Here's a summary of the themes from the Hacker News discussion:
Performance Improvements and Complexity
A significant theme is the impressive performance gains being made in .NET, particularly with LINQ constructions, which some users report as being "made 300 times faster." However, this performance comes with increased complexity in understanding how code operates at a lower level, specifically regarding heap allocations. * "Amazing progress, some LINQ constructions were made 300 times faster. But reasoning over what code does heap allocations is getting more and more complicated. I guess intuition has to give even more way to benchmarking" - yread * "But it's definitely harder to reason about whether optimizations will 'light up' for code that uses heap-allocated classes, closures, etc. than it was in the past, even if it's harder for a nice reason." - kg
Ecosystem Stability and Breaking Changes
Concerns exist regarding the stability of the .NET ecosystem and the frequency of breaking changes. While some argue that the changes are well-documented and that tools like dotnet upgrade-assistant make updating straightforward, others find breaking changes inherently disruptive.
* "If only they could fix the ecosystem's stability; I feel like anything written with C#'s staple packages becomes outdated considerably faster than any other options." - Varelion
* "Yep. A breaking change that makes my code a gajillion times faster is still always just a dirty breaking change that I'll hate." - porridgeraisin
* "The breaking changes are very well documented and are esoteric in nature. https://learn.microsoft.com/en-us/dotnet/core/compatibility/10.0" - CyanLite2
* "Scott Hanselman has a very short blog on how 20 year old code is upgraded to the latest .NET in just a few short minutes: https://www.hanselman.com/blog/upgrading-a-20-year-old-university-project-to-net-6-with-dotnetupgradeassistant" - CyanLite2
* "Microsoft created the ".NET Standard" for this. Literally anything that targets .NET Standard 1.0 should work from circa 2001 through modern day 2025. You still get the (perf) benefits up the runtime upgrade which is what the blog post is about." - CyanLite2
Stability of ASP.NET Core and Future Concerns
Conversely, some users have found ASP.NET Core to be a highly stable web framework, with upgrades often taking minimal time if good test coverage exists. The major breaking change from ASP.NET to ASP.NET Core is noted as a significant event, with hopes that similar large-scale breaks will be avoided in the future. There's also an underlying concern about product stability due to potential layoffs at large tech companies. * "TBH aspnet core has been the most stable web framework I've worked in my life. If you have good test coverage, upgrading projects between major versions often takes minutes — because nothing, or almost nothing, gets broken. Some things might get deprecated, but the old way keeps working for years, you can chip away at it slowly over the next year or two." - homebrewer * "Of course, they had a massive backwards compat break when moving from the regular aspnet to aspnet core, here's hoping nothing like that happens in the next 10-15 years.." - homebrewer * "Or hope that key figures, or significant portions of the team don't get laid off. I don't trust Google or Microsoft products for this reason alone." - Varelion
Generics and Language Design Philosophy (C# vs. Java)
A historical comparison is made between C# and Java regarding their implementation of generics and its impact on ecosystem compatibility. The discussion highlights how Java's type erasure approach, while having limitations, allowed for smoother interoperation between older and newer container types, whereas C#'s earlier generic implementation created a noticeable split.
* "I haven't written C# professionally since the early 2010s but back then the language had a big problem in that the old Container classes were not compatible with the Container
Performance Paradigms: GC vs. Manual Memory Management
The conversation touches upon how .NET's advancements are bringing it closer to languages like Rust in terms of performance by managing memory more intelligently, similar to stack allocation and avoiding garbage collection overhead. However, it also contrasts this with the benefits of garbage collection for "programming in the large," where memory management is a global concern, and discusses the potential difficulties this poses for code reuse and library interoperability compared to GC-managed environments. * "This kinda stuff brings languages like C# and Java closer to Rust in performance, thinking like the "borrow checker" it understands the scope of some objects and puts them on the stack and avoids garbage collection and allocation overhead." - PaulHoule * "It keeps the unsung benefit of garbage collection for "programming in the large" in which memory allocation is treated as a global concern independent of everything else instead of a global concern that has to be managed locally in every line of code." - PaulHoule * "Rust's strategy is problematic for code reuse just as C/C++'s strategy is problematic. Without garbage collection a library has to know how it fits into the memory allocation strategies of the application as a whole. In general a library doesn't know if the application still needs a buffer and the application doesn't know if the library needs it, but... the garbage collector does." - PaulHoule * "In the Java world we are still waiting for https://openjdk.org/projects/valhalla/" - PaulHoule