Rust: Fearless systems programming for the modern developer

Description

Originally designed by Mozilla Research for writing the next generation of web browsers, the Rust programming language offers the same degree of control over memory and performance as C and C++, all while ensuring memory safety (at compile time) without resorting to a garbage collector or a managed runtime. Rust programs are free of bugs such as dangling pointers, NULL pointer dereferences, buffer overruns, use-after-frees, double-frees, and iterator invalidation.

These safety guarantees make Rust well-suited for security-sensitive applications, but they also make multithreaded programming much less fraught with peril: Rust ensures (again, at compile time) that threads can never accidentally alias shared mutable state, even as they share data structures among themselves or as they take references to data in other stack frames.

The price, you ask? By moving so many classes of bugs from runtime to compile time, Rust forces you to think hard up front about the use of pointers within your program. Understanding Rust’s concept of ownership can be daunting for newcomers. Ben Striegel leads an active, hands-on introduction to Rust, explaining Rust’s novel characteristics and demonstrating how you can put them to work in your own projects.

Topics include:

• The principles behind Rust’s novel memory-safety system: ownership, borrowing, and lifetimes
• Traits—Rust’s principal method of code reuse—and their implications both as interfaces and for type-safe generic programming
• An introduction to the standard library, with an emphasis on the pieces that are used pervasively in Rust code: iterators, fundamental data structures, error-handling components, and more
• Rust’s novel and adaptable concurrency features and how to fearlessly scale workloads without the hard-to-debug errors that one typically expects of concurrent programming
• Standard Rust tooling with a particular focus on the Cargo package manager, which helps you build and test your code, manage dependencies, and publish your libraries to Rust’s central package host
• How to make cautious and careful use of Rust’s “safety escape hatch” for tasks such as calling into C libraries, writing assembly code, and expressing low-level idioms that are beyond the reach of Rust’s type system