.NET Blog

I still love Windows Forms and the designer. Sometimes some solutions are a bit hacky and the designer can do really weird stuff, but I can manage. I think, the standardized look and feel really works well for complex business applications.

WPF is nice for fully customized UI where you want your application to look modern, but xaml can really be daunting. And it's not only xaml, but that whole MVVM thing can be a nightmare to teach and stick to in a large team and project. Moreover you probably need some designers or an external company to design your UI's to really shine.

I would keep a close eye on MAUI [1] and where it will go. The Model-View-Update (MVU) pattern looks interesting and the cross platform aspect could be really nice.

[1] https://devblogs.microsoft.com/dotnet/introducing-net-multi-platform-app-ui/

Have you had a look at F#?

It has great GC piggybacking on the huge amount of efforts going into dotnet, each release since dotnet core has just gotten faster and faster, not just GC but many parts of the ecosystem, see e.g. https://devblogs.microsoft.com/dotnet/performance-improvements-in-net-6/

Pattern matching is first class. See e.g. https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/pattern-matching

I haven’t programmed with traits, but sounds like interfaces which you can have records implement.
https://gist.github.com/robertpi/2964793

Function signatures are usually not needed due to the type inference algorithm, so while it is statically typed, you often don’t need to write out the types of functions.

I think what he's saying is that instead of writing that in platform-specific C++ they could have worked on a Vector API and use that instead to automatically work in other (future) SIMD implementations of the same width.

A poster in another comment mentioned such API is being worked on, and what I described above is exactly how .NET is tackling this: they built a Vector API and are building optimizations like that in C# on top of that API, giving also developers the ability to write SIMD-oriented code in C# rather than resorting to platform-specific C++ and interop/JNI

In my opinion that's a better approach, it's discussed in great detail here https://devblogs.microsoft.com/dotnet/performance_improvements_in_net_7/

.NET Core did quite a bit of work on introducing "hardware intrinsics". They updated their standard libraries to use those intrinsics and let the JIT optimize userland code. .NET Core performance is pretty good, if not the best [1].

I have myself seen 2-3x improvements in older .NET applications migrating to the .NET Core (called just .NET from version 5 onwards). I think JITed code have a unique advantage here that any hardware-specific optimizations are automatically applied by the JIT, with newer versions of JITs bringing even more performance improvements when the ISAs change.

[1]. https://devblogs.microsoft.com/dotnet/hardware-intrinsics-in-net-core/

Edit: Added reference link.

Huh, reading from https://devblogs.microsoft.com/dotnet/welcome-to-c-9-0/ which was the first hit on Google shows the following example:

public data class Person(string FirstName, string LastName);

It seems https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-9 is saying what you wrote above though.

Seems my previous comment was based on outdated/wrong information, I'm sorry and thanks for clarifying :)

Edit: Seems the post I wrote was published 20th May (probably written before) and that was the same date someone said the same thing as my comment here in the discussion about the "records" feature https://github.com/dotnet/csharplang/issues/39#issuecomment-631572976

If you had to start over, would you still recommend to yourself to learn F# in 2022?

I am asking this as someone who has dabbled in functional languages (F#/ Haskell) multiple times over the years but, despite liking the elegance of functional code, never reached a level of productivity that came close to what I am used to from imperative languages. Specifically for C#, given the trend of baking more and more of the cool functional stuff into the language (e.g. [1]), I am wondering whether F# still has enough unique features to justify the effort.

[1] see e.g. https://devblogs.microsoft.com/dotnet/early-peek-at-csharp-11-features/#c-11-preview-list-patterns