Think Distributed Systems (Dominik Tornow)（Z-Library）

【One-Line Pitch】 A conceptual, illustration-driven guide to distributed systems that trades implementation detail for durable mental models, so you can reason about correctness, failure, and consensus with confidence. Best for engineers and architects who already build distributed software but want clearer thinking rather than another framework tutorial. 【Book Arc】 - **Opening (~0%–10%)**: Frames the whole project — knowing vs. understanding, mental models as perceived truth vs. system as ground truth, and the claim that every modern application is distributed to some degree. - **Early (~10%–30%)**: Builds the modeling vocabulary: correctness and completeness of models, safety vs. liveness, holons/holarchies for messy hierarchies, and the "Distributed Systems Incorporated" analogy (rooms = components, tubes = network, mailbox = interface). - **Early–Middle (~30%–45%)**: System models, order, and time — what assumptions a model makes, component failure classes (crash-stop, omission, crash-recovery), unreliable networks, partial synchrony, and why physical clocks mislead while logical time (happened-before, Lamport clocks) orders events. - **Middle (~45%–60%)**: Failure tolerance — normal vs. failure transitions, the exactly-once credit-card example, and the key split between failure detection (safety) and failure mitigation (liveness). - **Middle–Late (~60%–85%)**: The mechanics core — message delivery and processing guarantees, transactions and atomic commitment, distributed transactions and Two-Phase Commit, partitioning (range, hash, consistent hashing, rebalancing), replication, and consistency. - **Late–Ending (~85%–100%)**: Distributed consensus, durable executions, and cloud/services — pulling the earlier models together at the level of whole systems and deployed services. 【Key Takeaways】 - **Mental models are the real subject** (Opening): The book's central move is treating a model as a set of perceived facts judged by correctness (no falsehoods) and completeness (no relevant omissions) — relevance being application-specific. This reframes debugging as model repair. - **System models are load-bearing assumptions** (Early–Middle): Whether components may fail, messages may be lost, or clocks are synchronized determines which algorithms are even correct; a small rule change can invalidate a strategy, like a board game. - **Practical systems are partially synchronous** (Middle): The realistic model combines crash-stop, omission, and crash-recovery failures over an unreliable network that may reorder, drop, or duplicate messages; Byzantine failures are explicitly set aside. - **Physical time is unreliable; logical time orders events** (Middle): Clock skew and drift make wall-clock comparison across components dangerous, while happened-before gives a partial order and Lamport clocks give causally consistent timestamps — though the author notes Lamport clocks are more discussed than implemented. - **Failure handling splits into detection and mitigation** (Middle): Detection underpins safety (inhibit dangerous actions); mitigation underpins liveness (resume progress). The exactly-once credit-card charge is the running illustration of why this distinction matters. - **Transactions promise concurrency and failure abstraction** (Middle–Late): The model rests on correctness, serializability, and completeness, with aborts occurring at application or platform level — the foundation for distributed transactions. - **Atomic commitment across multiple resource managers is the hard part** (Late): Two-Phase Commit is presented first without failure, then with failure, exposing blocking vs. nonblocking behavior and motivating improvements. - **Partitioning and replication are complementary mechanics** (Late): Assignment strategies (range, hash), repartitioning, consistent hashing, and overpartitioning/rebalancing are treated as design choices that interact directly with consistency and consensus. 【Reading Tips】 - Read chapters 1–3 slowly and actively: the modeling vocabulary (correctness/completeness, safety/liveness, holons) is reused everywhere later, so skimming here costs you the rest of the book. - Treat the analogies as tools, not decoration — the office-building model and board-game framing are meant to be re-applied to your own systems; pause and map them onto something you operate. - Deep-read the failure, transaction, and consensus chapters if you work on data infrastructure; skim the partitioning/replication mechanics if you already know consistent hashing, but still read the consistency chapter for how it connects. - Keep a running list of your own system's assumptions (failure modes, clock reliance, delivery guarantees) and check them against the system-model chapter — that's the book's intended payoff. - Don't expect code-heavy walkthroughs; the value is in definitions and reasoning patterns, so take notes on definitions rather than implementations. 【Coverage Limits】 This guide is based on stratified excerpts covering roughly the first half of the book in detail (front matter, chapter list, and chapters 1–3), with later chapters (transactions through cloud/services) visible mainly through the table of contents and brief mentions. Specific arguments, examples, and conclusions from chapters 5–12 are therefore not covered here.