Again, I’m not the most knowledgeable on the language, but I think a lot of it has to do with how Rust deals with ownership and memory management. Generally, established languages follow a few paradigms:
- Management is the responsibility of the programmer (e.g. C, old C++, still used somewhat in modern C++)
- Reference counting with removal when the reference counter hits zero (e.g. modern C++)
- Monitoring and automatic garbage collection (e.g. C#, Java, Python)
The first two are, as we all known, error prone. The last one is less error prone, but the language is slower and may lose some usefulness. It also kind of encourages some really bad memory practices, which often exacerbate its slowness.
Rust, however, takes a different paradigm. It only allows one owner at a time, and you either transfer ownership (move) or allow someone else to use it (borrow). Based on this, you can make certain compile-time guarantees that let you mostly ignore explicit memory management while also not incurring the expenses of garbage collection and reference counting.
Further, Rust has a lot of compile-time memory safety rules that are even more rigid than, for instance, C#. For instance, the compiler will prevent dangling references, a mix of mutable and immutable references to the same object, and multiple mutable references to the same object. All of this effectively catches potential memory bugs at compile time. And while I don’t think dangling references are possible in C# and Java, the latter two problems are still allowed.
Effectively, Rust is a bit more advanced than other popular languages in terms of memory safety, and it managed to do that while still being marketable as a fast language that can be used for systems programming. The fact that its syntax isn’t a nightmare to learn for you average C++ or Java programmer also helps, given that people won’t use your advanced language if they struggle to learn it.
With all that said, though, one can certainly program C#, C++, or Java in a way that holds to Rust’s rules. The main difference is that Rust enforces it. It doesn’t rely on every programmer to do so without fail.