C# has become a great language for the "functional core, imperative shell" way of doing things. That means it has to be a hybrid language. F# is more tilted toward functional-land, C# is tilted toward imperative/OO-land. Both have their place.

If C# devs are constantly rewriting their code, that means there's no vision for that particular codebase. It's true that there are many different ways to "do C#." So, a developer or team needs to pick a particular way (OO classic, or functional core/imp shell, or functional, or minimal golang-style) and stick to it. It's more of an architectural challenge than you would get with a language that can only do one of those. The upside is, your system can blend approaches as necessary, all within one codebase. Every module of the system is perfectly suited to its task, from philosophy all the way down. Of course there's the danger of it becoming a mess, but the risk is worth the reward IMO. With great power comes great responsibility as they say.

If something can be written in 10 different ways then it will be re-writting in 10 different ways, because today you are leading your team and defining 1/10 ways. Tomorrow you leave and another lead or senior comes onboard and will disagree with your architecture and then slowly re-write everything.

Even worse, every time you add a new person on your team there's a 9/10 chance that they will disagree with your code. Your team will waste so much time between people just talking about how to write something because people get hung up on minor details instead of just trying to build a good application solving a real problem. The micro benefits of doing something in c# one way or another are in 99.999% of applications a complete waste of time.

Whenever I'm trying to hire C# developers (something I've been doing a lot over the years) I'm amazed how little people even know about C#. There's literally so much when you go deep that most people are completely clueless and it's getting worse and worse.

A wise lead may prefer a different path to their predecessor but respect the decisions that were made before them and realize that it's counterproductive to chaotically "drip-migrate." And good experienced developers will not get bogged down in endless debates with no clear winners.

It just sounds like you've had some bad experiences.

A general rule is you made modifications to a codebase the same style / technology as the original codebase. I've seen bad developers not do this and it certainly turns into a mess.

I feel sorry for new Developers because I learnt those features bit-by-bit over the years and they are expected to learn them at a go. It is also hard to understand why a syntatic was introduced when you never used the way it used to be done.

I also use Resharper, it repeatedly reminds me of new syntactical ways of doing things.

I understood from a Microsoft conference I attended (regrettably I forget the speaker) that their decision to incorporate new features so rapidly was a very conscious decision, based on what I thought to be a quite perceptive look at the landscape - to some extent C# has always been a reaction to Java; a language that often comes under fire for its extremely slow and cautious incorporation of features.

I think the big changes between .net framework and . Net Core weren't that big for a project.

And it got a lot faster.

I am angry that .NET Core keeps changing faster than Kim Kardashian changes her outfits. First they focused on making .NET Core all about ASP.NET with a clear focus on MVC and making everything super granular. Then they didn't like how granular it was and started to put lots of featurs into smaller pacakges again. Then they keep re-inventing things. First introduce Newtonsoft Json into the default .NET Core stack. Then rewrite everything. The webhost model keeps constnantly changing. The ASP.NET Core team now is realising that people hate MVC and they are splitting out more features from MVC into more basic ASP.NET Core features, which is why routing has completely changed again with endpoint routing. Honestly nothing is constant, not even for 6 months. Every version of .NET Core almost requires a developer to completely rewrite their Startup.cs class. It's just ridiculous.

The reason for all of this is old MSFT thinking. It's not bloody rocket science, people have been saying it for years that they don't want to be forced into MVC, they want things to be more lightweight, bla bla bla. But obviously MSFT cares more about making a shit hello world demo at BUILD and therefore they first must hack together ASP.NET Core which was mostly just about MVC before being allowed to build the core platform to something that is actually useful to others.

They'll constantly keep changing the fundamentals, moving the carpet under developers feet and distracting businesses with stupid useless excercises or rewriting shit instead of just creating a stable base platform on which people can freely build applications and actually focus on their own apps.

"First they focused on making .NET Core all about ASP.NET with a clear focus on MVC and making everything super granular. Then they didn't like how granular it was and started to put lots of featurs into smaller pacakges again."

.Net core was a ground-up re-write and was the vehicle used to opensource all .Net. It was always meant to grow into a full-scale offering and eventually bring along all the features users demanded. I personally love reading all the fun library code: https://github.com/dotnet/runtime/tree/master/src/libraries

" First introduce Newtonsoft Json into the default .NET Core stack. Then rewrite everything."

Newtonsoft itself is bloated and there is no turning back for that library. MS is providing an option to use a lightweight JSON library that uses the new SPAN ref struct.

"The ASP.NET Core team now is realising that people hate MVC and they are splitting out more features from MVC into more basic ASP.NET Core features, which is why routing has completely changed again with endpoint routing."

Endpoint mapping wasn't born out of hate for MVC, it facilitates the separation of framework/transport/protocol without introducing config files (or handler code) for each. https://github.com/aspnet/AspNetCore/issues/4772

"The reason for all of this is old MSFT thinking. It's not bloody rocket science, people have been saying it for years that they don't want to be forced into MVC, they want things to be more lightweight, bla bla bla."

Maybe I am old but I remember when MS was almost forced to adopt MVC. They kept webforms alive for a long time. They introduced razor pages when SPA world demanded an easier solution. I am not sure if there was going to be a way to satisfy everyone here.

The name changed and there is an obsolete attribute on it with instructions.

> First introduce Newtonsoft Json into the default .NET Core stack.

With the same usage/properties/methods but faster

> routing has completely changed

Another method, the older one is still available ( also, obsolete attribute)

> completely rewrite their Startup.cs class

Wait what? You already named 2 of the 3 changes and there is probably a year in between. Also, the third change is related to the webhost change.

Kim changes every day

That means you don't have to update for a very long time ;)

Are there any popular application programming platforms that are widely used that haven't evolved fairly rapidly and caused a lot of complaints along the way?

It's two philosophies: 1. Backwards compatibility is king, 2. The best framework possible is king. #1, over time, can lead to a hot mess.

I am yet to get a RFP that even mentions it.

I know a lot of companies that really want to run away from a dependency on Windows - especially in cloud environments. Every time you introduce Windows into the mix it costs more for licenses and resources.

This is coming from someone who has exclusively developed and deployed to Windows servers until 2 years ago and even now my only Linux deployments are Lambda and Docker.

Better pay attention to MS conferences then, they have stressed multiple times that VS is going to stay .NET Framework and how they are commited to keep it as long as there is Windows.

And at .NET Core 3.0 release conference it was visible in multiple occasions how they are fighting the re-writing fatige from many enterprises.

I think JetBrains knows a little about the .Net ecosystem.

https://www.jetbrains.com/lp/devecosystem-2019/csharp/

As far as cloud and server adoption.

https://www.makeuseof.com/tag/linux-market-share/

On Amazon EC2, standard Linux (along with its various distros) controls 92 percent of the market. It boasts more than 350,000 individual instances. Again, Windows is responsible for the other eight percent.

Even MS said that 2/3 of their VMs on Azure are running Linux.

Those VMs running Linux is where we put our Java stuff not .NET.

Just like my anecdotes are the sample of our DAX and Fortune 500 customers.

Linux adoption? Yes it is wiping Windows on the server, that is why I always worked for Java/.NET shops since 2006, switching stacks as per customer project requirements, in some projects even both get equally used.

Somehow your replies always feel being about fear of using outdated tech, always having to jump into new toys to keep being employable.

Never felt the need to worry about that, as long as we have happy customers, opportunities abound, regardless of what is the latest tech stack fashion.

I think JetBrains sample size is a lot larger than yours.

.Net Core isn’t “new”. It’s been around since 2016 and the direction that Microsoft is headed in.

never felt the need to worry about that, as long as we have happy customers, opportunities abound, regardless of what is the latest tech stack fashion.

And what happens when either you want to or are forced to change jobs? Someone who is 40+ will be seen as just another old head who hasn’t kept up with technology and be on HN screaming about “ageism”. Not directed at you personally. I’m also in my mid 40s and seen it happen time and time again. Someone staying at a job for 20 years and then gets laid off and all they have to offer is that they are really good at ASP.Net WebForms when the world has moved on.

Heck it happen to me at 35 looking for a job and my experience after staying with a company for 10 years was VB6 and C++/MFC.

Instead of moving on to technologies that are in the “slope of enlightenment” phase of the hype cycle would you suggest that I kept doing C on DEC and Stratus mainframes like I did on my first job?

The average tenure of a developer in the US is 3-4 years.

And yet most of those RFP keep referring to stuff like .NET Framework 4.6 and .NET 4.7.1.

As for the job, luckily Europe is not as bad as US in what concerns ageism.

Over 40 here as well and so far no problems switching jobs, because I always strived not to be labelled as only being good at technology X, without anything else to offer.

My advice is to diversify domain knowledge, master soft skills, be able to jump between developer, QA and technical lead roles across delivery sprints, and most customers will find less relevant how well one masters the very latest version of technology X, rather what is the business value one brings to the organization.

And some of them, do value a lot that one is able to keep that old clunky VB 6 application running, instead of sinking several thousand euros attempting an half-baked rewrite into the latest stack trend, and do pay accordingly as well.

And yet again you use your own anecdotal evidence without any large sample size.....

As for the job, luckily Europe is not as bad as US in what concerns ageism.

So how competitive is someone all other things being equal who hasn’t kept up with technology as someone who has?

And some of them, do value a lot that one is able to keep that old clunky VB 6 application running, instead of sinking several thousand euros attempting an half-baked rewrite into the latest stack trend, and do pay accordingly as well.

Until Microsoft introduces an operating system that doesn’t support it and you’re stuck with an unsupported OS with an unsupported runtime with security and compliance concerns.

If they get the job of their dreams, it is a completely different matter though.

The world's best OOP-system (CLOS) was conceived using macos.

I see this in Scala, not Java, as the latter's feature set is much more restricted.

MSFT stacks are an ever ending wild ride of change, deprecation, constant direction shifting and bugs.

I’ve been writing c# since 2002 and I’m quite frankly done now. It doesn’t help me solve problems now. It just creates new ones I don’t want to solve or have to pay to solve.

The IDE is buggy, the platform is buggy and the churn is so bad it’s a ridiculous prospect trying to build a non trivial business on it now.

Most companies are still stuck on classic .net because hardly anything is really portable to core. On top of that when you do finally drag it to core 2.2 then it’s deprecated so you have to rewrite half your MVC stack for 3.0.

And then there’s the customer abuse like opt out Telemetry.

2.2 to 3.1 is probably the easiest upgrade I’ve ever done. You wanna talk about mvc 1 to 2/3, now that was a painful upgrade.