Dr Martin Kleppmann’s 16-lecture course splits into two halves. The first eight lectures dive into concurrency control. You start with threads, locks and atomic operations. Then you’ll study classic algorithms like Lamport’s bakery, semaphores in producer-consumer setups, and reader-writer locks. Monitors, condition variables and kernel APIs (pthreads, Java, OpenMP) follow. By lecture six, you explore message-passing models—actors, CSP and transactions with ACID guarantees. The final two sessions cover history graphs, two-phase locking, optimistic control and recovery: logging, checkpoints, lock-free code and hardware/software transactional memory. The second half turns to distributed systems over eight more lectures. It begins with RPC mechanics and failure modes: unbounded delays, partial crashes and Byzantine faults. You’ll compare synchronous, partially synchronous and asynchronous network models, then tackle time—UTC, NTP, physical drift—and logical clocks (Lamport and vector). Broadcast protocols establish orderings; quorums and state-machine replication enforce consistency. Raft appears in its own session, alongside FLP impossibility. You’ll also cover two-phase commit, linearizability, eventual consistency and CAP. The course closes with case studies on CRDTs, collaborative editing and Google Spanner’s TrueTime API. By course end, you’ll judge threading models, locking trade-offs and language support. You’ll know how dynamic resource allocation invites deadlock and how transactions manage isolation and durability. On the distributed side, you’ll grasp fault tolerance, replication strategies, replica consistency and the impact of scale. You’ll have seen core algorithms—consensus, total order broadcast, two-phase commit—and practical tools like RPC middleware. Recommended texts include Tanenbaum’s Modern Operating Systems, Goetz’s Java Concurrency in Practice and Kleppmann’s Designing Data-Intensive Applications.