Uni Reading List
Index / 001 EN
Distributed Systems cover

Computer Science

Computer Science

Distributed Systems

Maarten van Steen; Andrew S. Tanenbaum

A principles-first textbook on distributed systems that explains architectures, processes, communication, naming, coordination, consistency, replication, fault tolerance and security, with examples drawn from existing systems placed next to the principles they illustrate. The fourth edition adds material on blockchain systems and updates all code examples to Python 3. The authors provide a free personalised digital copy to readers who register an e-mail address.

Prerequisites: Operating systems and computer networks at an introductory level, plus programming experience; the Python examples are short and readable.

Difficulty Level
Intermediate
Academic Level
Undergraduate
distributed systemsconsistencyreplicationfault toleranceopen accessTextbook

01 / Reading Guide

Reading Guide

Citation

van Steen, M., & Tanenbaum, A. S. (2023). Distributed Systems (4th ed.). distributed-systems.net. Free personalized copy from the authors' site: https://www.distributed-systems.net/index.php/books/ds4/

Chapter Summary

The book has nine chapters. According to the author's page, it stays close to the setup of the third edition: examples of existing distributed systems are placed next to the general principles they illustrate, material that can be skipped on first reading is set in boxed sections, and blockchain systems and their components are discussed throughout. All Python code was updated to Python 3, and the complete examples are available from the author's site.

Chapter 1: Introduction

The opening chapter moves from networked systems to distributed systems and separates distributed from decentralized systems. It sets out design goals (resource sharing, distribution transparency, openness, dependability, security and scalability), classifies distributed systems (high-performance computing such as cluster and grid computing, distributed information systems and application integration, and pervasive systems including mobile computing and sensor networks, with the cloud-edge continuum), and ends with pitfalls in developing distributed systems.

Chapter 2: Architectures

Chapter 2 starts with architectural styles (layered, object-based, RESTful and publish-subscribe or coordination-based styles) and the role of middleware. It then compares system architectures: layered and multitiered centralized designs, symmetrically distributed designs (structured and unstructured peer-to-peer systems, super-peers, BitTorrent), and hybrid designs (cloud computing, edge-server architectures and blockchains).

Chapter 3: Processes

The chapter covers threads, virtualization (including containers and the relation between virtual machines and cloud computing), clients, servers (general organization, state, object servers, examples including Apache and content delivery networks) and code migration, including the migration of virtual machines.

Chapter 4: Communication

This chapter starts from layered protocols and the types of communication, then covers remote procedure calls, message-oriented communication (sockets, request-reply, publish-subscribe, pipelines, MPI, and queue-based messaging with message brokers) and multicast communication, including application-level multicasting and epidemic protocols for information dissemination.

Chapter 5: Coordination

Chapter 5 covers clock synchronization, logical clocks and vector clocks, mutual exclusion and election algorithms, with ZooKeeper, Raft and proof-of-work or proof-of-stake elections as examples. It then turns to gossip-based coordination, distributed event matching and location systems such as GPS and Vivaldi.

Chapter 6: Naming

The naming chapter distinguishes names, identifiers and addresses and covers flat naming (broadcasting, forwarding pointers, home-based approaches, distributed hash tables such as Chord), structured naming (name spaces, resolution, DNS, NFS), attribute-based naming (directory services, LDAP) and named-data networking.

Chapter 7: Consistency and Replication

This chapter explains why data is replicated and then covers data-centric consistency models (sequential, causal, eventual and continuous consistency), client-centric consistency models (monotonic reads and writes, read your writes, writes follow reads), replica management, consistency protocols (primary-based and replicated-write protocols), and caching and replication in the Web.

Chapter 8: Fault Tolerance

The chapter introduces dependability and failure models, then process resilience and consensus, covering flooding-based consensus, Raft, Paxos and Byzantine fault tolerance (PBFT), with the CAP theorem. It continues with reliable client-server and group communication, distributed commit (two-phase commit) and recovery through checkpointing and message logging.

Chapter 9: Security

The security chapter covers security threats, policies and mechanisms (including privacy and the GDPR), cryptography, authentication (shared keys, Needham-Schroeder, public keys, Kerberos, TLS), trust in distributed systems (Sybil and eclipse attacks, blockchain approaches), authorization (access control, delegation, OAuth) and monitoring through firewalls and intrusion detection.

Key Concepts

Chapters 1–4: Foundations

  • Distribution transparency and scalability: hiding distribution from users and applications, and growing in size and geography.
  • Architectural styles and middleware: how components and connectors are organized, including peer-to-peer, cloud, edge and blockchain systems.
  • Virtualization and code migration: running and moving software across machines.
  • RPC and message-oriented communication: the main ways processes exchange data.

Chapters 5–6: Coordination and Naming

  • Logical and vector clocks: ordering events without a global clock.
  • Mutual exclusion and election: coordinating access and choosing leaders.
  • Flat, structured and attribute-based naming: locating entities, with Chord and DNS as examples.

Chapters 7–9: Consistency, Fault Tolerance and Security

  • Consistency models: data-centric and client-centric guarantees for replicated data.
  • Consensus and distributed commit: Paxos, Raft, PBFT and two-phase commit.
  • Authentication, authorization and trust: cryptographic protocols and access control.

Critical Analysis

Strengths

  • Principles first, with systems alongside. The author states that examples of existing systems are placed where the general principles are discussed, and the chapters cover recurring problems (naming, coordination, consistency, fault tolerance) rather than a catalogue of products.
  • Executable code. All Python code was updated to Python 3, and the author says virtually all examples can be run through a simple script; the complete examples and figures are in a downloadable archive.
  • Current topics. Blockchain systems are discussed throughout, and the contents include cloud and edge architectures, containers, Raft and Paxos, Byzantine fault tolerance, GDPR and OAuth.
  • Open access. A personalized digital copy is free, a full set of slides in PDF and PPTX is available, and the LaTeX source for the slides is provided.
  • Optional material marked. Boxed sections can be skipped at first reading, so a newcomer can follow the main line.

Limitations

  • Fewer chapters on data systems. Transactions, distributed file systems and multimedia are not chapters of their own: the NFS example appears under architectures and naming, and nested transactions appear in the application-integration discussion in Chapter 1. Readers who want more on storage and transactions need another book.
  • Practical friction. The author notes that special packages such as Redis must be installed for some examples, and that free-copy requests can take a while to be fulfilled.
  • Self-published. The book is distributed by the author, with the paperback through Amazon, and later versions (4.01 to 4.03) carry small corrections, so readers should check which version they and their course use.
  • Simplified code. The coding examples leave out many details for readability, as the author states, so they illustrate ideas but are not production-quality implementations.

Where It Fits in the Course

Van Steen and Tanenbaum is the principles-first distributed systems textbook among the course books. Coulouris, Dollimore, Kindberg and Blair's Distributed Systems: Concepts and Design is longer (21 chapters), older (2011) and gives more room to middleware, security, transactions and extended case studies, so the two are alternatives or complements. Vitillo's Understanding Distributed Systems is a concise introduction for developers that can be read first, and Kleppmann and Riccomini's Designing Data-Intensive Applications is a practical study of data systems that covers replication, partitioning and stream processing and fills the gap on storage and transactions noted above.

Cachin, Guerraoui and Rodrigues's Introduction to Reliable and Secure Distributed Programming is a graduate text that specifies broadcast, shared-memory and consensus abstractions precisely; it is the natural next step after Chapters 5 and 8 of this book. Pacheco's An Introduction to Parallel Programming is a separate path for writing parallel programs on multicore machines and clusters.

How to Use This Book

The book suits a distributed systems course for upper-level undergraduates and beginning graduate students, and software engineers who build networked services. The author's page does not list prerequisites; some programming experience will help with the Python examples, and some background in operating systems and networks will help with the chapters on processes and communication.

A practical plan:

  • Core: Chapters 1 and 2, then Chapter 4 (communication), Chapter 5 (clocks, mutual exclusion, election), Chapter 7 (consistency and replication) and Chapter 8 (fault tolerance and consensus).
  • Selective: Chapter 3 if operating-system background is thin; Chapter 6 on naming; Chapter 9 on security, which can be read independently.
  • Practice: download the code and figures archive, run the Python examples (installing the required packages), and use the slides for revision. Skip the boxed sections on a first pass.
  • Edition check: use the current version (4.03 or later) of the free copy, since page numbering is kept while small corrections are made.