Ask Lemmy

None of the languages give the same runtime guarantees as Rust without having a garbage collector.

I think people in this thread are putting Rust in the same bucket as garbage-collecting languages, but there is a performance cost to garbage collecting. Rust doesn't have a garbage collector and this is why Rust is very fast and still can guarantee a lot of runtime errors won't happen (unlike in C, c++ etc).

But it's really complicated to write code in Rust. Not the basic code but if you have lifetimes on things or use async code and want to change it, you may have to spend hours reworking your entire program.

Pretty much all high level languages do because they're already designed around automatic memory management.

Almost every language does, do they not? Rust is special because it is safe and as fast as cpp

If you have to ask this question you should probably be using a garbage collected language. Manual memory management is quite tedious and it's easy to make mistakes. Rust's novel contribution is reliably catching the mistakes at compile time so once you have fixed all the compile time error messages you have a safe program. But it doesn't ease the tedium that much.

GC does it automatically and is way more convenient, but inflicts a cost in runtime performance. That's almost always fine on today's computers, thus Python's popularity. Rust is best for systems work where you need more precise control of machine resources. It is probably used more than necessary right now, because it's new and exciting and programmers like that.

The safest language is probably Ada but it is less flexible than Rust. They are working on extending it to be comparable. Right now Ada isn't well suited for programs that do lots of runtime allocation.

This never became a real language, but years ago Microsoft Research work on Project Midori, an attempt to make a managed programming language suitable for an operating, and the operating system to go with it. It was based off of C# and heavily modified. Joe Duffy at Microsoft Research wrote some good blogs on it, about approaches they took and why, problems they ran in to, etc.

https://joeduffyblog.com/2015/11/03/blogging-about-midori/

zig, kinda. You still have to manually manage memory, but for smaller applications there is e.g. the ArenaAllocator, which does everything for you. zig has a few nice features that make it just easier to manage memory. Keep in mind that it is not at release level and will change, but it's already functional.

Ada comes to mind, goes further than Rust in this regard.

I mean Java and Python ig? But those don’t really count, do they?

I'd say Malbolge is pretty safe. I'd like to see someone crack a system using that.

I'm new to C and Rust, but from what I can gather, C and C++ are not memory safe by default because they require the programmer to manually allocate memory onto the heap as needed and then free said memory, and then remember not to use said freed memory again. There is a lot of "ceremony" around this and it's easy to make mistakes, which result in memory leaks, use after free errors, undefined behavior, security bugs, etc.

Most high level languages (Python, JavaScript, Java, Golang, etc.) use a garbage collector (also known by the acronym, GC), which very essentially looks for when memory can be freed within your program and performs this allocation/deallocation ceremony for you. There are, however, disadvantages to running a garbage collector. Running a garbage collector costs allocation of memory itself, and it is not inherently efficient (depending on how the garbage collector itself was implemented).

Rust's solution to this utilizes techniques built around the concept of memory ownership, which is enforced using what is known as the Borrow Checker. In essence, Rust prevents memory leaks by ensuring that a variable (i.e. a reference to a value stored in memory) cannot be utilized in multiple different scopes of the program, but rather must be either copied (a new variable with the same value stored in a different space of memory), or the variable must be passed directly to the new scope, afterwards which it cannot be utilized outside of the scope it was passed to (hence the term of it being "borrowed".)

Im not sure, but I believe this is why Rust is more efficient than a garbage collected language because the techniques used in garbage collection can be computationally and resource intensive. These techniques include tracing, reference counting, and escape analysis.

This is as opposed to Rust's memory management model, which prevents memory leaks by explicit memory allocation of mutable variables which prevents the presence of dangling pointers being left within the codebase.

From my little experience working with both C and Rust, as well as languages like JS/TS and Python, is that Rust cuts the difference between the low level languages like C and the GC languages like Python in that you don't have to manually allocate and deallocate memory every time you need to use the heap, but you need to keep track of which scope owns which memory at any given time, otherwise the compiler (and hopefully long before that, your linter) will complain at you and prevent you from even compiling a binary in the first place.

Lastly, a point of interest. C++ has an optional borrow checker of sorts in its use of RAII.

Hope this helps sort things out a bit. Really there aren't many memory safe languages that use the ownership model. All GC languages are memory safe (assuming the GC is implemented well), but the computational cost of that memory safety is higher than with Rust.

In short, Rust's Ownership model makes Rust one of the few memory safe languages that is nearly as efficient as manually memory allocated languages like C, while still memory safe like with GC languages.