Consensus, replication, and trust without a central coordinator — from vector clocks to blockchains, every protocol traced step by step.
Synchronous vs. asynchronous models, and what it means for a node to fail — crash, omission, or Byzantine.
Lamport clocks and vector clocks — establishing a 'happened-before' relation without a shared clock.
Ricart-Agrawala and token-ring algorithms for a critical section when there's no shared memory to lock.
Concurrent vs. causally-ordered events, and why vector clocks capture causality exactly while scalar clocks don't.
Linearizability, sequential consistency, causal consistency, and eventual consistency — a strictness spectrum.
Why a network partition forces a choice between consistency and availability — and what PACELC adds beyond CAP.
Given a trace of reads and writes across 3 replicas, find the exact operation that breaks linearizability.
One node takes writes and ships a log to backups — simple, but the primary is a single point of failure.
Read and write quorums that overlap guarantee you always see the latest write — the R + W > N rule.
Prepare/promise then accept/accepted — reaching agreement on one value even with node failures.
Skip Paxos's prepare phase across many decisions once a stable leader is elected.
Leader election, log replication, and safety — the same guarantees as Paxos, designed to be understandable.
Tolerate nodes that lie, not just nodes that crash — and why you need 3f+1 replicas to survive f of them.
Consensus on a log plus a deterministic state machine is enough to replicate any service.
Step through term numbers, vote requests, and split votes across a 5-node cluster.
A coordinator collects votes, then commits or aborts everywhere — atomic, but blocks on coordinator failure.
An extra pre-commit phase removes 2PC's single blocking point — at the cost of an extra network round trip.
Break a long transaction into local steps, each with an explicit undo, instead of holding locks across services.
Build a wait-for graph across nodes and detect a cycle that no single node can see on its own.
Capture a consistent global state of a distributed system using marker messages, without stopping the world.
Follow marker messages and in-flight channel states to reconstruct one consistent cut.
Every node forwards to a few random peers each round — information spreads exponentially, no central broadcast needed.
Place nodes and keys on the same ring so adding or removing a node only reshuffles a 1/N slice of keys.
Route a lookup to the right node in O(log N) hops using finger tables over the hash ring.
XOR distance and k-buckets — the routing scheme behind BitTorrent's DHT and IPFS.
Data structures whose concurrent updates always merge to the same result, with no coordination at all.
Vector clocks, sloppy quorums, and hinted handoff — Amazon Dynamo's recipe for an always-writable store.
Combine consistent hashing, gossip membership, and vector clocks into one small working store.
Hash functions, digital signatures, and Merkle trees — the building blocks every blockchain is made of.
Agreement by computational cost — why the longest valid chain wins, and what that costs in energy.
Replace computational cost with economic stake — and the new attack surface that comes with it (nothing-at-stake).
Temporary forks resolve themselves probabilistically — finality is a confidence level, not a guarantee.
Code that runs identically on every node and whose state transitions are themselves the consensus object.
Split validators and state across shards to scale throughput — and the cross-shard transaction problem it creates.
Why identity is free in a P2P network, and how proof-of-work/stake make fake identities expensive instead.
Hash a block header against a difficulty target, chain it to the previous block, and validate the result.
Address data by its hash, not its location — so the same content is identical no matter which peer serves it.
Train a shared model across many devices' local data without any raw data ever leaving the device.
Prove a statement is true without revealing why it's true — the cryptography behind private, verifiable computation.
Self-sovereign identity: prove a claim about yourself without a central authority vouching for it in real time.
Pick the consistency model, replication strategy, and consensus protocol for a system you specify from scratch.