The document outlines four pains experienced by developers when using traditional .NET development approaches: 1) Reliance on "magic" frameworks that can cause unexpected errors, 2) Builds that fail due to unpredictable dependencies, 3) Long edit-compile-test cycles, and 4) Rapid obsolescence of skills as technologies change. It proposes four guiding principles to address these pains: 1) Using direct queries over ORM "magic", 2) Ensuring predictable, reproducible builds and environments, 3) Shortening feedback loops through techniques like hot reloading, and 4) Focusing on reusable skills rather than specific technologies. The overall message is that prioritizing business needs over technical wizardry and automation can help developers work more efficiently

1. Pain-driven development
Alexandr Sugak,
.NET developer/architect at Sigma Software,
Kharkiv F# User Group

2. About me
 32 years old;
 Programming for ~12 years;
 Did mostly .NET;
 Worked on Web and Desktop apps, DBs, Web/Win Services, IDE plug-ins,
SPAs, mobile apps, integrations;

3. About me
 32 years old;
 Programming for ~12 years;
 Did mostly .NET;
 Worked on Web and Desktop apps, DBs, Web/Win Services, IDE plug-ins,
SPAs, mobile apps, integrations;
 Never liked it.

4. Agenda
 Pain #1 -> example(s) -> Guiding principle #1;
 Pain #2 -> example(s) -> Guiding principle #2;
 Pain #3 -> example(s) -> Guiding principle #3;
 Pain #4 -> example(s) -> Guiding principle #4.

5. How we do .NET today
Platform:
 Windows;
 IIS;
 MS SQL Server;
 Azure.
Technology:
 C#;
 ASP.NET
MVC/API;
 Entity Framework;
 WCF
 Angular.JS.
Tools:
 Visual Studio;
 R#;
 NuGet.exe;
 TFS;
 TeamCity.
Libraries:
 AutoMapper;
 Json.NET;
 Log4Net;
 Rhino Mocks.
Architecture:
 3-Tier;
 DDD “Light”;
 SOA;
 Microservices.

6. But now we have .NET Core and a new
open-source MSFT, right?

7. But now we have .NET Core and a new
open-source MSFT, right?
https://github.com/NuGet/NuGetGallery/pull/4437
Wrong

8. .NET Core + Linux =
 C#;
 ASP.NET Core;
 EF Core;
 SQL Server for Linux;
 Visual Studio for Mac;
 <something> Core;

9. DISCLAIMER
 Subjective matter!
 You will have your project’s requirements;
 Not every project is a “green field” project;
 This is not about “all new shiny things are better”.

10. Pain of using “magic” frameworks
 You install NHibernate;
 Everything works as expected;
 You create your first entity – so far so good;
 You create second entity – it doesn’t work;
 You spend 3 hours to understand that the problem is that your new entity
has “Date” property and it is not escaped in generated T-SQL.

11. Principle 1: direct SQL queries (Dapper)

12. Principle 1: direct SQL queries (F# +
ADO.NET)

13. Principle 1: direct SQL queries (Go)
https://github.com/jmoiron/sqlx

14. Principle 1: Request -> Response
https://suave.io

15. Principle 1: Request -> Response
https://golang.org/pkg/net/http/

16. Principle 1: “less magic”
 Avoid accidental complexity at all cost;
 Magic things: ORMs, AOP, overuse of conventions, code generation,
reflection etc.;
 Willing to trade some effort for the full control over solution.

17. The “it works on my machine” pain
 You do the change and test it locally – it works;
 You push your changes to repository;
 CI build fails with “Cannot load an assembly”;
 You spend next 3 hours trying to understand why.

18. Principle 2: predictable builds

19. Principle 2: locking dependencies
Package Manager Platform Has lock file?
Paket .Net
Nuget.exe .Net
Npm JS
Yarn JS
dep Go

20. Principle 2: configuring IIS
http://tavalik.ru/ustanovka-wordpress-na-iis/

21. Principle 2: configuring nginx

22. Principle 2: predictable state
 Reproducible builds: “single script to rule them all”;
 Transient dependencies, lock files;
 Immutable servers/infrastructure;
 Configuration-driven environment.

23. The “edit, compile, wait, repeat” pain
 You do the change to the model/view/controller;
 You compile your 35 projects solution - 30 sec;
 You reload your browser and wait for:
 IIS to reload the app – 5 sec;
 Your app to initialize – 15 sec;
 The page to load – 2 sec;
 You manually restore the page state – 5 sec;

24. The “edit, compile, wait, repeat” pain
 You do the change to the model/view/controller;
 You compile your 35 projects solution - 30 sec;
 You reload your browser and wait for:
 IIS to reload the app – 5 sec;
 Your app to initialize – 15 sec;
 The page to load – 2 sec;
 You manually restore the page state – 5 sec;
 And it did not work;
 Repeat.

25. The “edit, compile, wait, repeat” pain
https://faculty.washington.edu/ajko/books/cooperative-software-development/history.html

26. Principle 3: File watchers

27. Principle 3: React hot loader

28. Principle 3: next level
 Not just time travel, I want to observe changes across time at one glance;
 Not just hot reload, I want to see changes for all states, on all pages;
 Visual programming?
 Programming by example?
 See Bret Victor’s work, e.g.
http://worrydream.com/#!2/LadderOfAbstraction

29. Principle 3: build feedback
 Run entire test suite on every commit;
 Run all linters on every commit;
 Deploy 10 version of the app per day;
 Receive notifications on every failure: Slack integration for CI builds and in-
app critical errors;

30. Principle 3: shorten feedback loop
 As a programmer, I want to see the effect of the changes I do
immediately so that I could be more efficient;

31. The “your skills are now obsolete” pain
 You start as a .NET programmer in 200X;
 You learn ASP.NET Web Forms: the event model, the View State, the Ajax
Toolkit, etc.;

32. The “your skills are now obsolete” pain
 You start as a .NET programmer in 200X;
 You learn ASP.NET Web Forms: the event model, the View State, the Ajax
Toolkit, etc.;
 Time passes, you are in the 201X;
 You now have a part of your brain that is forever lost.
How to disable
ViewState
https://commons.wikimedia.org/wiki/File:Brodmann_area_45_lateral.jpg

33. The “your skills are now obsolete” pain
 You start doing SPAs in the 201X;
 You learn AngularJS: the template language, the directives, the custom
HTTP client, etc.;

34. The “your skills are now obsolete” pain
 You start doing SPAs in the 201X;
 You learn AngularJS: the template language, the directives, the custom
HTTP client, etc.;
 …
 See the pattern?

35. Principle 4: things I cannot reuse
 WebForms;
 WinForms;
 SharePoint;
 Visual Studio + R#;
 AngularJS http client;
 “Click to deploy to Azure”;
 and many more.

36. Principle 4: things I can reuse
 JavaScript;
 Object Oriented/Functional programming, SOLID;
 Event-driven/reactive systems;
 Web, http, networks;
 SQL;
 Emacs/Vim;
 Actor Model;
 Stream Processing;
 Machine Learning;
 Statistics;
 UX;
 And many more.

37. Principle 4: Reactive Extensions
http://reactivex.io/

38. Principle 4: composition and reuse
 As a programmer, I want to be able to reuse the skills and knowledge I
have when working on a new project so that I could be more efficient and
be in demand on job market;

39. Summary
 Business value first, technical wizardry second;
 Automate all the things!
 Do not make compromises with technology, ask for more!
 Learn how to build systems, not how to use frameworks.

40. What are your Principles?

41. https://www.facebook.com/groups/kharkivfsharp/

42. Thank you!