Distributed Systems Course

Lesson 1 • Theoretical Limits: CAP and Beyond

Presents CAP theorem, PACELC, and impossibility results. Students use these frameworks to justify architectural choices.

Lesson 2 • System Models and Assumptions

Introduces synchronous, asynchronous, and partially synchronous models. Students apply the correct model when reasoning about algorithm correctness.

Lesson 3 • What Is a Distributed System

Defines distributed systems by their structural and behavioural properties. Establishes vocabulary used throughout the course.

Lesson 4 • Core Challenges and Failure Modes

Surveys partial failures, network unreliability, and timing issues. Frames every subsequent design decision around these constraints.

Lesson 1 • Service Discovery and Load Balancing

Explains how nodes find each other and distribute load. Students configure discovery and balancing strategies for dynamic clusters.

Lesson 2 • Message Passing and Queuing

Covers point-to-point and publish-subscribe messaging models. Connects messaging patterns to decoupling and resilience goals.

Lesson 3 • Network Stack Essentials

Reviews TCP, UDP, and the layers relevant to distributed systems. Provides the transport-layer foundation for higher-level protocols.

Lesson 4 • Remote Procedure Calls

Explains RPC semantics, stubs, and serialisation. Students implement and debug RPC-based services with correct failure handling.

Lesson 1 • Hybrid Logical Clocks

Combines physical and logical time to achieve causality with bounded skew. Students select the appropriate clock scheme for latency-sensitive applications.

Lesson 2 • Physical Clocks and Their Limits

Examines clock drift, NTP, and GPS-based synchronisation. Motivates logical clocks by showing physical clocks cannot provide global order.

Lesson 3 • Consistent Snapshots

Presents the Chandy-Lamport algorithm for capturing global state. Students apply snapshots to debugging, checkpointing, and deadlock detection.

Lesson 4 • Logical Clocks

Introduces Lamport timestamps and their happens-before relation. Students use logical clocks to order events without physical time.

Lesson 1 • Conflict Detection and Resolution

Addresses divergent replicas and strategies for merging concurrent writes. Students implement last-write-wins, CRDTs, and application-level resolution.

Lesson 2 • Consistency Models Spectrum

Defines linearisability, sequential consistency, causal consistency, and eventual consistency. Students map application needs to the appropriate model.

Lesson 3 • Quorum-Based Replication

Explains read and write quorums and their consistency implications. Students calculate quorum sizes for desired durability and availability.

Lesson 4 • Replication Goals and Strategies

Surveys why replication is used and the primary approaches. Frames the consistency-performance trade-off central to this chapter.

Lesson 1 • Distributed Locking and Coordination

Applies consensus to implement distributed locks, barriers, and leader election services. Students avoid common pitfalls like lock expiry races.

Lesson 2 • Byzantine Fault-Tolerant Consensus

Extends consensus to tolerate malicious or arbitrary failures. Students evaluate when BFT protocols are necessary and their cost.

Lesson 3 • Paxos Algorithm

Walks through single-decree and multi-Paxos phases in detail. Students trace message flows and identify failure recovery paths.

Lesson 4 • Raft Consensus Algorithm

Presents Raft as an understandable alternative to Paxos. Students implement log replication, leader election, and membership changes.

Lesson 1 • Partitioning and Sharding

Covers range, hash, and directory-based partitioning strategies. Students design partition schemes that balance load and minimise cross-shard queries.

Lesson 2 • Storage Engine Internals

Examines LSM trees, B-trees, and write-ahead logs. Students predict performance characteristics and tune storage engines accordingly.

Lesson 3 • Distributed Transactions

Explains two-phase commit, three-phase commit, and their failure modes. Students implement atomic cross-partition operations with correct rollback.

Lesson 4 • NoSQL Storage Models

Surveys key-value, document, column-family, and graph storage models. Students match data models to query patterns and consistency requirements.

Lesson 1 • Bulkhead and Isolation Patterns

Isolates failures using thread pools, process boundaries, and resource quotas. Students prevent cascading failures by containing blast radius.

Lesson 2 • Chaos Engineering and Resilience Testing

Introduces controlled fault injection to validate resilience assumptions. Students design experiments that expose hidden failure modes before production.

Lesson 3 • Failure Detection

Covers heartbeats, phi-accrual detectors, and gossip-based detection. Students tune detectors to balance false positives against detection latency.

Lesson 4 • Redundancy and Replication Strategies

Applies active-active, active-passive, and N+1 redundancy models. Students calculate required redundancy for target availability levels.

Lesson 1 • Incident Response and Post-mortems

Establishes on-call practices, runbooks, and blameless post-mortems. Students produce actionable post-mortems that prevent recurrence.

Lesson 2 • Capacity Planning and Load Testing

Forecasts resource needs and validates headroom through load tests. Students build capacity models and interpret load test results.

Lesson 3 • Horizontal and Vertical Scaling

Contrasts scaling strategies and identifies bottlenecks that limit each. Students design stateless services and data tiers that scale independently.

Lesson 4 • Deployment and Rolling Updates

Covers blue-green, canary, and rolling deployment strategies. Students execute zero-downtime deployments and roll back safely on failure.