The Rust Programming Handbook (Francesco Ciulla) (z-library.sk, 1lib.sk, z-lib.sk)

【One-Line Pitch】 A hands-on, end-to-end tour of Rust that pairs the language's core principles with practical projects, aimed at developers with prior coding experience who want to write safe, fast, and concurrent software. If you're curious why Rust keeps topping "most admired language" polls and want a guided path from first program to deployment, this is for you. 【Book Arc】 - **Opening (~0%–15%)**: Sets expectations and prerequisites — the book assumes comfort with variables, loops, functions, and the command line, plus a working Rust toolchain via rustup, an editor (VS Code with rust-analyzer, or RustRover), and Docker for later chapters. It frames Rust's pitch: performance, memory safety without a garbage collector, and concurrency. - **Early (~15%–35%)**: Lays the conceptual foundation — Rust's three design goals (type safety, performance, concurrency), the ownership model, and the borrow checker. It also surveys the ecosystem (Serde, Tokio, Axum, Polars) and explains why Rust matters for systems, web, and data work. - **Middle (~35%–60%)**: Moves into the language's harder machinery — error and panic handling, generics, traits, and lifetimes for polymorphism, then object-oriented patterns via traits and structs, and functional thinking through iterators and closures. Testing is introduced as a first-class habit. - **Late (~60%–85%)**: Tackles memory and concurrency at depth — smart pointers (Box, Rc, Arc), manual resource management without a GC, and thread-safe concurrency that avoids data races and deadlocks. - **Ending (~85%–100%)**: Applies everything to real work — building a fullstack web application, low-level system programming (file I/O, networking, hardware), and containerizing/deploying with Docker and CI/CD. An online appendix covers common pitfalls. 【Key Takeaways】 - **Rust's core promise is memory safety without a garbage collector** (Early): ownership rules checked at compile time replace runtime GC, which is the mindset shift that trips up most newcomers. - **The borrow checker is the gatekeeper, not the enemy** (Early): it tracks reference lifetimes at compile time to guarantee valid pointers and prevent data races — the book frames the compiler as strict but protective. - **Type safety, performance, and concurrency are the three design pillars** (Early): understanding these goals explains why Rust makes the trade-offs it does versus C, C++, Java, or Go. - **Polymorphism in Rust runs through generics, traits, and lifetimes** (Middle): traits define shared behavior, generics allow flexible types, and lifetimes validate references — the trio that unlocks idiomatic Rust design. - **Iterators and closures enable concise, high-performance functional code** (Middle): this is where Rust's zero-cost abstractions pay off, letting expressive code compile to efficient machine instructions. - **Smart pointers solve shared ownership and thread safety** (Late): Box, Rc, and Arc are the tools for managing memory when simple ownership isn't enough, especially across threads. - **Concurrency is a first-class concern, not an afterthought** (Late): the language is designed to exploit multi-core processors while structurally preventing data races and deadlocks. - **Rust's ecosystem turns the language into a platform** (Middle): crates like Serde (serialization), Tokio (async), Axum (web), and Polars (dataframes) extend Rust into web, systems, and data-intensive domains. 【Reading Tips】 - **Deep-read the ownership and borrow-checker material** (Early): this is the conceptual bottleneck; skimming it will make every later chapter harder. Budget extra time and re-read if needed. - **Skim the ecosystem survey if you already know the crates**: the Serde/Tokio/Axum/Polars overview is orientation, not instruction — return to it when a project needs a specific library. - **Treat the late project chapters as the real test**: the fullstack web app, system programming examples, and Docker/CI-CD deployment are where abstract concepts become concrete. Do them hands-on rather than reading passively. - **Keep the online pitfalls appendix bookmarked**: it addresses common mistakes and community best practices, useful as a debugging companion once you're writing your own code. - **Set up your environment before Chapter 1**: install rustup, pick an editor with rust-analyzer, and have Docker ready — the book assumes this and moves fast once it starts. 【Coverage Limits】 This guide is synthesized from stratified excerpts covering the preface, table of contents, and early chapters; the excerpts do not cover the detailed content of the middle and late chapters, so chapter-level specifics beyond their titles and stated themes are not represented here.