Programming Rust Fast, Safe Systems Development, 3rd Edition (Jim Blandy, Jason Orendorff etc.) (z-library.sk, 1lib.sk, z-lib.sk)

【One-Line Pitch】 A rigorous, example-driven guide to writing fast, safe systems code in modern Rust, aimed at experienced programmers who want to understand *why* the language works—not just memorize syntax. Read it if you're coming from C++, Java, Python, or Go and want to build low-latency, concurrent, or embedded software without fighting the borrow checker blindly. 【Book Arc】 - **Opening (~0%–10%)**: Frames Rust as the answer to decades of undefined behavior, crashes, and security flaws in C/C++, and argues that safety and performance need not trade off. Establishes who the book is for and how to navigate it. - **Early (~10%–35%)**: A guided tour through small but complete programs—a command-line calculator with tests, a web server, and a multithreaded fractal renderer—plus tooling setup with rustup and Cargo. This gives you a working mental model before the deep material. - **Middle (~35%–55%)**: Core language fundamentals in reading order: basic types and functions, ownership and references, expressions, error handling, crates and modules, structs, enums and patterns. The authors explicitly recommend reading these in sequence. - **Late (~55%–75%)**: Traits and generics as the "last two big concepts," then operator overloading and utility traits, followed by closures and iterators as power tools. Mastering this section unlocks the rest of the book. - **Ending (~75%–100%)**: Remaining chapters are modular and can be read in any order or dipped into as needed—concurrency, async programming, and C interoperability are named in the blurb, though the excerpts do not detail their internal structure. 【Book Arc note】 The excerpts cover the preface, opening chapters, and early tour in detail but thin out sharply after the midpoint; the late-stage bullets above reflect the authors' stated roadmap rather than sampled content. 【Key Takeaways】 - **Safety is a compile-time promise, not a runtime hope** (Early): Rust guarantees that code passing the compiler's checks is free of undefined behavior—dangling pointers, double-frees, null dereferences, and buffer overruns are caught before execution. This reframes debugging: bugs can't silently corrupt unrelated memory. - **Concurrency is tamed by the same restrictions** (Early): The rules that ensure memory safety also prevent data races. Shared immutable data is free; mutable data requires synchronization primitives (mutexes, channels, atomics), and the compiler verifies correct usage. This makes Rust unusually well suited to multithreaded work. - **Systems programming means resource-constrained programming** (Opening): The book targets operating systems, drivers, filesystems, databases, codecs, networking, virtualization, and games—domains where every byte and CPU cycle counts. Rust is positioned as an exceptional tool for exactly this niche. - **The book teaches concepts head-on, not by trial and error** (Early): The authors deliberately tackle Rust's big new ideas up front and in depth, aiming to spare readers the slow grind of learning the borrow checker through repeated failure. - **Ownership and references are the gateway** (Middle): Chapters on ownership and references are the conceptual core; the authors insist on reading the first five chapters in order because everything later depends on them. - **Traits and generics unlock the language** (Late): Traits serve as interfaces and as Rust's mechanism for integrating your types into the language itself; generics and traits together are described as the last two big concepts you need before the rest of the book opens up. - **Error handling is non-negotiable** (Middle): Among the fundamentals chapters, the authors single out error handling as the one you must not skip—a signal that Rust's error model is central to writing production code. - **Cargo is part of the language experience** (Early): Cargo and crates.io are presented as Rust's answer to NPM or RubyGems, with an emphasis on sound version management and reproducible builds—practical infrastructure for real projects. 【Reading Tips】 - **Read the first five chapters linearly, then go modular.** The authors explicitly recommend sequential reading through ownership and references; after traits and generics, chapters can be read in any order or used as reference. - **Do not skip error handling.** It's flagged as essential even within the "skimmable" fundamentals block—skimming it will cost you later. - **Pair the book with a side project.** The preface recommends building something you've never built before that exploits Rust's speed, concurrency, and safety; the concepts land far better with hands-on code. - **Treat the opening tour as orientation, not mastery.** The calculator, web server, and fractal examples are there to show how features cooperate; expect to revisit them after the ownership chapters. - **Expect the borrow checker to be the hard spot.** The book's stated goal is to minimize trial-and-error learning, but the restrictions take practice—budget extra time for ownership, references, and lifetimes. 【Coverage Limits】 The excerpts concentrate on the preface, opening motivation, tooling, and early fundamentals; the late-book chapters on concurrency, async, and C interoperability are named in the blurb and roadmap but not detailed in the sampled material, so this guide cannot assess their depth or specific content.