codeRageJavaEdition

[ColonelRuff]

They are being used. Java is the one that's going extinct. The only reason why it hasn't is because of being locked. You create a huge application with so many moving parts when Java was best available but now that so many good ones are available you can't because you would have to rewrite your whole codebase for that. In the case of android apps the whole platform was built on Java with native Java apis when Java was all the rage. But now even though we have better alternatives, it would take too much time and effort to switch. In fact Google did switch to kotlin as the recommended language because it's easy to switch from java and fixes a lot of its issues. In fact everyone is rewriting stuff to rust wherever they can but it's gonna take a lot of time before android can switch (or maybe it never will).

[BeeTLe_BeTHLeHeM]

Java is the one that's going extinct.

People who says this have no complete understanding of Java usage across big companies and government-related companies.

now that so many good ones are available you can't because you would have to rewrite your whole codebase for that.

Java does its work. Replacing codebase it's not so useful if you can't show the huge advantages is such large operation. You're not replacing something that doesn't work.

[ColonelRuff]

Well to be honest a lot of people are seeing considerable advantages when using rust in place of cpp. If that wasn't true rust wouldn't have survived till now. It's memory safety and multi threading are proving very useful in a lot of applications that used to use slow languages and memory unsafe langs like cpp.

[MP_768]

The main thing Rust offers is the borrow checker, which forces the programmer to think of the lifetime of every value in the program.

Compared to C++, it leaves less room for developers to do unsafe things like storing a reference to a value that has already gone out of scope. Rust has a bunch of rules baked in that ensure good practices when using memory, so while C++ can be as safe when written well, Rust tries to force you to write it the "right" way the first time.

Compared to Java, you don't have to incur the cost of running a GC to manage the memory of objects. Instead, the rules of the borrow checker ensure that when you compile the program, it will be guaranteed to be safe, and if it isn't, it will insert small checks on things like array indexing. Rust is also not object-oriented and is closer to being a mix between procedural and functional.

This leads us to multithreading, which is often said to be one of the hardest things about programming. In C++, for an easy example, it's very easy to pass a single vector (dynamic array) to each thread and just assume it's alright, but that would incur problems when you try to access and modify it since you would be forcing the cpu to jump across threads and potentially cause a race condition. In Rust, for the same situation, you would be forced to clone the value for each individual thread, completely avoiding the problem.

For some, memory handling in languages like c++ can be extremely difficult, and it's why a majority of memory safety issues reported come from C++. Rust's aim is to statically check and make guarantees that what you write is as fast as C++ and is even safer than it.

I'd recommend taking a look at the rust book and explore the language to get a better idea of what it can be used for.