Distributed Systems

Taught by RTM himself at MIT: dry, surgical systems thinking on partial failures, idempotency, network partitions, and the trade-offs between consistency and performance.

Dissects threads vs. event-driven I/O, Go goroutines, mutex discipline, race detectors, and why Remote Procedure Calls cannot transparently mimic local function calls under network drops.

Examines SOSP 2003's most influential storage paper: how GFS traded strict POSIX consistency for huge aggregate throughput across thousands of failing commodity disks.

Contrasts state transfer vs. replicated state machines using VMware Fault Tolerance—replaying deterministic x86 instruction streams and eliminating split-brain via test-and-set shared storage.

Practical deep dive into condition variables, goroutine lifecycles, channel deadlock traps, and structuring concurrent state machines cleanly before implementing Raft.

Why quorum majorities defeat split-brain network partitions, followed by a line-by-line walkthrough of Raft leader election, terms, and AppendEntries log replication.

Covers the subtle Figure 8 election safety restriction in Raft, crash recovery from persistent state, log snapshotting, and duplicate-RPC suppression for linearizable key-value stores.

Shows how ZooKeeper relaxes strict linearizability on reads (FIFO client order + zxid watches) to achieve massive read scalability while keeping writes totally ordered via ZAB.

This lecture delves into advanced replication techniques, analyzing the Chain Reaction Accelerated Quorum (CRAQ) protocol for improved write performance and fault tolerance in distributed systems.

The session examines cloud-native replicated databases, focusing on Amazon Aurora's architecture, its quorum-based storage service, and design principles for high availability and durability.

This lecture explores cache consistency mechanisms in distributed file systems, specifically analyzing the Frangipani file system's approach to maintaining coherent data across multiple clients.

The lecture covers the complexities of distributed transactions, discussing techniques like two-phase commit (2PC) for ensuring atomicity and consistency across multiple participating nodes.

This session meticulously analyzes Google Spanner, a globally distributed database, examining its TrueTime API for external consistency and its multi-version concurrency control mechanisms.

This lecture introduces optimistic concurrency control, contrasting it with pessimistic methods and detailing validation phases to detect and resolve conflicts in highly concurrent distributed systems.

The session investigates Apache Spark as a prominent big data processing framework, explaining its RDD abstraction, fault tolerance mechanisms, and in-memory computation model.

This lecture focuses on practical cache consistency, examining how Facebook uses Memcached to achieve high performance and low latency while maintaining data coherence across its vast infrastructure.

The lecture explores causal consistency models, specifically introducing the COPS (Casual Order Preserving Store) system and its vector clock implementation to enforce causality in distributed data stores.

This session introduces fork consistency as a weaker consistency model and then transitions to Certificate Transparency, analyzing its role in detecting misissued or malicious SSL/TLS certificates.

This lecture offers a technical deep dive into Bitcoin, dissecting its proof-of-work consensus mechanism, blockchain data structure, and implications for decentralized, trustless systems.

The session examines Blockstack, a decentralized computing network built on blockchain technology, exploring its approach to user-owned data, decentralized identity, and DApp development.