this post was submitted on 01 Nov 2023
135 points (97.2% liked)
Programming
17398 readers
105 users here now
Welcome to the main community in programming.dev! Feel free to post anything relating to programming here!
Cross posting is strongly encouraged in the instance. If you feel your post or another person's post makes sense in another community cross post into it.
Hope you enjoy the instance!
Rules
Rules
- Follow the programming.dev instance rules
- Keep content related to programming in some way
- If you're posting long videos try to add in some form of tldr for those who don't want to watch videos
Wormhole
Follow the wormhole through a path of communities !webdev@programming.dev
founded 1 year ago
MODERATORS
you are viewing a single comment's thread
view the rest of the comments
view the rest of the comments
Help me understand your point of view. How does Rust not prevent memory leaks?
There's built in functions to leak memory that are perfectly safe. You can also do one really trivially by making a reference count cycle. https://doc.rust-lang.org/book/ch15-06-reference-cycles.html
Rust only prevents memory unsafety - and memory leaks are perfectly safe. It's use after frees, double frees, etc. It prevents.
And here you're only talking about a subset of memory leaks, by inaccessible memory. You can also leak memory by pushing new elements in a channel while never reading them for example.
You are absolutely correct that rusts safety features don't extend to memory leaks, but it's still better than most garbage collected languages unless you abuse Rc or something, and it does give you quite fine-grained controll over lifetimes, copying and allocations on the heap which in practice means that rust is fairly good about memory leakages compared to most languages.
How would rust fare any better then a tracing GC? Realistically I'd expect them to use more memory, and also have worse determinism in memory management - but I fail to really see a case where rust would prevent memory leaks and GC languages wouldn't.
If you just Rc everything (which I'd count as "abusing Rc") Rust is significantly worse than a language with a good GC. The good thing about Rust is that it forces you to aknowledge and consider the lifetimes of objects. By default things are allocated on the stack, but if you make something global or dynamically handled (e.g. through Rc) you have to do so explicitly. In Rust the compiler has greater compile time information about when things can be freed which means that you need less runtime overhead to check things and if you want to minimize the amount of potentially long-lived objects you can more easily see how long objects might live by reading the code as well as get help by the compiler to determine if a lifetime-based refactoring is sound or not.
Reference counting is a GC though ?
It's a bad one sure and will leak memory in cases of a cycle which most tracing GC are able to do.
It's main advantage is that there are no GC pauses.
https://en.m.wikipedia.org/wiki/Reference_counting
I think you know what I mean when I contrast Rust with GC'd languages, we can call it opt-in garbage collection if we're being pedantic.