Beginning Rust Programming (Ric Messier)（Z-Library）

【One-Line Pitch】 A hands-on, project-driven introduction to Rust that skips "Hello, world" and teaches the language by building a working Conway's Game of Life. Best for programmers coming from C, C++, or Python who want to understand ownership, types, and Cargo by writing real code. 【Book Arc】 - **Opening (~0%–9%)**: Sets up the toolchain and mindset — installing Rust via rustup rather than a Linux package manager, understanding rustc vs. cargo, and why dependency management matters. Establishes that this is a compiler-driven systems language, not a scripting language. - **Early (~9%–28%)**: Builds the Game of Life from scratch: Cargo project setup, external crates, namespaces, functions, variables, datatypes, arrays, and control structures. Introduces Rust's implicit return (last expression, no semicolon) and the freedom to place `main` anywhere in the file. - **Early–Middle (~28%–38%)**: Moves into ownership and lifetime concepts through the lens of the Game of Life — moves vs. copies, why Rust avoids garbage collection and reference counting, and how memory safety drives language design. - **Middle (~38%–47%)**: Adds real program plumbing: command-line arguments, `Option` types and `unwrap()`, reading from files, populating vectors, and terminal output with color via external crates. Contrasts Rust references with C pointers and dereferencing. - **Late (~47%+)**: Extends the project with modules, generation printing, and iteration over generations. The excerpts do not cover the later chapters in detail, so the book's treatment of concurrency, FFI, and embedded work is only signaled by the blurb. 【Key Takeaways】 - **Cargo is the center of the Rust workflow** (Opening): it compiles, manages dependencies, and resolves modules automatically — unlike C, where you manually link libraries. Learn it early and use it instead of rustc directly. - **Ownership replaces garbage collection and reference counting** (Early–Middle): when a value is assigned to a new variable, it is *moved*, not copied, preventing two aliases from pointing at the same memory. This is the core mental shift for readers coming from Java or Python. - **Rust returns values implicitly** (Early): the last expression in a function — without a semicolon — becomes the return value. This distinction between statements and expressions recurs throughout the language. - **Option types force you to handle absence** (Middle): functions like `nth()` return `Option`, and calling `unwrap()` on `None` panics. This is the book's first taste of Rust's error-handling philosophy. - **References work opposite to C pointers** (Middle): `&` passes a reference to a value rather than an address, and the compiler enforces safe usage. The book uses side-by-side C and Rust examples to make this concrete. - **External crates are first-class** (Early–Middle): the `rand` and `color` crates are pulled in and used with explicit scoping, showing how Rust's ecosystem integrates without manual installation steps. - **The Game of Life is the teaching vehicle** (Early–Late): each concept — arrays, loops, functions, ownership, file I/O — is introduced because the project needs it, not as an abstract exercise. 【Reading Tips】 - **Deep-read Chapters 1–2**: the Game of Life implementation is the spine of the book. Type the code yourself rather than reading it passively; the ownership and reference material only clicks when you hit compiler errors. - **Skim the C/Python comparisons if you already know those languages** — they are useful for intuition but not essential to writing Rust. - **Pause on ownership and references** (Early–Middle): these are the hardest conceptual jumps. If you rush, later chapters on modules and file I/O will feel arbitrary. - **Treat the exercises at the end of each chapter as mandatory** — the book is explicitly practical, and the exercises extend the Game of Life in ways that reinforce the chapter's concepts. - **Keep the Rust compiler handy**: the book leans on compiler feedback as a teaching tool, so build frequently and read error messages carefully. 【Coverage Limits】 The excerpts cover roughly the first half of the book, centered on the Game of Life project, ownership, and basic I/O. Later topics promised by the blurb — concurrency, thread safety, FFI, and embedded devices — are not covered in the available excerpts, so this guide cannot assess their depth or quality.