svick

.Net is part of the FOSS ecosystem.

You don't want them to experiment with new tools? The main difference now is that the experiment is public.

Half of the .Net ecosystem doesn't work with AOT either.

A NullPointerException is not a security vulnerability.

A race condition might, but even then, I'm not sure how likely that is to result in a vulnerability in a garbage collected language.

UTF-8 string literals will be part of C# 11/.Net 7, which could help. But they're still more awkward to use than the UTF-16 string.

Many developers distrust closed source developer tools, whether they are free or not.

There is VS Code, which is not a version of VS, is free, and has this debugger.

There is also VS Community, which is a free version of VS, has this debugger, but has fairly strict licensing limitations (e.g. it can't be used in corporations).

Note that Mono, the framework, is indeed dying. But Mono, the runtime, is now part of .Net and it's an alternative to CoreCLR, used for things like Xamarin/MAUI and Blazor.

Though most of the time, you don't need to know any of this, you just use .Net and it works on Windows, Linux, Android, Apple and in the browser.

For null, there are nullable reference types now.

Exceptions are here to stay though. I don't see how you could retrofit something like Rust's Result on top of .Net. (Also, .Net has a pattern that's an alternative to exceptions: `bool TrySomething(out T result)`. But it's quite limited, in several ways.)

Nobody does anymore, so I don't see how that counts as a valid criticism of current .Net.

How do you differentiate between "actually abandoned and probably dangerous" and "actively maintained, but updated only very rarely, because there's nothing left to do"?

> While writing it I needed something that would be 'just data' without any additional 'functionality' attached to it, so I naturally reached for `struct`, given that it exists in the language. The .NET guys asked why it was not a `class` instead. See, somewhere deep inside they felt that not wrapping everything in a `class` is wrong on some fundamental level.

The difference between a class and a struct in C# is not the same as between a class and a struct in C++. In C#, structs can definitely be useful, but also have some gotchas, so they're mostly used only in performance-critical parts of the code.

If you visit a foreign tribe, I think you should listen to the locals, unless you are really certain your way of doing things is better in the local context.