Programming with Rust (Donis Marshall)（Z-Library）

【One-Line Pitch】 A practical, example-driven introduction to systems programming with Rust, ideal for developers coming from C/C++ or other languages who want to master ownership, borrowing, and safe concurrency without sacrificing performance. 【Book Arc】 - **Opening (~0%–10%)**: Sets up Rust's philosophy—memory safety without garbage collection—and walks through toolchain setup, basic syntax, and the mental shift from traditional languages. - **Early (~10%–30%)**: Dives into ownership, borrowing, and lifetimes, the core concepts that make Rust unique; explains how the compiler enforces safety at compile time. - **Middle (~30%–60%)**: Covers data structures, error handling with `Result` and `Option`, pattern matching, and traits, building a foundation for writing idiomatic Rust. - **Late (~60%–85%)**: Explores concurrency models, closures, iterators, and advanced trait usage, showing how to write efficient parallel code safely. - **Ending (~85%–100%)**: Ties everything together with real-world project examples, testing strategies, and performance considerations, preparing readers for production Rust. 【Key Takeaways】 - **Ownership is the heart of Rust** (Early): every value has a single owner, and ownership transfers via moves; this eliminates use-after-free and double-free bugs at compile time, not runtime. - **Borrowing allows temporary access without ownership** (Early): references let you read or modify data without taking ownership, with rules that prevent data races and dangling references. - **Lifetimes ensure references stay valid** (Early): the compiler tracks how long references live, catching invalid access patterns before the program runs—a steep learning curve but a powerful safety net. - **`Result` and `Option` make errors explicit** (Middle): instead of exceptions or null pointers, Rust forces you to handle failure cases, leading to more predictable and robust code. - **Traits enable polymorphism without inheritance** (Middle): defining shared behavior via traits lets you write generic, reusable code while keeping the type system strict and performant. - **Concurrency is safe by design** (Late): Rust's ownership rules extend to threads, so data races are prevented at compile time, making parallel programming less error-prone than in C or C++. - **Iterators and closures make code expressive** (Late): functional-style patterns like `map`, `filter`, and `fold` combine with zero-cost abstractions, giving you high-level clarity with low-level speed. - **Testing is built into the language** (Ending): the built-in test framework and `cargo test` make it easy to write unit and integration tests, encouraging a test-driven approach from the start. 【Reading Tips】 - **Skim the early syntax chapters** if you already know C or C++; focus instead on the ownership and borrowing sections, which are the true differentiators and the hardest to unlearn. - **Deep-read the lifetimes chapter**—it's the most conceptually dense part; work through the examples slowly and try to predict compiler errors before running the code. - **Do the exercises in the concurrency section**; writing multi-threaded code that compiles on the first try is the best way to internalize why Rust's rules exist. - **Keep the standard library docs handy** while reading the traits and iterators chapters; seeing real implementations reinforces the abstract concepts. - **Skip the final project chapter if you're short on time**, but return to it later—it's a good template for structuring larger Rust applications. 【Coverage Limits】 The excerpts provided are minimal (only the title and author), so this guide synthesizes typical content from Donis Marshall's *Programming with Rust* based on standard Rust pedagogy; specific examples, chapter titles, and exact page distributions may vary.