Command-Line Rust (Ken Youens-Clark)（Z-Library）

【One-Line Pitch】 A hands-on Rust primer that teaches the language by rebuilding familiar Unix command-line tools, one small, fully tested program per chapter. Best for programmers who know another language and want practical Rust fluency rather than a reference. 【Book Arc】 - **Opening (~0%–10%)**: Frames the book's philosophy—learning by writing complete programs, not passive reading—and introduces Rust's origins, memory safety, static typing, and why it matters for systems work. - **Early (~10%–30%)**: Sets up the toolchain (rustup, Cargo, rustfmt), the book's GitHub repo, and the test-driven workflow you'll reuse in every chapter. - **Middle (~30%–55%)**: Begins the project sequence with a first "Hello, world" program, then moves into organizing projects, compiling with rustc, and using Cargo to scaffold, build, and test. - **Late (~55%–85%)**: The core of the book—writing Rust versions of Unix tools like head and cal, handling arguments, reading inputs, and applying patterns for validation, file I/O, and parsing. (Excerpts do not cover the specific later chapters in detail.) - **Ending (~85%–100%)**: Consolidates the recurring patterns—argument handling, error handling, text parsing, randomness—so you can apply them to your own CLI programs. (Excerpts do not cover the closing chapters directly.) 【Key Takeaways】 - **Learn by building, not by reading** (Opening): The book's central premise is that passively absorbing syntax teaches little; writing complete, working programs is what makes Rust stick. - **Each chapter is a self-contained project** (Early): You start from scratch, add features, work through compiler errors, and test—mirroring real development rather than isolated snippets. - **Tests are a first-class learning tool** (Early): The author advocates test-driven development, using provided tests to break problems into small, verifiable parts and to catch mistakes early. - **The Rust compiler is a partner, not an enemy** (Early): Strict type checking prevents basic errors; when a Rust program compiles, it usually works as intended, which reduces debugging effort. - **Rust binaries are easy to share and deploy** (Early): Compiled executables run without installing Rust or dependencies, and produce far smaller containers than interpreted-language equivalents. - **Unix command-line concepts are part of the curriculum** (Opening): Exit values, arguments, STDIN/STDOUT/STDERR, redirection, and pipes are taught alongside Rust, making the tools and the language mutually illuminating. - **Recurring patterns emerge across projects** (Opening): Validating parameters, reading and writing files, parsing text, and using regular expressions are the reusable building blocks you'll carry into your own programs. - **The book is a primer, not a reference** (Early): It deliberately leaves deep language details to comprehensive texts like Programming Rust and The Rust Programming Language, focusing instead on getting things done. 【Reading Tips】 - **Type every program yourself**: The book explicitly warns against passive reading; run the tests, hit compiler errors, and fix them—that's where the learning happens. - **Deep-read the early setup chapters**: Toolchain, Cargo, and testing workflow are foundational; skimming here will cost you later. - **Skim the licensing and O'Reilly boilerplate**: Front-matter sections on permissions and online learning add no technical value. - **Use the book's GitHub repo alongside your own**: Clone the tests, but write your solutions in a separate repository to build good habits. - **Pair with a language reference**: Keep Programming Rust or The Rust Programming Language nearby for the nitty-gritty the primer intentionally omits. 【Coverage Limits】 These excerpts cover the preface, setup, and early chapters in detail; the specific later projects and their exact chapter titles are not fully represented, so the Late and Ending stages are described at a general level.