A pet peeve of mine is when people say that the only thing Rust offers (compared to other main-stream languages) is memory safety (putting aside how important memory safety is..).
There are other features that I think help me write better (more reliable) code, though sometimes it can be difficult to pin-point exactly what those features are. For instance, it took me years to realize that there was a type of bug I would end up doing in C++ from time to time that completely vanished when I started using Rust, and it's thanks to pattern matching:
if let Some(ref val) = something {
// ..
} else {
// ..
}
Once that clicked, std::optional felt almost .. advisory.
NDC Conferences just put out a video called "Rust is not about memory safety" (I suspect there was supposed to be a "just" in there, but idk), which I think does a pretty decent job of making this point -- Rust really isn't just about memory safety. Honestly, it would be pretty surprising if a relatively modern language didn't have a bunch of other nice features.
If you're looking for someone to make the case for Rust, the language, beyond memory safety (with concrete examples!), this video is pretty good:
Does that video at least mention the fact that Rust's approach to memory safety was born because Rust tried to go beyond memory safety?
That's a very interesting point: as Graydon Hoare very explicitly told us Rust was, initially, be supposed to be radically different: with tracing GC, “normal” approach to the memory safety, but with a typestate, generators, green threads and so on. More like Go++ than today's Rust.
But at some point, after they have added a way to handle “real-world” objects, where tracing GC is not precise enough (you couldn't exactly rely on tracing GC if you need do file locking, after all, because “this file would become available… eventually” doesn't lead to great user experiance) Rust developers have discovered that people use these things to manage memory, too.
And then low-level Rust was born… very explicitly from attempts to provide more safety than what you automatically get from tracing GC memory safety approach.
IOW Rust wasn't born as “hey, we want memory safety but in a very non-standard way” but more from “memory safety is not enough… but when we go beyond we discover that tracing GC is no longer needed… and that's amazing” way. Of course language that started from “normal memory safety” and tried to go beyond that would have more than “just” a memory safety!
