A post about how not to develop frameworks, and why the software life cycle is not empty words, especially if millions of developers around the world rely on you. The following is a critique of the approach to developing the .NET Core platform, and the closely related framework, ASP.NET Core.

Version history. NET Core (a joke from the Internet):

* Alpha
* Beta
* RC1
* 2RC 2Furious
* RC: Tokyo Drift
* RC4: The Big RC
* 7
* RC8

Prehistory

vNext is the codename for the new generation of ASP.NET, which was used for quite a long time, until the framework received a sequence number and became known as ASP.NET 5 (later known as ASP.NET Core). If before that the development of ASP.NET went smoothly, mostly without any problems with backward compatibility, then the new version was a real revolution. In essence, this is a new framework. One of the goals of total rewriting was to achieve modularity, which, among other things, made it possible to untie .NET from the Windows platform. This later served as a reason for a series of loud announcements about support for Linux and OS X.

I must say that the new framework has turned out to be very pleasant: the monstrous System.Web has sunk into oblivion, and the MVC and Web API parts have merged into one. In addition, runtime and libraries were divided into small parts (a typical installation of a web application along with all dependencies now took less than 50 megabytes, compared to the previous 500 MB of the full version of the .NET Framework). Linux support is generally a separate conversation. The official image for Docker, launching applications in two clicks on servers of any cloud hosting provider - that's what, before that .NET programmers could only dream of.

But not everything went smoothly. The new platform was incompatible not only at the ASP.NET level, the .NET Framework itself has changed. In fact, there are two independent directions: CoreCLR and the "old" .NET version 4.x. Porting between these frameworks turned out to be a nontrivial task for a large number of libraries, the authors of which, naturally, began to express their dissatisfaction. But, by and large, Microsoft got off easy then - people made some noise, and calmed down. As an imagination workout, one can imagine rivers of blood that would flow if, in addition to the basic version of Java, there appeared some incompatible SuperDuperJava. In the case of .NET, the developers were more pleased with the new features than opposed to the changes, although there was also a lot of discontent.

No matter how it was there, the fact is that .NET is now in a situation similar to the one that happened with Python 2.x and 3.x. And yet there are WinRT, Mono, Unity and Xamarin, which also do not differ in one hundred percent compatibility ...

Release candididate

If you are a normal person, and did not arrive on Earth from one of the planets of the Alpha Centauri system, then most likely, after unit you have numbers 2 and 3, after alpha version there is beta, and after Release Candidate follows final release, well, or RTM .

Most hipster offices write on the new ASP.NET from the first alpha versions. I personally managed to work in two teams that use this framework. You can live with it if you update the application as new versions are released, without lagging behind the release schedule. Of course, the work on updating applications is not the most interesting, but the goodies of the new version are worth it if the company can afford it.

In a normal world, when a project comes to the Release Candidate stage, the community expects stability. "This is too boring" - probably, Microsoft thought so. It turned out that the most interesting was still ahead. Suddenly, the biggest changes in the history of the new framework happened when the version received the prefix RC. The first sign of a future fire was project.json, or rather its replacement with good old MSBuild. To be honest, this change is not in itself a disaster. However, it was project.json that was the flagship of the "new" .NET. Watch the presentations from numerous conferences - the PR machine lured hipsters from the world of Go and, oh my God, Node.js with just such things. In addition, terrible timing - how can you call something Release Candidate, when is ahead to change the build system for the entire framework?

Further more. ASP.NET Community Standup is a YouTube channel, where developers in the weekly releases talk about the new ASP.NET and its development process. Standup, which had been steadily going out once a week, suddenly stops talking for a month. The latest publication is called "Do we have dates?", Which is very symbolic. The developers of the framework, previously active Twitter users, are becoming cautious and do not get involved in discussions. The rest of Twitter seethes with indignation. Everyone is at a loss. It seems that those who did this project are no longer aware of what is happening now. From the conjectures of the community, "adult guys" came who gave a scolding to "plenty of kiddies" and took everything under control.

Mixed in a bunch of horses, people, WebAssembly

One can judge what kind of discrepancy is going on in the .NET world by screenshots that have emerged on the net discussing the future of the platform inside Microsoft. While ASP.NET is in limbo, developers are discussing strange topics, like compiling support in WebAssembly. Most likely, .NET Core, in its current form, is inconvenient to some Microsoft departments (like Xamarin) due to its incompatibility. One part of Microsoft is not entirely happy with what the other has done. Like Swan, Cancer, and Pike, everyone pulls on himself. As a result - marking time and strange silence.

What's next? You can make a few assumptions about the future of .NET based on discussions in the official Slack channel: Mscorlib and AppDomains most likely return in their original form, which calls into question the modularity of the entire framework, and, in general, the need for an initial idea. Instead, a subset of the APIs that are available and compatible across all platforms, from ASP.NET to Unity and Xamarin. These are big enough changes. According to the new terms - the absolute uncertainty.

Conclusion

Despite the brilliant work done by the development team, the lack of a complete picture in the eyes of management led to the fact that a large number of developers have relied on a platform that will never be released in its current form. One can argue for a long time about whether it was the right decision to divide the platform into two branches, but it was necessary to think on this topic much earlier. A 180 degree turn in the RC stage is the worst thing you could think of. Release Candidate is, quite to itself, an established term that implies certain obligations that it would be nice to fulfill.