Command-Line Rust A Project-Based Primer for Writing Rust CLIs (Ken Youens-Clark)（Z-Library）

【One-Line Pitch】 A hands-on Rust primer that teaches the language by rebuilding classic Unix command-line tools one small, fully tested program at a time. Best for developers who know some programming but want practical Rust fluency through real, runnable utilities rather than abstract language theory. 【Book Arc】 - **Opening (~0%–10%)**: Sets up the book's philosophy — Rust's strict compiler and testing culture lead to more maintainable programs — and previews the project-based approach through the table of contents. - **Early (~10%–30%)**: Establishes the toolchain and workflow: compiling with Cargo, using `$PATH`, pulling crates from crates.io, reading exit statuses, and writing unit and integration tests. Builds `true`/`false` and an `echo` clone to teach argument parsing and composability. - **Early–Middle (~30%–45%)**: Moves into file I/O and text processing with `cat` and `head`, covering optional arguments that take values, parsing strings into numbers, `From`/`Into`/`as` conversions, iterators, and reading bytes versus characters. - **Middle (~45%–60%)**: Deepens data handling with `wc` and related tools — counting lines, words, and bytes, handling STDIN, and learning why reading whole files into memory is dangerous versus streaming safely. - **Late (~60%–90%)**: Tackles more complex utilities like `uniq`, `tail`, and `fortune`, introducing regular expressions, randomness, and more intricate argument validation and error handling. - **Ending (~90%–100%)**: Consolidates the testing, crate usage, and problem-solving patterns built across the projects, reinforcing how to apply Rust to everyday tooling work. 【Key Takeaways】 - **Rust's compiler is a strict but valuable partner** (Early): The author frames type checking as preventing basic errors and argues that getting a program to compile usually means it works as intended. - **Testing is woven into every project from the start** (Early): Unit tests, integration tests, and helper functions that compare program output against expected files are treated as core skills, not afterthoughts. - **Exit statuses make programs composable** (Early): Correctly reporting success or failure lets tools chain with `&&` and other shell constructs, a hallmark of well-behaved CLI programs. - **Argument parsing deserves real structure** (Early–Middle): Using crates like clap, the book shows how to define positional and optional arguments, validate them, and produce helpful error messages with nonzero exit codes. - **File I/O has safe and dangerous paths** (Middle): Reading entire files into memory can crash on large inputs; the book contrasts this with streaming approaches using `take` and careful byte handling. - **Bytes and characters are not interchangeable** (Middle): UTF-8 validity matters — `String::from_utf8_lossy` handles invalid sequences, and slicing bytes can panic on empty or multibyte inputs. - **Type conversions and Option/Result chaining are everyday tools** (Middle): Patterns like `Option::map`, `transpose`, and `?` propagation appear repeatedly when parsing and validating configuration. - **Each chapter is a complete, testable program** (Throughout): The project-based structure means every concept lands in a working utility, reinforcing retention through practice. 【Reading Tips】 - **Deep-read the testing chapters early**: The testing infrastructure (helper functions, expected-output files, `mk-outs.sh` scripts) is reused throughout, so investing time there pays off across every later project. - **Skim the table of contents and chapter previews first**: They map which Unix tools are rebuilt and in what order, helping you decide which projects align with your goals. - **Treat the "danger" examples as lessons, not templates**: The book deliberately shows unsafe file-reading patterns to explain why they fail — understand the reasoning rather than copying the code. - **Run every program yourself**: The value is in compiling, testing, and debugging; reading alone misses the compiler-feedback loop that the book is built around. - **Use the "Going Further" sections as stretch goals**: They suggest extensions after each project, useful if you want more practice beyond the guided solution. 【Coverage Limits】 The excerpts cover the book's opening philosophy, early toolchain setup, and several middle chapters (`cat`, `head`, `wc`, `tail`, `fortune`), but do not detail the full solutions or later chapters. Specific chapter counts, exact page ranges, and the complete list of projects beyond those mentioned are not fully covered.