Programming Rust

About the book

Programming Rust teaches Rust to readers who arrive with experience in another language and want to understand how the language's memory model shapes ordinary code. The central subject is ownership and borrowing: the rules that let Rust manage memory without a garbage collector, and the compiler errors that follow when those rules are broken.

The book treats the compiler as part of the subject. It works through why the borrow checker rejects certain programs and how to restructure code so the constraints are satisfied. That approach suits Rust's design, where safety guarantees are enforced at compile time and the cost of learning appears as friction during development. The authors move from language fundamentals toward systems programming concerns, including concurrency and interaction with code written in other languages.

Expect a book oriented toward practical understanding. The material assumes the reader can already program and is willing to think about references, lifetimes and data ownership as design questions. That framing makes the book useful for readers who want to write Rust that compiles without fighting the compiler on every change.

How to read it

Read with a compiler open. The explanations of ownership and borrowing become concrete when tested against small programs, and the errors the compiler produces are the best feedback available. Pause on sections about references and lifetimes until the rules feel predictable. Later material on concurrency and unsafe code depends on them.

The prose is direct and technical, with examples carrying much of the argument. Some sections are dense, particularly where the type system and memory layout are discussed, and readers may need to reread them. The book explains mechanisms rather than offering shortcuts, and the pace assumes sustained attention rather than quick skimming.

Who it suits

Programmers fluent in another language, especially C, C++ or Go, will get the most from this book. It suits developers who need to write systems code, work with concurrency, or maintain Rust projects and want to understand the language's constraints instead of copying patterns. Readers who prefer learning by building small projects alongside explanations will find the structure workable.

Reading considerations

Rust changes steadily, and this edition may not reflect later language or tooling updates. Check the edition and errata before relying on specific compiler behavior. Readers new to programming altogether should start elsewhere, since the book assumes prior experience and moves quickly through fundamentals.