Beyond Memory Safety: What Makes Rust Different – Lessons from Autonomous Robotics
Over the last couple of years, I have been working in the field of autonomous mobile robotics, which is where many of the examples in this article originate. My goal here is to explore what makes Rust special beyond its well-known memory safety guarantees, specifically, how the language prepares developers to write software that is more correct from the outset, where common mistakes become difficult to make, and where the resulting code is inherently more failure-proof.
Beyond Memory Safety
In my conversations with developers about Rust, a consistent pattern emerges: Those who have not invested significant time in the language tend to dismiss it, often after a brief, unsuccessful first attempt. However, in my experience, developers who persist through the initial learning curve and apply Rust to real projects tend to develop a strong appreciation for it. I still remember when we started a large new project two and a half years ago, bringing together people from different language backgrounds into an all-Rust codebase.
One colleague, coming from C++, spent the first two weeks complaining to me every single day. Then, after about three to four weeks, something shifted. He started genuinely enjoying the language and now says he never wants to go back.
A Simple Core
This example may help explain why Rust consistently ranks as the most loved language in Stack Overflow surveys. While memory safety is undoubtedly valuable and I highly benefit from it in my projects, there is more to the story. Rust makes it substantially easier to write software that is correct from the start, where developer mistakes are harder to introduce, and where the resulting code demonstrates greater resilience to failures.
At its core, Rust is a relatively simple language. The widespread perception of Rust as extremely difficult with a steep learning curve contains some truth, but examining the fundamentals reveals that the language centers on data types and the functions that operate on them. Many concepts from other languages that add complexity are simply absent: no garbage collection, no classes, no inheritance, no traditional object-oriented programming, no null pointers, no function overloading, and no type coercion. This minimalist approach has led some developers to compare Rust’s feel to C or, more recently, to Zig.
Enums: More than Just Integers
Rust enums differ fundamentally from their counterparts in other languages because enum variants can store data. Each variant of an enum can hold specific data that differs from other variants, or it can hold no data at all. This concept resembles tagged unions in TypeScript, but in Rust, it exists as a unified, first-class language feature.
Pattern Matching and Exhaustiveness
To access the data within an enum, developers must match the enum with a construct similar to switch statements in other languages. The match expression allows checking which variant a value actually holds and executing the corresponding logic. Critically, when inside a specific match arm, the compiler grants access to the associated data only for that variant. Matches must be exhaustive, meaning every variant must be handled either explicitly or through catch-all patterns, preventing developers from accidentally forgetting to handle a case.
Modeling Optional Data
Optional data appears everywhere in software systems. Many languages model this concept using null pointers, nil values, or specialized standard library types. In Rust, optional data is modeled using enums with associated data, which eliminates the need for null pointers and forgotten case handling.
The Typestate Pattern
The typestate pattern encodes runtime protocols into the type system, catching protocol violations at compile time rather than runtime. This approach ensures that the code is more correct from the start and reduces the likelihood of common mistakes.
Borrowing and Lifetime Rules
Borrowing and lifetime rules make it impossible to access mutex-protected data without holding the lock, eliminating a common source of concurrency bugs. This feature ensures that the code is more failure-proof and reduces the likelihood of errors.
Conclusion
In conclusion, Rust offers a unique set of features that make it an attractive choice for developers who want to write software that is more correct from the start. By eliminating common mistakes and reducing the likelihood of errors, Rust prepares developers to write software that is inherently more failure-proof. Whether you are working on autonomous mobile robotics or other complex systems, Rust is definitely worth considering.
Key Takeaways:
- Rust’s value proposition extends far beyond memory safety to include compile-time prevention of entire categories of developer mistakes through its type system.
- Ownership rules provide automatic resource management for any resource, not just memory, by hooking into value lifecycles through the Drop trait.
- Enums with associated data, combined with exhaustive pattern matching, eliminate null pointer errors and forgotten case handling.
- The typestate pattern encodes runtime protocols into the type system, catching protocol violations at compile time rather than runtime.
- Borrowing and lifetime rules make it impossible to access mutex-protected data without holding the lock, eliminating a common source of concurrency bugs.
