What's so good about MS ranking in the TechEmpower benchmarks is that it's the fastest full-featured "enterprise" framework. Frameworks like drogon or just-js are impressive feats of engineering, but the only reason they exist is so that their authors can mention that on their resume. If you run them in production, you are on your own.

There's equally fast Vert.x, which you can buy support from Red Hat for, but most Java shops use Spring Boot (vmware or Red Hat support available), which is easier, but hopelessly slow in comparison.

That proves my point even further, because I don't develop anything remotely web-related, hence that performance scenario is completely moot for me.

> What's so good about MS ranking in the TechEmpower benchmarks is that it's the fastest full-featured "enterprise" framework.

Again, the same because the software I develop is not "Enterprise" either.

What I develop is scientific software, and needs to be extremely performant. In my case C++ is the best language, but it's not the best for every case. This is why I also learn Go and use Python for other tasks.

In my case, Debian's benchmarks are directly related to my use cases, however even that's not a definitive measurement for my case. It's just a bunch of data to keep in mind.

I hope you realize non-web development is a niche nowadays. So it's perfectly reasonable to prioritize .NET benchmarks that target ASP.NET Core web apps/APIs.

Our vantage points are different, and these different vantage points need not to see the complete ecosystem as a whole. It's too big to generalize from a single vantage point, and just because our view reveal us a little of something doesn't mean it is, in fact, little.

There's a whole invisible world out there, from DBs themselves to OS kernels to embedded platforms, and everything in between.

IOW, horses for courses.

That's a terrible attitude. If you want a certain ecosystem to get a better rep, you have to be ready to talk with different communities, and accept their feedback.

Python is what it is largely because it can cater to a large number of these very different communities, which has ensured its long-term success. Compare with Ruby, which became effectively a web-only language and has since struggled to go anywhere.

Hard disagree. I prefer specialized tools over jack-of-all-trades. Otherwise we would be coding web applications in assembly.

Your example, Ruby, wouldn't even be a blip in history radar if it wasn't for Ruby on Rails, a specialized and very productive toolkit.

Just because RoR now has more competition doesn't mean it isn't/wasn't awesome.

Some people write web-apps in C. Just because you don't like something, it doesn't mean the world agrees.

>Ruby, wouldn't even be a blip in history radar if it wasn't for Ruby on Rails

Hard disagree. Ruby was getting traction on its own, as "the purest OOP language you can use in the real world", around the same time Python was starting to get traction (early 2000s). Then RoR blew up, effectively coopting the entire ecosystem. Since then, Python has slowly gone from strength to strength in so many different fields, whereas Ruby died on its ass as soon as people moved on to other tools for web.

It's not only their stance against Linux only, but everything competing with them.

I believe hardware and software should be open and platforms shall compete openly. I don't use any vendor which openly kills this interoperability and try to corner market with underhanded tactics.

It's not limited to Microsoft, though. I use Java because there's OpenJDK, Go because there's gcc-go toolchain, etc. Similarly I don't use Rust because it's LLVM only for now.

However, this doesn't mean that I want these to disappear. I want them to compete fairly, so we can improve. I'm not a web-dev so I have no need for this frameworks, but I'd make similar choices if I enter to that arena, too.

Which is mostly (~95%) developed by Oracle and is about the same in its openness and community participation as

https://github.com/dotnet/runtime/

is.

Or maybe you meant OpenJ9?

FWIW I also use Linux exclusively, develop (and host) dotnet applications on it, and have my own gripes with it (mostly with Linux still being treated as a second-tier platform which is only good for servers as far as MS is concerned — I'm not talking about the abomination that VS is — try to compare the official profiling & debugging tooling).

As a result, OpenJDK is much more sustainable in the long term, since it can't be closed down and crippled as easily.

While I am no enemy of MIT/BSD style licenses, the "freedoms" they provide to corporations are damaging to open source ecosystem in my eyes.

OpenJ9 looks like EPL licensed, and indeed interesting. It's worth a look.

I'm not writing Java with any considerable volume for some time (because, I didn't need that), hence I was just keeping that in my peripheral vision without paying much attention. However, I'm using Eclipse because it's a great IDE for my needs, and comes with OpenJ9 embedded.

Thanks for bringing this to my attention, will look deeper.

I'm curious, what do you have against LLVM? I'm sure it supports fewer backends than GCC, no surprise given their relative ages, but it's still got quite a few and it's open enough that it has documented support for adding new backends.

I open everything I can, and strictly with GNU/GPLv3+. I want this code can be built and improved upon, even after I abandon it voluntarily or involuntarily. Hence I choose GPL licensed (or close as much as possible) toolchains and tools as much as possible.

For example, I use Eclipse, and include .project files in the repositories, so one can import the project as is, and continue playing, or maintaining the code. I'm improving my Eclipse knowledge to use agnostic paths, so anyone cloning the repo can directly import to Eclipse, and just click build.

I also plan to make my Eclipse and toolchain settings available to make my development environment completely reproducible.

On the case of the Rust, I'm waiting gccrs, which is arriving as an unofficial language in gcc-13. This will both provide an alternative and GPL licensed implementation of the language, and I can be sure that the code I leave behind can be built with the public version of the GCC.

Moreover, I use no compiler specific extensions, because I'm not trying to lock anyone to any toolchain. I'm just trying to make sure that the repo is buildable. I may even add a LLVM (or go-gc) test path to make sure that I don't break anything between implementations.

IOW, I have strong opinions about software freedom, and I apply them to my code, but not force people to obey them (except the license, because I need to underpin it). It's a strong stance, yet there's no insistence. I just set an example, and try to make it a very good one, to show it can be done.

In proper society, the population would get to vote on the initiatives they care about.

Thanks for reminding, BTW. :)