Scott Meyers' original Effective C++ book was phenomenally successful because it introduced a new style of programming book, focused on a collection of guidelines that had been learned from real world experience of creating software in C++. Significantly, those guidelines were explained in the context of the reasons why they were necessary – allowing the reader to decide for themselves whether their particular scenario warranted breaking the rules.
The first edition of Effective C++ was published in 1992, and at that time C++, although young, was already a subtle language that included many footguns; having a guide to the interactions of its different features was essential.
Rust is also a young language, but in contrast to C++ it is remarkably free of footguns. The strength and consistency of its type system means that if a Rust program compiles, there is already a decent chance that it will work – a phenomenon previously only observed with more academic, less accessible languages such as Haskell.
This safety – both type safety and memory safety – does come with a cost, though. Rust has a reputation for having a steep on-ramp, where newcomers have to go through the initiation rituals of fighting the borrow checker, redesigning their data structures and being befuddled by lifetimes. A Rust program that compiles may have a good chance of just working, but the struggle to get it to compile is real – even with the Rust compiler's remarkably helpful error diagnostics.
As a result, this book is aimed at a slightly different level than other Effective <Language> books; there are more Items that cover the concepts that are new with Rust, even though the official documentation already includes good introductions of these topics. These Items have titles like "Understand…" and "Familiarize yourself with…".
Rust's safety also leads to a complete absence of Items titled "Never…". If you really should never do something, the compiler will generally prevent you from doing it.
That said, the text still assumes an understanding of the basics of the language. It also assumes the 2018 edition of Rust, using the stable toolchain.
rustc version used for code fragments and error messages is 1.60. Rust is now stable enough
(and has sufficient back-compatibility guarantees) that the code fragments are unlikely to need changes for later
versions, but the error messages may vary with your particular compiler version.
The text also has a number of references to and comparisons with C++, as this is probably the closest equivalent language (particularly with C++11's move semantics), and the most likely previous language that newcomers to Rust will have encountered.
The Items that make up the book are divided into six sections:
- Types: Suggestions that revolve around Rust's core type system.
- Concepts: Core ideas that form the design of Rust.
- Dependencies: Advice for working with Rust's package ecosystem.
- Tooling: Suggestions on how to improve your codebase by going beyond just the Rust compiler.
- Asynchronous Rust: Advice for working with Rust's
- Beyond Standard Rust: Suggestions for when you have to work beyond Rust's standard, safe environment.
Although the "Concepts" section is arguably more fundamental than the "Types" section, it is deliberately placed second so that readers who are reading from beginning to end can build up some confidence first.
The following markers, borrowing Ferris from the Rust Book, are used to identify code that isn't right in some way.
|This code does not compile!
|This code panics!
|This code block contains unsafe code.
|This code does not produce the desired behaviour.
My thanks go to:
- Tiziano Santoro, from whom I originally learned many things about Rust.
- Julian Rosse, who spotted dozens of typos and other errors in the online text.
- Martin Disch, who pointed out potential improvements and inaccuracies in several Items.
- Chris Fleetwood, Sergey Kaunov, Clifford Matthews, Remo Senekowitsch, Kirill Zaborsky, and an anonymous ProtonMail user, who pointed out mistakes in the text.