Distributed Systems

This introductory lecture establishes core concepts of distributed systems, examining fundamental challenges, desirable properties like scalability and fault tolerance, and common architectural patterns.

This lecture introduces Remote Procedure Call (RPC) as a fundamental mechanism for inter-process communication in distributed systems. It examines the design principles and challenges, including marshalling, message passing semantics, and error handling.

This lecture introduces the fundamental system models for distributed computing, analyzing various failure modes, communication paradigms (e.g., synchronous vs. asynchronous), and ordering guarantees essential for robust distributed system design. It lays the groundwork for understanding fault tolerance and consistency in complex distributed architectures.

This lecture segment introduces the complexities of physical time in distributed systems, detailing issues such as clock drift, the inherent inaccuracies of hardware clocks, and the mechanisms of Network Time Protocol (NTP) for synchronization across nodes.

This lecture investigates the fundamental challenges of clock synchronization in distributed systems, contrasting physical clock synchronization protocols like NTP with logical clocks and vector clocks, and their implications for event ordering.

This lecture introduces the concept of causality in distributed systems, detailing Lamport's happens-before relation and its implications for ordering events across independent processes. It covers vector clocks as a mechanism to capture causal dependencies.

This lecture introduces the concept of logical time in distributed systems, contrasting it with physical time. It details Lamport timestamps and vector clocks as mechanisms for establishing causal ordering of events across distributed processes.

This lecture investigates different guarantees for message delivery in broadcast communication, including FIFO, causal, and total order broadcast, crucial for consistent state management in distributed environments.

The lecture explores the principles of data replication in distributed systems, covering techniques like leader-based and leaderless replication, and their implications for availability and consistency models.

This lecture introduces the fundamental problem of consensus in distributed systems, exploring the challenges of achieving agreement among multiple nodes in the presence of failures and network latency. It lays the groundwork for understanding key algorithms like Paxos and Raft.

This lecture provides an in-depth explanation of the Raft consensus algorithm, detailing its leader election, log replication, and safety properties designed for understandability and practical implementation.

This lecture analyzes the two-phase commit protocol, a classic distributed transaction mechanism, examining its operational phases, failure modes, and suitability for ensuring atomicity across multiple nodes.

The session defines linearizability as a strong consistency model for distributed systems, illustrating its strict real-time ordering guarantee and contrasting it with weaker consistency properties.

This lecture delves into eventual consistency, a relaxed consistency model widely adopted in large-scale distributed systems, discussing its benefits for availability and partition tolerance, alongside its challenges.

This lecture examines the architecture and synchronization challenges of collaborative software, including operational transformation (OT) and conflict-free replicated data types (CRDTs), which enable real-time co-editing.