In my experience, C# and .NET are both "underappreciated" in a large part based on the legacy.
Some folks out there still think .NET is Windows only. Some folks out there haven't looked at C# since the .NET Framework days. Some folks out there are still salty about some of Microsoft's decision around OSS (debugger, hot reload fiasco, etc.)
But day to day working with C# and .NET for backends? It's really fantastic. AI seems to like it a lot and a lot of tools for agents to go HAM. Roslyn analyzer, source generators, tons of really good docs from Microsoft, generally low variance and high consistency (e.g. Drizzle vs Prisma vs TypeORM vs Kysely vs ... in Node land).
My previous team switched from TS to C# and F#[0] and it was a blessing; a lot of the platform ops have been simplified. It's just one very solid tool chain and packages are generally stable. First party packages get consistent security updates.
C# feels like a really solid choice in the age of AI coding because of it's general stability, strong static analyzer, insistence on types, and really good tooling.
C# was my 2nd programming language after VB6. I remember in the early 2000s when I was 12, using my best friends computer to try and download VB .NET (he had faster internet) just because it was free, then being extremely disappointed when I couldnt just run my VB6 projects I wanted to run on it... Some years later, during 2007 ~ 2009 I tried out C# and that was life changing.
I wound up going to college after working retail at Disney, then after college, my first job was supposed to be C# but they didn't have the project approved, so I got my first exposure to Python - which I loved, then JavaScript - which I hated but have a love-hate with to this day, and finally C#, but it wasn't .NET 3.5 no, they started using .NET Core, which was... something else, lots of teeth pulling during the original .NET Core days.
So many wonderful projects made with .NET my only complaint is I wish Microsoft would make a cross-platform GUI stack they'd actually stick to, and make it work on Linux too. ;)
I know there's alternatives but nothing beats telling your coworkers "lets just use the built-in" when choosing a GUI stack.
We abandoned .Net years ago before our third major product rewrite prompted by withdrawal of various bits of tech they said was the next greatest thing. AppFabric, WWF, WCF and Silverlight hit us hard.
That's fair enough, but the dust has largely settled on dotnet core. The death of Silverlight was long ago. I think the only thing at risk of abandonment is the native UI situation, which is a mess.
Hard to say what's native in Windows anymore. I imagine Win32 APIs and more recently Windows App SDK?
The most supported UI frameworks from MS for Windows are WPF and WinUI 3. UWP is dead and WinForms (even though closest to something native to Windows) is probably going to end up in the land of forgotten (sorry nostalgic Windows devs, you have to face it eventually).
A "mess" is an understatement when the people who themselves develop Windows desktop apps have trouble explaining the landscape.
I used to be in the anti .NET camp but for Enterprise applications .NET has been delightful and upgrading between versions has been trivial since .NET 6.
So about that... when I started using .NET Core, it was bleeding edge and shiny, but it was to rewrite a Silverlight application, the only way to run it was Firefox ESR 54 (I think it was 54?) we thought "oh this is easy" only to find out that it was a colossal nightmare, EF didn't support some things, including Shapefiles, we had to force the support, get back a WKT from SQL Server, and send one back when we did updates, basically Entity Framework was mostly useless.
I also reverse scaffolded the existing database into EF compatible classes, so that saved us a ton of effort, the original idea was to be backwards compatible.
Best part? It never got used, when we found out they weren't using the project, my boss said, screw it, lets remake it in Python I know we can build it up quicker, and sure enough, it was done quicker than the C# rewrite, fastest rewrite I ever did, because he figured out the key things they actually needed, and trimmed the requirements to just those key things.
Sometimes rewrites don't need to be 1:1 especially if it's an internal only tool.
Anyway, lots of blood, sweat, tears, stress, etc from me as it was my first job in tech.
Boy do I have good news for you (I am half kidding). OpenSilver project lets you compile your Silverlight code to Web Assembly or iOS/Android/Windows/Mac.
WCF had some good ideas and if you followed its best practices migrating to other networking stacks should have been straightforward. Delete your complex Bindings XML configs and just write implementations of your Contract interfaces and figure out where you need to dependency inject the new implementations. If you were deep enough into WCF you might have even had mock implementations you could bootstrap from.
That concept of "define an RPC interface and let the platform fill it" was ancient before WCF and continues to this day (I've got a bunch of tabs open for Cloudflare Durable Objects right now). The legacy problem with WCF was not but long term backward compatibility with the Bindings abstractions and XML config junk and SOAP Stack RPC. Without WCF native in the box in .NET 5+ it is harder (but not impossible) to build SOAP RPC monoliths. But so few businesses actually need SOAP and can't just switch to something more RESTful.
Silverlight was maybe ahead of its time given the growing popularity of Blazor WASM.
I'd be okay with this, I'd also be okay with MAUI (which... is a whole behemoth of how to make UIs), but anything, hell I would take them porting WinForms somehow into a cross-platform .NET thing that runs everywhere (Mono used to!), I just want anything at this point.
XAML was supposed to become an open spec, not sure why they have so many teams making so many different ways to make UIs. Then there's those "Windows 8" apps, or the "Universal Windows Apps" which are poorly named, you cannot run any of them on previous versions of Windows, if anything Win32 apps are universal apps.
Awesome stuff, as usual in .NET releases! The runtime async support is surprising to me... I get that stack traces are more friendly without state machines in the code, but I didn't expect they could switch to a runtime version and have equivalent performance. Cool!
Seems to be a gift of the modern CLR cycling faster with each release since .NET 5 versus the backwards compatibilities the runtime used to have to keep in .NET <= 4 because the same runtime would power multiple versions at a time of the compilers and BCL above it. In the old world "Framework" days after the CLR made the huge changes from 1.0 to 2.0 (for generics and other things) it seemed almost "afraid" to add features, especially for things that compilers could support themselves. The .NET 5+ CLR makes fewer "forward compatibility" guarantees as it now assumes it cycles directly with the compilers and that most deployment methods "bake" the CLR version with the application.
There have been smaller runtime improvements like this one in recent releases, but this one seems a big one to point to to prove that the runtime is truly growing at a faster and more interesting pace than the old days.
They don't need to mark functions as needing special compilation / rewriting to support asynchronous use since the runtime provides the necessary mechanism to pause and resume (e.g. stackful continuations). So 'async' is unnecessary and 'await' can be a library function (or remain a keyword of course).
I feel like they've done a lot to resolve a lot of the confusing versioning and runtime compatibility problems that drove away non-Windows developers from using .NET.
However they still suffer from an incredible branding problem.
It's really too bad because as a runtime it's fairly incredible, and F# in particular is fun to work with. They also have good cross-platform support and tooling, which they didn't have a number of years ago.
Combine that with the fact that nobody really writes code anyway thanks to AI, and this could be a slam dunk runtime for an AI-native development environment.
> ...this could be a slam dunk runtime for an AI-native development environment.
I wrote this in my other comment, but I really think that C# is an underappreciated language and tooling stack for AI.
- Roslyn analyzers
- Simple, stable tool chain
- Language has largely been stable and backwards compatible for the two and half decades of its existence
- Now have a very, very good type system that promotes good practices
- Very good corpus of docs
To all the .NET outsiders, C# is indeed the .NET darling but you can also use F# if you feel like living in the future. Or VB if you feel nostalgic. So in .Net land, C# is not destiny. It is a choice
I feel like VB is a "better" Python for beginners and F# is a much better Python for data scientists.
The tooling ecosystem in Python is just so bad that I can barely stomach it after spending the last 20 years in .NET. At times, when supporting analysts at work wanting to write a little glue code, I've found their main complaint about C# is "curly braces" (which seems like a really odd thing to complain about, but ok) and I've found it easier to teach them a little VB than to figure out whatever the hell is going on with dependency and runtime version management in Python.
And then, for the folks who go deep on Python for ML tasks, I've mostly found them caring now about specific libraries than the language itself. I then show them how .NET has equivalent or better libraries available and that a lot of the code-golf stuff they do in Python has a much cleaner version in F#.
> .NET 11 is a Standard Term Support (STS) release with two years of support under the .NET support policy. STS and Long Term Support (LTS) releases have the same quality and servicing policies; the difference is the length of support. .NET 10 remains a supported LTS option. Stay current with servicing updates whichever release you choose.
They burried the lede on this one.
- .NET 10 is end of life'd on Nov 14th, 2028
- .NET 11 is end of life'd on Nov 9th, 2028
Which means anyone who upgrades to 11 has fewer days of support. But the idea is that you'll upgrade to 12 as soon as it's RTM'd.
The problem with that is I have clients who refuse to budge from 2.1 (or even upgrade to the 2.1 re-release: 2.3).
Nothing new to comment on here. MS has been open about its long term and short term releases based on even and odd numbers. Unsurprisingly, there's a web page that explains it https://dotnet.microsoft.com/en-us/platform/support/policy
This whole thread is a bit of a tangent, but I'm not sure the STS/LTS distinction makes much sense for the end user. STS gets a relatively generous 2 years of support (cf. Java at 6 months) while LTS gets a relatively anemic 3 years of support (cf. Java at 8+ years [1]). Plus, with yearly releases, every LTS expires at the exact same time as its successor STS. Are STS releases generally less stable or more experimental than LTS releases? Otherwise, this feels like a valueless distinction.
Does runtime async mean stackful coroutines? It's not obvious what exactly the state machines are replaced by, if not automatically inserted yield() calls.
I took it to mean that coroutines are still stackless but that yielding is now an operation the runtime knows about instead of being compiled out by the compiler.
For the features that overlap between golang and .Net, can someone please let me know why people choose .Net over golang for non legacy systems? As far as my limited knowledge goes, go is much more efficient in syntax and memory.
The languages are very different. C# has much more powerful abstractions and is a much larger language in general. That is both an advantage and a disadvantage. Modern C# is also very fast, I wouldn't bet on Go winning that comparison.
My experience with Go is a while back, before it got generics. While I liked the overall idea of a language with little syntax and a focus on simplicity, I didn't really like Go in the end. It was a weird mix of too low-level and high level code. It exposed low level details that I don't need to think about in C#, and it is missing convenient abstractions like LINQ.
Personally, I like async/await in C# more than Go concurrency. I know this is heretical here, but I don't care about function coloring or any of the abstract advantages of other concurrency approaches. Async/Await in C# works for me (in non-legacy code) and is easy to understand.
the main problem with the .net async/await is the immediate execution of a call returning a Task, without control over where it may execute. F#'s asnyc was way saner and easier to understand in my opinion.
I'd beg to differ on the easy to understand... last time i worked with this stuff like ConfigureAwait only has cargo cults and no real good explanation, and wasn't covered in any recent version of eg. CLR via C#... Distributed tracing and thread management were totally bitten by async, also the way iterators and LINQ were broken... that was when I got off the train, as it broke the best abstractions for line of business code so that instead of designing an IO pipeline lazy developers could simple put Task.Run around blocking IO calls at the bottom of the codebas, and ... yeah, we are back at function coloring.
This brings me to: I winder for what kind of apps did you find it a delight, because for extensive data wrangling leveraging multiple calls it was a pain.
You don't need ConfigureAwait() at all in modern C# (unless you're writing desktop UI code, I don't know enough about that to comment there). In a modern ASP.NET Core web application you don't care about which thread your Task executes, there is no synchronization context at all.
I'm using C# for the backend of a web application, not legacy but .NET Core from the start.
Indeed, you need a crapload of ConfigureAwait() in desktop UI code, and it infects all underlying libraries that might have to run inside a desktop app. The worst thing they ever added to our beautiful language. It's a dream to work in ASP.NET without needing to pepper every await with a ConfigureAwait().
That said, I don't agree with the characterization of ConfigureAwait() as un-understandable. We understand it. We just hate it.
Sometimes you do care where it executes, and then it starts to become a problem ;).
Something which was as easy as an IO call in the middle of a function running on a thread pool becomes a PITA if the IO call is cleverly async-ized (by wrapping the original sync IO method into a Task.Run(), but actually this is the better case!) ad then removed from the public API... (cannot recall the exact library, but it was a pain, as it was some core stuff, maybe vendored by MS themselves)
Also back then it caused us loosing correlation IDs as those were thread locals in traditional pre-async ASP.Net Core (think version 0.9-2.0 when I worked on that part, then up until core 4 and the async mania continuos broke readable calculation code in LINQ, TPL based performant data pipelines, etc...) and with async execution started to migrate between threads... If you needed high performance you already used threads, because it was not a classic web application, but a specialized optimization algorithm with a web api... and if you need more than CRUD, and use all the cores (and SIMD) to squeeze out all performance you have, you hit these problems right away. These all could be solved, but it actually broke stuff, a lot of stuff, as developers jumped on the fad, and it their sync code was turned into a .ConfigureAwait(false /* Microsoft blogs talk a lot about it without a clear explanation, so every cool kid does this */).GetAwaiter().GetResult()... then you some of your threaded code silently broken if you dare used Thread Locals... Faded memories, but that was when they f'ed up the C# language.
That's why I emphasized modern .NET. All I/O should be using async methods through the entire application. Wrapping sync code in async causes troubles, but that is entirely avoidable in new code. That's the price you have to pay to make this particular abstraction work well, everything I/O must be async.
Go is not much more efficient, compared to NativeAOT - though it can be faster in some areas. The big reason why someone would want to use C# is that it's a more expressive language. You can even write your DB queries with LINQ (C# lets you express code as data), making them type-safe.
Modern .net is surprisingly performant while also being very high level if needed. So it is very close to being a "learn once" ecosystem. This means you use it to write code for a much broader range of usecases than others, you will have a broader / more mature ecosystem than others, and your potential hiring market is more vast.
Based Hopac enjoyer. I built the Spiral's language server using it. I have to admit though that these days I just use native .NET channels for all my message passing needs.
I know it's not quite as important in the agentic world, but the .NET tooling (across Visual Studio, JetBrains Rider, and C# Dev Kit for VS Code) is just awesome. Some people might frown upon full-blown IDEs, but sometimes they're just incredibly handy.
Put things like their remote debugging experiences side-by-side and you will quickly learn why some of us go for the Microsoft tools rather than the others.
Exactly C# with .NET is batteries included type of ecosystem where most of stuff is done by Microsoft and if someone is experienced with the stack he can whip up enterprise ready app in no time.
I don’t have much experience with Go lang but what I have seen, there is lots of things one has to implement on his own. Which has its own merits, but to go from 0 to full fledged enterprise app you need more time.
I'm not a .NET person by any stretch and have been more of a Go person traditionally, but I think from what I've seen IRL, this is accurate.
Go is trying to be like C. Less language features (until recently...), so to solve problems you write more code. Intentionally simple language. Intentionally need a lot of code to implement something substantial. .NET seems more frameworks driven. Go traditionally has eschewed frameworks for doing stuff much like C tends to eschew framework type stuff and prefers smallest dependency reliance as possible.
Go still has a better deployment story. Single static binary deployment are king. On .Net 8 I was hitting random compatibility issues with single binary application bundles, with System.Data.SQLite, and other libraries. (had to use that one and not he Microsoft one for some legacy compatibility reason, maybe around Guid handling maybe)
Every new release of Go brings some of the features that have been available for twenty years in .NET (and every other language), like generics. Some features, like ergonomic error handling (whether or not you think unchecked exceptions are a good idea), Go has said will never be available. There isn't much to recommend about Go. It's fast to do the mediocre thing, faster than any language, but for a serious code-base intended to be maintained long-term, C# has better libraries, established patterns and frameworks, abstraction features, developer ergonomics, etc.
Compare the ecosystems of .NET vs golang. No comparison whatsover. IoT, mobile, web (front and backend), cloud, etc. I think Go lacks variety and is more focused on traditional greybeard areas.
I'm going to talk about the second part first. .NET is often deployed with a JIT compiler runtime like Java. That means that hello-world scripts use a lot more memory than Go, but that difference becomes a lot smaller on real-world programs and .NET can use less memory than Go depending on what you're doing.
C#'s concurrency can also be more efficient than Go's since it's coroutine based async/await is a lightweight state machine rather than green threads. That's not to say Go is especially heavy or anything, but it is more overhead.
In terms of "efficient in syntax", Go has a lot fewer features. That's one of Go's biggest strengths and weaknesses.
Here's an example. With Go, you just have struct tags: strings of anything that can be attached to a field in a struct. Let's say you have a User struct and you want to make it so the JSON won't have the user's email in it. You do: Email string `json:"-"`. But what if you mess up and write "jsom" or `json:-` without the quotes? It's basically a meaningless string to the compiler. With C#/.NET, you have annotatons/attributes that are a part of the language and checked as types. You'd do: [JsonIgnore] public string Email. JsonIgnore is an attribute class so your IDE can help you.
There's a lot in Go where the answer kinda becomes "f-it, we'll just use strings instead of having something meaningful." Go talks about how important error handling is, but then you get an error from a function and it's basically just a string. If you're doing good error handling, you want to handle different errors differently, but that's not easy in Go. Frankly, it's not easy in most languages, but this is definitely an area where it felt like Go gave up on creating something good in order to get something out the door quickly enough that Google didn't cancel the project. In a language like Zig, errors are enums and you get exhaustiveness checking. With Go, someone could add another error state to something you're using and you'd never know - or they could change the phrasing of an existing error and you'd silently stop matching on it.
Go's lambda syntax is clunky. func(x MyType) string { x.ToString(); } vs (x) => x.ToString()
There's lots of stuff like that. I'm not arguing that Go is bad, but it has a ton less stuff and that's both a blessing and a curse.
There's one (usually minor) caveat here, which is around strings. In .NET, like Windows*, strings are UTF-16. If you call into native code that uses UTF-8 strings extensively, then they have to be marshalled (when passed to native code) and unmarshalled (when received from native code), which takes additional time and memory. I've run into this lately, which has led me to write special CStr/CString types (idea borrowed from Rust) to avoid unnecessary, especially round-trip, (un-)marshalling.
* = Technically, Windows now supports the UTF-8 "code page" where applications can use UTF-8 natively, but all NT system calls use UTF-16, so the conversion still has to happen somewhere
C# in .NET 11 adds support for UTF-8 string literals (`ReadOnlySpan<byte> str = "Some sample string."u8;`) which is a step to making such interop easier.
The Runtime has explored attempting "UTF-8 native" string storage as a platform feature especially for Linux FFI, but yeah Windows using UTF-16 is still a compatibility issue where platforms themselves just don't agree.
Well for me, that's like asking why don't you write everything in Erlang rather than C#.
Go is for me just a, hmm, concurrency programming language. Its popularity stems just from being pushed by Google, and the cosmetics of using braces. Despite what pundits say, it's completely and utterly not like C.
While C# is a successful and comfortable everything-language. It is blazing fast, has amazing tooling, you can get going to prototyping, then enterprise code, its serverside handling is excellent. It has many low level features and built-in data structures. It's I would say preferable for almost any kind of work except scripting. (I really don't like C# scripting.)
In addition to what the others have said, I also enjoy the extremely robust ringtone reflection system in .NET. I don't know of any other systems that provide more complete detail. Maybe Java, though it's been a while since I've used it. It makes reflection in other languages feel prehistoricaly primitive.
C# is a really great language, and I hope I can keep using it. I like Microsoft’s ecosystem, but personally, I’d like to see its cross-platform support strengthened a bit more.
Some folks out there still think .NET is Windows only. Some folks out there haven't looked at C# since the .NET Framework days. Some folks out there are still salty about some of Microsoft's decision around OSS (debugger, hot reload fiasco, etc.)
But day to day working with C# and .NET for backends? It's really fantastic. AI seems to like it a lot and a lot of tools for agents to go HAM. Roslyn analyzer, source generators, tons of really good docs from Microsoft, generally low variance and high consistency (e.g. Drizzle vs Prisma vs TypeORM vs Kysely vs ... in Node land).
My previous team switched from TS to C# and F#[0] and it was a blessing; a lot of the platform ops have been simplified. It's just one very solid tool chain and packages are generally stable. First party packages get consistent security updates.
C# feels like a really solid choice in the age of AI coding because of it's general stability, strong static analyzer, insistence on types, and really good tooling.
[0] https://engineering.usemotion.com/moving-off-of-typescript-e...
I wound up going to college after working retail at Disney, then after college, my first job was supposed to be C# but they didn't have the project approved, so I got my first exposure to Python - which I loved, then JavaScript - which I hated but have a love-hate with to this day, and finally C#, but it wasn't .NET 3.5 no, they started using .NET Core, which was... something else, lots of teeth pulling during the original .NET Core days.
So many wonderful projects made with .NET my only complaint is I wish Microsoft would make a cross-platform GUI stack they'd actually stick to, and make it work on Linux too. ;)
I know there's alternatives but nothing beats telling your coworkers "lets just use the built-in" when choosing a GUI stack.
Once burned, twice shy.
The most supported UI frameworks from MS for Windows are WPF and WinUI 3. UWP is dead and WinForms (even though closest to something native to Windows) is probably going to end up in the land of forgotten (sorry nostalgic Windows devs, you have to face it eventually).
A "mess" is an understatement when the people who themselves develop Windows desktop apps have trouble explaining the landscape.
Everything boils back down to Win32, including WPF, WinForms, WinUI2, and WinUI3.
So about that... when I started using .NET Core, it was bleeding edge and shiny, but it was to rewrite a Silverlight application, the only way to run it was Firefox ESR 54 (I think it was 54?) we thought "oh this is easy" only to find out that it was a colossal nightmare, EF didn't support some things, including Shapefiles, we had to force the support, get back a WKT from SQL Server, and send one back when we did updates, basically Entity Framework was mostly useless.
I also reverse scaffolded the existing database into EF compatible classes, so that saved us a ton of effort, the original idea was to be backwards compatible.
Best part? It never got used, when we found out they weren't using the project, my boss said, screw it, lets remake it in Python I know we can build it up quicker, and sure enough, it was done quicker than the C# rewrite, fastest rewrite I ever did, because he figured out the key things they actually needed, and trimmed the requirements to just those key things.
Sometimes rewrites don't need to be 1:1 especially if it's an internal only tool.
Anyway, lots of blood, sweat, tears, stress, etc from me as it was my first job in tech.
Boy do I have good news for you (I am half kidding). OpenSilver project lets you compile your Silverlight code to Web Assembly or iOS/Android/Windows/Mac.
You can dust off your code now.
https://github.com/OpenSilver/OpenSilver
That concept of "define an RPC interface and let the platform fill it" was ancient before WCF and continues to this day (I've got a bunch of tabs open for Cloudflare Durable Objects right now). The legacy problem with WCF was not but long term backward compatibility with the Bindings abstractions and XML config junk and SOAP Stack RPC. Without WCF native in the box in .NET 5+ it is harder (but not impossible) to build SOAP RPC monoliths. But so few businesses actually need SOAP and can't just switch to something more RESTful.
Silverlight was maybe ahead of its time given the growing popularity of Blazor WASM.
I know this may as well be beseeched of the King of Nod, but if they just made WPF cross platform I'd be delighted beyond words.
XAML was supposed to become an open spec, not sure why they have so many teams making so many different ways to make UIs. Then there's those "Windows 8" apps, or the "Universal Windows Apps" which are poorly named, you cannot run any of them on previous versions of Windows, if anything Win32 apps are universal apps.
https://github.com/iBobX/RapidR
Not compatible, but you can use it in a cross-platform way.
Sinofsky left a lasting damage. The way things go with LLMs, it might be now pure app-specific Rust instead of any common frameworks....
But I'm on linux now. If I wanted to pick up back up then what should I be using?
but job offers are kind of boring :/
Be aware
There have been smaller runtime improvements like this one in recent releases, but this one seems a big one to point to to prove that the runtime is truly growing at a faster and more interesting pace than the old days.
https://github.com/dotnet/runtimelab/issues/2398
Be sure to read all the way to the bottom,
However they still suffer from an incredible branding problem.
It's really too bad because as a runtime it's fairly incredible, and F# in particular is fun to work with. They also have good cross-platform support and tooling, which they didn't have a number of years ago.
Combine that with the fact that nobody really writes code anyway thanks to AI, and this could be a slam dunk runtime for an AI-native development environment.
But it will never happen.
It's actually crazy what the agent can do with that.
The tooling ecosystem in Python is just so bad that I can barely stomach it after spending the last 20 years in .NET. At times, when supporting analysts at work wanting to write a little glue code, I've found their main complaint about C# is "curly braces" (which seems like a really odd thing to complain about, but ok) and I've found it easier to teach them a little VB than to figure out whatever the hell is going on with dependency and runtime version management in Python.
And then, for the folks who go deep on Python for ML tasks, I've mostly found them caring now about specific libraries than the language itself. I then show them how .NET has equivalent or better libraries available and that a lot of the code-golf stuff they do in Python has a much cleaner version in F#.
Or PowerShell if you want to hash out something really quick.
They burried the lede on this one.
- .NET 10 is end of life'd on Nov 14th, 2028 - .NET 11 is end of life'd on Nov 9th, 2028
Which means anyone who upgrades to 11 has fewer days of support. But the idea is that you'll upgrade to 12 as soon as it's RTM'd.
The problem with that is I have clients who refuse to budge from 2.1 (or even upgrade to the 2.1 re-release: 2.3).
[1]: https://www.oracle.com/java/technologies/java-se-support-roa...
2.3 on .NET Framework reaches end of life on 2027-04-13, so upgrades have to happen soon.
Not really for any groups that commonly use .Net. Even numbers are LTS and odd numbers are not, or at least it's been this way for a while.
>I have clients who refuse to budge from 2.1
Give me their names, sounds like it would be easy to penetrate them again and again and again with AI.
My experience with Go is a while back, before it got generics. While I liked the overall idea of a language with little syntax and a focus on simplicity, I didn't really like Go in the end. It was a weird mix of too low-level and high level code. It exposed low level details that I don't need to think about in C#, and it is missing convenient abstractions like LINQ.
Personally, I like async/await in C# more than Go concurrency. I know this is heretical here, but I don't care about function coloring or any of the abstract advantages of other concurrency approaches. Async/Await in C# works for me (in non-legacy code) and is easy to understand.
I'd beg to differ on the easy to understand... last time i worked with this stuff like ConfigureAwait only has cargo cults and no real good explanation, and wasn't covered in any recent version of eg. CLR via C#... Distributed tracing and thread management were totally bitten by async, also the way iterators and LINQ were broken... that was when I got off the train, as it broke the best abstractions for line of business code so that instead of designing an IO pipeline lazy developers could simple put Task.Run around blocking IO calls at the bottom of the codebas, and ... yeah, we are back at function coloring.
This brings me to: I winder for what kind of apps did you find it a delight, because for extensive data wrangling leveraging multiple calls it was a pain.
I'm using C# for the backend of a web application, not legacy but .NET Core from the start.
Indeed, you need a crapload of ConfigureAwait() in desktop UI code, and it infects all underlying libraries that might have to run inside a desktop app. The worst thing they ever added to our beautiful language. It's a dream to work in ASP.NET without needing to pepper every await with a ConfigureAwait().
That said, I don't agree with the characterization of ConfigureAwait() as un-understandable. We understand it. We just hate it.
Something which was as easy as an IO call in the middle of a function running on a thread pool becomes a PITA if the IO call is cleverly async-ized (by wrapping the original sync IO method into a Task.Run(), but actually this is the better case!) ad then removed from the public API... (cannot recall the exact library, but it was a pain, as it was some core stuff, maybe vendored by MS themselves)
Also back then it caused us loosing correlation IDs as those were thread locals in traditional pre-async ASP.Net Core (think version 0.9-2.0 when I worked on that part, then up until core 4 and the async mania continuos broke readable calculation code in LINQ, TPL based performant data pipelines, etc...) and with async execution started to migrate between threads... If you needed high performance you already used threads, because it was not a classic web application, but a specialized optimization algorithm with a web api... and if you need more than CRUD, and use all the cores (and SIMD) to squeeze out all performance you have, you hit these problems right away. These all could be solved, but it actually broke stuff, a lot of stuff, as developers jumped on the fad, and it their sync code was turned into a .ConfigureAwait(false /* Microsoft blogs talk a lot about it without a clear explanation, so every cool kid does this */).GetAwaiter().GetResult()... then you some of your threaded code silently broken if you dare used Thread Locals... Faded memories, but that was when they f'ed up the C# language.
I have also found c# async to be lighter than go's concurrency story, and dotnet11 is going to make that much more clear.
Now: I write software for fun, not for money.
For general concurrency where async doesn't suffice, go is nicer than C#, but hopac is nicer than go.
If go had proper concurrentML I am pretty sure I would use go a lot more. Again: this is for hobby projects where I get to choose freely.
Put things like their remote debugging experiences side-by-side and you will quickly learn why some of us go for the Microsoft tools rather than the others.
I don’t have much experience with Go lang but what I have seen, there is lots of things one has to implement on his own. Which has its own merits, but to go from 0 to full fledged enterprise app you need more time.
Go is trying to be like C. Less language features (until recently...), so to solve problems you write more code. Intentionally simple language. Intentionally need a lot of code to implement something substantial. .NET seems more frameworks driven. Go traditionally has eschewed frameworks for doing stuff much like C tends to eschew framework type stuff and prefers smallest dependency reliance as possible.
Also Go is at the stage of C# .NET 2.0, and still plenty of lacking language features.
I really think the creator of C# made a disservice to the .NET community by picking Go for the Typescript rewrite.
I'm going to talk about the second part first. .NET is often deployed with a JIT compiler runtime like Java. That means that hello-world scripts use a lot more memory than Go, but that difference becomes a lot smaller on real-world programs and .NET can use less memory than Go depending on what you're doing.
C#'s concurrency can also be more efficient than Go's since it's coroutine based async/await is a lightweight state machine rather than green threads. That's not to say Go is especially heavy or anything, but it is more overhead.
In terms of "efficient in syntax", Go has a lot fewer features. That's one of Go's biggest strengths and weaknesses.
Here's an example. With Go, you just have struct tags: strings of anything that can be attached to a field in a struct. Let's say you have a User struct and you want to make it so the JSON won't have the user's email in it. You do: Email string `json:"-"`. But what if you mess up and write "jsom" or `json:-` without the quotes? It's basically a meaningless string to the compiler. With C#/.NET, you have annotatons/attributes that are a part of the language and checked as types. You'd do: [JsonIgnore] public string Email. JsonIgnore is an attribute class so your IDE can help you.
There's a lot in Go where the answer kinda becomes "f-it, we'll just use strings instead of having something meaningful." Go talks about how important error handling is, but then you get an error from a function and it's basically just a string. If you're doing good error handling, you want to handle different errors differently, but that's not easy in Go. Frankly, it's not easy in most languages, but this is definitely an area where it felt like Go gave up on creating something good in order to get something out the door quickly enough that Google didn't cancel the project. In a language like Zig, errors are enums and you get exhaustiveness checking. With Go, someone could add another error state to something you're using and you'd never know - or they could change the phrasing of an existing error and you'd silently stop matching on it.
Go's lambda syntax is clunky. func(x MyType) string { x.ToString(); } vs (x) => x.ToString()
There's lots of stuff like that. I'm not arguing that Go is bad, but it has a ton less stuff and that's both a blessing and a curse.
* = Technically, Windows now supports the UTF-8 "code page" where applications can use UTF-8 natively, but all NT system calls use UTF-16, so the conversion still has to happen somewhere
The Runtime has explored attempting "UTF-8 native" string storage as a platform feature especially for Linux FFI, but yeah Windows using UTF-16 is still a compatibility issue where platforms themselves just don't agree.
Sure, having a runtime is downside but difference in container size for your average CRUD App doesn't really matter. Performance IME is very similar.
Ops type here.
Go is for me just a, hmm, concurrency programming language. Its popularity stems just from being pushed by Google, and the cosmetics of using braces. Despite what pundits say, it's completely and utterly not like C.
While C# is a successful and comfortable everything-language. It is blazing fast, has amazing tooling, you can get going to prototyping, then enterprise code, its serverside handling is excellent. It has many low level features and built-in data structures. It's I would say preferable for almost any kind of work except scripting. (I really don't like C# scripting.)
Golang is a fantastic delightful language, but it's still missing a lot of stuff that's existed in C# for years.
However, do you *need* all those .net tricks?
Golang is usually enough for a small project you need to build in a weekend. Scaling it to a mono repo with 200 developers might be a bit difficult
Not quite discriminated unions, but close. With an exhaustive checker with switch statements.
Now if only it made creating unique types easy, so I wouldn’t have to use a library like VOgen, the language would be nearly as good as F#