What you will learn in Think Distributed Systems
Mental models of reliable and scalable software
Chapter by chapter
Chapter 1: Thinking in distributed systems: Models, mindsets, and mechanics
The chapter introduces distributed systems as interacting components and explains why engineers need them to build applications that remain functional under load and failure.
What you learn in chapter 1 →Chapter 2: System models, order, and time
The chapter introduces system models, order, and time as tools for reasoning about what distributed-system behavior can and cannot reveal.
What you learn in chapter 2 →Chapter 3: Failure tolerance
The chapter introduction defines the purpose of failure tolerance and frames the chapter as a theoretical and practical exploration of failure.
What you learn in chapter 3 →Chapter 4: Message delivery and processing
The chapter introduces message delivery and processing by distinguishing literal exactly-once processing from exactly-once processing semantics and warning against assuming guarantees are broader than stated.
What you learn in chapter 4 →Chapter 5: Transactions
This introduction explains why transactions matter in distributed systems and frames the chapter around correctness and completeness rather than ACID alone.
What you learn in chapter 5 →Chapter 6: Distributed transactions
Introduces distributed transactions as changes spanning multiple systems, defines their participants, and previews the chapter’s treatment of Two-Phase Commit.
What you learn in chapter 6 →Chapter 7: Partitioning
The introduction contrasts partitioning with replication and previews the partitioning topics covered in the chapter.
What you learn in chapter 7 →Chapter 8: Replication
The chapter introduces redundancy as a way to preserve durable promises when components can fail.
What you learn in chapter 8 →Chapter 9: Consistency
The introduction contrasts database consistency with the multiple meanings of consistency in distributed systems and previews the chapter’s topics.
What you learn in chapter 9 →Chapter 10: Distributed consensus
The introduction explains why distributed consensus matters: it lets redundant processes act as one and prevents disagreements that could make an application behave incorrectly.
What you learn in chapter 10 →Chapter 11: Durable executions
The introduction previews the chapter’s path from process duration and failure-tolerant execution to sagas and durable executions, presenting durable execution as an abstraction that conceals failure.
What you learn in chapter 11 →Chapter 12: Cloud and services
The chapter introduction frames cloud computing, cloud-native computing, serverless computing, and microservices as popular but vaguely defined ideas, and sets out the chapter’s approach to clarifying them.
What you learn in chapter 12 →Concepts explained in this book
- distributed systemA computing system whose components execute across multiple networked locations and must coordinate despite having incomplete views of system state.
- mental modelAn internal representation of a target system that forms the basis for comprehension, communication, and reasoning.
- database transactionA transaction is a logical unit of work whose operations are treated as a single coherent execution with specified correctness properties.
- atomicityFailure atomicity is the property that an operation either completes as an indivisible unit or exposes no partial effect when execution fails.
- exactly-once deliveryA message-delivery guarantee in which each sent message is delivered exactly one time.
- safetyA system guarantee that a specified bad event or condition will never occur.
- livenessA system guarantee that a specified good event or condition will eventually occur.
- networkThe communication infrastructure through which distributed-system components send and receive messages.
- replicationReplication is the maintenance of multiple copies or instances of data or functionality to reduce reliance on a single component and improve availability or performance.
- transaction coordinatorA component that receives requests, assigns them an order, and distributes the ordered requests to other components.
- linearizabilityCAP consistency is the safety guarantee that every successful read reflects the value of the most recent write, or the read returns a failure response.
- application-level failureAn application-level failure is a failure caused by application semantics or business logic rather than by the underlying platform.
- platform-level failureA failure reported by the software or infrastructure platform when an operation cannot be connected or executed at that platform level.
- transient failureA failure whose subsequent occurrence probability is not elevated and that resolves automatically without intervention.
- at-most-once deliveryA message-delivery guarantee in which each sent message is delivered zero or one time.
- idempotencyIdempotence is the property of an operation that applying it multiple times has the same effect as applying it once.
- two-phase commitA distributed transaction commit protocol that coordinates commitment in two phases among participating processes.
- distributed transactionA distributed transaction is a transaction whose participants are located across multiple components or stores and must reach a coordinated commit-or-abort outcome.
- race conditionA concurrency situation in which at least one possible ordering of actions produces an incorrect result.
- consensusAn algorithm that enables distributed nodes to agree on a replicated state or sequence of operations.
- scalabilityScalability is the ability of a system to maintain its intended behavior as demand or workload increases.
- intermittent failureA failure whose subsequent occurrence probability is elevated and that can resolve automatically after a delay.
- permanent failureA failure whose subsequent occurrence is certain and whose resolution requires manual intervention.
- platform layerThe platform layer is the architectural layer providing the infrastructure and runtime environment for applications.
- CAP theoremThe CAP theorem is a formal impossibility result stating that, under its specified asynchronous system model, a distributed system cannot guarantee consistency and availability during a network partition.
- resource managerA resource manager is a component that manages a transactional resource and executes the local transaction for that resource.
- message-delivery semanticsThe rules describing whether, how often, and in what order messages reach their recipients.
- request-response message exchangeCommunication between distributed components in which messages are sent through a network.
- eventual consistencyA form of eventual consistency that guarantees eventual delivery and convergence only after updates cease, without constraining intermediate reads or continuously updated behavior.
- failure transparencyFailure-transparent recovery is recovery that hides failures from process definitions and other observers so the system continues to appear to provide its specified behavior.
- log replicationLog replication is the process of copying log entries across nodes so that they maintain a consistent replicated log.
- mathematical equivalenceA relation in which two system states or outcomes are considered indistinguishable according to an application-defined criterion, even if their representations differ.
- physical timeTime as measured by clocks and used to characterize the real-time occurrence and duration of events.
- leader electionA Raft protocol that elects a leader for a term and starts a new election when the current leader is suspected to have failed.
- durabilityDurability is a transaction property requiring committed effects to persist despite subsequent failures.
- reliabilityThe ability of a system to continue providing its intended service correctly over time and under expected conditions.
- end-to-end argumentA systems design principle that places functionality at the endpoints when lower layers cannot implement it correctly and completely.
- failure classificationA scheme for grouping failures according to dimensions such as their location or time-related behavior.
- happens-before relationThe happened-before relationship is a causal ordering relation in which one distributed-system event precedes another through local execution and message communication.
- recoveryRecovery is a technique for restoring a system or transaction to an acceptable state after failure or interruption.
- quorumA quorum is a sufficient subset of distributed participants whose agreement or participation allows a decision to be made safely.
- concurrencyConcurrent execution is the overlapping execution of operations from multiple transactions without requiring one transaction to finish before another begins.
- logical clockA logical clock is a distributed-systems mechanism that assigns logical timestamps or ordering information to events without representing physical time.
- idempotency keyA client-supplied identifier that lets an API associate repeated requests with the same logical operation and return a consistent result.
- durable executionDurable execution is an execution model that persists workflow progress and state so execution can resume after failures without requiring application logic to handle those failures explicitly.
- commutative operationAn operation whose result is unchanged when its operands or applications are reordered.
- noncommutative operationAn operation whose result can change when its operands or applications are reordered.
- request tagAn ordering marker attached to a request to identify its position relative to other requests.
- resilienceThe ability of a system or protocol to continue providing acceptable behavior despite component or network failures.
- physical clockA physical clock is a timekeeping mechanism that measures elapsed or calendar time using a physical process.
- completenessThe property of a mental model in which every relevant fact of the system is represented in the model.
- logical objectA logical object is an abstract entity whose representation or storage may be divided among multiple physical objects.
- physical objectA physical object is a concrete representation or storage unit that embodies part or all of a logical object.
- backward recoveryBackward recovery is a failure-mitigation strategy that returns a system from an illegal intermediate state to a state equivalent to its initial legal state.
- logical timeLogical time is a system-defined ordering measure for events that does not necessarily correspond to elapsed physical time.
- state machine safetyState machine safety is the property that no two processes apply different log entries at the same index to their state machines.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.
