.NET Core is fantastic. I recently bought an M1 Macbook Air (which I really hadn't wanted to do but my Intel Macbook died and I wasn't about to buy another Intel Mac given they are being phased out.) There's one issue in that debugging is broken at the moment, but it's being addressed by Apple/MS. Docker (M1 Preview) works great.
If you've never given .NET a shot because you weren't/aren't a fan of Microsoft/Windows - I recommend you give it try, you might be pleasantly surprised.
Hadn’t used Windows in years and that was my first exposure to PowerShell, which made me feel a little better about Windows.
Grew to greatly appreciate C# and .NET over the years and am now fairly optimistic that Microsoft has made a lasting change after seeing the steady, dramatic improvements that they’ve been making technologically and sociologically (embracing open source, cross-platform support, and putting their money where their mouth is).
Highly recommend that curious people install Windows 10 on an external HDD to try out WSL, Windows Terminal, and PowerToys Fancy Zones. I use Linux for my personal machines, still, but Fancy Zones has honestly had me missing the ease of desktop layout when I switch off my work machine.
Or, if you are just looking to explore C# and the dotnet ecosystem, then you can do that from the command line on most non-BSD operating systems.
Powerful, consistent, feature-rich. Coming from a python, java, web background, was really blown away. Wish more people would give .NET a chance. It isn't like it used to be when I first tried it in College and hated it.
.NET is in the corporate world but you'll have a harder time finding a .NET-related job if you don't already know stuff about it.
Since I don't currently use windows and I don't casually want to build a corporate type of software on another system in my free time (I'd much rather fold some origami, I'm likely one of the people that aren't called "passionate" about dev), I didn't get to be exposed to it easily - unlike "typical" web and mobile-related languages for example (Java, Obj-C/Swift, JS). Some of it might have been shown when I was a student (Java), and other things are just requirements of the times (I want to try making a mobile app -> either web or native languages). Didn't see .NET at university, and early jobs didn't involve that, so now it feels like a missed train somehow.
Is it worth focusing on when you're not already living in that ecosystem and you're on your own?
A skillion years ago I had to do a .NET project and somewhat randomly chose VB.NET as the language over C#. However, I did buy some C# books which I never looked at. Given that the books are now about a decade old, is there any point in keeping them? Has C# changed enough in the years that the language is sufficiently different from what was created in the book that I might as well pick up a newer volume?
I tend to gravitate toward stability in languages. Something of a flaw of mine.
Performance is generally great and if you need to, there are lots of features in the language to allow you to further squeeze performance. C# is easy to pick up and has best-of-breed IDE support- you will get productive quickly. Also, you have an extremely large standard library at your disposal that is supported and dogfooded by Microsoft. Which is great because generally you do not need to install third party packages, but if you do NuGet is really easy to use.
Edit: Forgot to mention the stellar documentation provided by Microsoft.
My 2nd favorite feature is Self-Contained Deployments [2]. We skipped the whole containerization party because this approach completely obviated our need for such things.
Beyond that, being able to seamlessly transition between imperative & functional members within the same type, pattern matching in switch statements [3], on-going awesomeness of LINQ, etc. Really great stuff to work with.
[1] https://docs.microsoft.com/en-us/aspnet/core/blazor/hosting-...
[2] https://docs.microsoft.com/en-us/dotnet/core/deploying/#publ...
[3] https://docs.microsoft.com/en-us/dotnet/csharp/pattern-match...
The only thing I'm not entirely sure about is the recent direction of C# to add loads and loads of syntactic sugar, which reduces the amount of code you have to write but I find the code becomes so terse it's hard to glance and reason with, but that may be just because it's quite new.
Specific syntax for patterns makes intention more clear, and shifts responsibility for getting it right from the developer to the compiler.
I have no doubt that some of this newer syntax is clever, and very welcome to many, but not everyone will realize that it's far more beneficial in the long term to cater to the common denominator.
well some is necessary. example: init-only-Setter, was impossible to do before. You could not write the same Code, without it. No matter what you did.
using declarations where also necessary to increase readability.
and nullable reference types also were important!
I've seen people say one of Java's biggest benefits is being boring and staying consistent. I disagree. C# (sometimes all of .Net) consistently adds new features that keep the language feeling modern. Properties are a great example.
The big thing I'd love to see in C# now is sum types, but I'm not holding my breath.
https://docs.microsoft.com/en-us/dotnet/csharp/tutorials/exp...
Having cut my teeth on C++ and being reasonably familiar with Python, I'll choose C# for anything larger than a script that doesn't need direct memory layout control.
Deployment story is still a bit of a pain sometimes.
The truth is, languages rarely have an impact on the success or failure of a project. The reason some companies blame failure on language is because the organization fails to adequately adapt its procedure to the tools it uses.
Starting on a fresh language and not getting involved in the community because a dozen pizza to host a meetup every 3-4 months is too expensive? You're headed for trouble.
Going for a new stack and letting poor management drive away the team? Even with a mainstream language, the hit you're going to take is going to be huge.
Willing to rewrite old code but not interested in giving people time to adapt and learn? Good luck.
The only difference between languages like Java or C# and Clojure or F# is that it's much harder to blame the former for organization/process issues.
I'm not saying that languages don't have an effect on productivity or dev experience, I'm saying that effect is way less important than other factors, and as a consequence, it's rarely the factor that tips the scale.
Yes, that is what killed F# effectively - on top of not having any killer frameworks. Though to be fair even Scala is dead. Making a language popular is tough.
F# has been an unwanted child of Microsoft, it actually adopted the language from Microsoft Research. As a language, F# is _very_ good (although not as good as the original OCaml, whose features had to be cut to be able to run on CLR). It's just not first-class citizen, so not everything may work with F#. And F#'s own development and features are blocked on CLR -- instead of F# charting its own path, each feature first has to be available for C#/CLR and only then will F# developers implement it (higher-kinded types are just one example).
But it's still much more pleasant "syntactic sugar to write the CIL bytecode" than C# can ever be.
> even Scala is dead
I beg to differ! Thankfully, Scala is very much not dead. Scala 3 is around the corner, with many more features and, even more importantly, several simplifications. And the community is also much larger compared to F# (or any other ML language, like Haskell). Innovation also takes place in the realm of libraries, like ZIO for example.
And here I am happily using it for greenfield projects, interfacing with popular ecosystems and just generally getting things done!
Right now it really feels like F# is taking off. It is bundled with .NET Core, fully open-source, has a better REPL experience with Nuget integration, Ionide and Fable just had a new releases...
It was very easy to integrate - I've finished a POC with a lot of functionality rebuilt in just around 2 hours.
We had two issues that we spent quite some time on, though: 1. When jumping a lot from video part to video part, especially if reading movie files from NAS, we've seen the component hanging - the only way to automatically recognize it hanged was to parse warning logs and restart the component forcibly. 2. Lack of native per-frame backwards movement. It is video player, not video editing component, and there is only a way to move backwards a few frames at a time by slowly changing current position.
I have 4 options, Xamarin, UWP, Winforms, WPF. As non-Windows dev, which option is going to be my best options with the best support in the future? How do these relate to WinUI? Also, what's project Reunion https://docs.microsoft.com/en-us/windows/apps/project-reunio... ?
Let's not forget react-native-for-windows. Where does this fit into the above scheme?
If you'd rather have a book, and enjoy the Head First series, the 4th edition of Head First C# will be released on the 26th: https://www.amazon.com/Head-First-Learners-Real-World-Progra...
As for UI, on Windows, all but WinForms/Xamarin Forms use the same "layout language" called XAML - it's just different ways of distribution/platform compatibility tied to more or less different APIs.
For traditional Windows apps, you would be using WPF and that's what a lot of modern Windows apps are built on. That's probably what you want to use and the Windows apps I've made have been a pleasure to work with, especially due to their hot reloading and design tools.
For "Store" apps, you would be using UWP, which are the "modern UI" apps you see when you use Windows 10. These can run on any Windows 10 version and Xbox One+. You can also make that style of app with WPF by theming it though.
Xamarin is now mostly used for mobile .NET development, but I really can't recommend it nowadays as there's a lot of cruft and documentation, in comparison to the stellar work MS has been doing, is quite lacking. If you need to reuse .NET code in your mobile apps, it's there as a way for you to do that.
"Project Reunion" which has key pieces in .NET 5 (including and especially the new C#/WinRT projection system, which replaces dark/magic .NET internals with NuGet packages) is entirely blurring the line between WPF and UWP. With WinUI 3 you can use all of the modern UI controls in WPF apps (and in WinForms if you're nasty). You can also package WPF apps for the Store, including opting into UWP sandboxing and security models (though not yet far enough that you can run WPF on the Xbox yet). (The ability to package WPF, WinForms, and other Win32 applications has been around for some time, in fact, that's not specifically new. Project Reunion has roadmap features to keep making it a better experience, though.)
> Xamarin is now mostly used for mobile .NET development, but I really can't recommend it nowadays as there's a lot of cruft and documentation, in comparison to the stellar work MS has been doing, is quite lacking. If you need to reuse .NET code in your mobile apps, it's there as a way for you to do that.
Upcoming .NET 6 will see Xamarin merged closer/deeper inside and the cross-platform pieces (currently named Xamarin.Forms and Xamarin.Devices) rebranded MAUI. Presumably that will also involve a lot of spring cleaning out of cruft and upgrades to the documentation. There's also roadmap talk of much more desktop support beyond just mobile (people wanting to share code not just between Android and iOS, but also Windows, macOS, and Linux).
The newer idea of middleware pipelines in ASP.NET do a good job of hiding some boilerplate and there are even libraries like Flurl or Polly (which is now officially a part of .NET, itself) that reduce the code you have to write for things like http requests and resilience policies.
I ended up in a C# role by chance coming from a non-software background and it can often feel like a separate world; so many discussions in the other ecosystems just feel less relevant since C# is so batteries included you rarely have to venture outside the confines of the officially mandated environment.
While there's a lot of stuff in the corporate environment on Windows servers and old full-framework code there's also a healthy and growing Linux first community using .NET.
I don't know that I'd recommend it particularly from outside if not trying to start a .NET role specifically, I don't think (based on the languages you list having experience with) it will help you learn anything particularly new, in the way that learning a functional language does for someone with an OOP background. Though LINQ is quite a nice way for people unfamiliar with functional programming to ease into it from an OOP environment.
With .NET 5 / dotnet core the getting started is easier than it used to be (thanks to dotnet new https://dotnet.microsoft.com/learn/dotnet/hello-world-tutori...) and a lot more like other languages/frameworks, but without a specific aim I think it's going to be hard to be motivated to get in-depth with the environment.
To be clear I wouldn't want to work in any other language or framework (though React with functional components and TypeScript comes pretty close to the developer experience quality of C#/.NET) but I'm just not sure how porous the ecosystem boundary is and how transferable the skills are.
Of course, there’s lots of room to grow towards that goal.
if (expression is {} val)
Is the right way to code, even if it looks ugly.
I have been programming in F# full time for the past 7 years and I hope that rumours of its death are greatly exaggerated. Perhaps this comes from a point of view that if something is not growing 10x each year is dead?
It's not a JavaScript framework that has an average lifespan of a couple of years. It's a fully featured, complete, very productive language that makes programmers life easier and more enjoyable.
From that it's just standard Docker - it doesn't matter that you are running .NET core in it really. You can do anything you could normally in Docker and K8S.
Also some libraries changed around a bit during the transition to .net core, so some the code in your book may not compile.
Finally, if it's a book about web dev (asp.net) or something similar (mobile dev, game dev), that stuff has changed a lot over the past ten years.
You're probably best of ditching the books and hitting up some tutorials or checking with your local library. My public library gives us access to safari books online which has a large selection of technical books.
If so, it isn’t just sugar, they added a new hook for it in the internals, rather than just relabelling a technique to accomplish a similar (but not equal) end.
actually record types are more syntactic sugar around what you said than initonly, which opens up a new way of writing code