Distributed Systems: Concepts and Design

Citation

Coulouris, G., Dollimore, J., Kindberg, T., & Blair, G. (2011). Distributed Systems: Concepts and Design (5th ed.). Pearson.

Chapter Summary

The book has 21 chapters, which the authors arrange under seven topic areas. Their stated aim is to explain the principles on which the Internet and other distributed systems are based, together with their architecture, algorithms and design, using a top-down approach of abstract models, algorithms and detailed case studies. The chapters below are grouped by the authors' own organization.

Chapters 1–2: Characterization of Distributed Systems; System Models

The first two chapters give a conceptual overview. Chapter 1 covers examples of distributed systems, trends, resource sharing, the main challenges (the preface names scalability, heterogeneity, security and failure handling as the most significant) and the World Wide Web as a case study. Chapter 2 develops physical, architectural and fundamental models for process interaction, failure and security.

Chapters 3–7: Networking and Internetworking; Interprocess Communication; Remote Invocation; Indirect Communication; Operating System Support

These foundational chapters cover networks relevant to distributed systems (types of network, network principles, Internet protocols, and Ethernet, WiFi and Bluetooth as case studies), then the API for Internet protocols, data marshalling, multicast, overlay networks and MPI. Remote invocation covers request-reply protocols, remote procedure call and Java RMI. Chapter 6 on indirect communication, new in this edition, covers group communication, publish-subscribe, message queues and shared memory approaches, and Chapter 7 treats the operating system layer, protection, processes and threads, and virtualization at the operating system level.

Chapters 8–10: Distributed Objects and Components; Web Services; Peer-to-Peer Systems

The middleware chapters examine different ways of supporting distributed applications. Chapter 8 moves from distributed objects (with CORBA as a case study) to components (Enterprise JavaBeans and Fractal). Chapter 9 covers web services, their descriptions and directory services, XML security, coordination and applications. Chapter 10 covers peer-to-peer systems, from Napster to middleware, routing overlays (Pastry, Tapestry) and application case studies (Squirrel, OceanStore, Ivy).

Chapters 11–13: Security; Distributed File Systems; Name Services

Chapter 11 presents security techniques, cryptographic algorithms, digital signatures and cryptography pragmatics, with Needham–Schroeder, Kerberos, TLS and 802.11 WiFi as case studies. Chapter 12 describes the file service architecture with Sun NFS and the Andrew File System as case studies, and Chapter 13 covers name services, DNS and directory services, with the Global Name Service and X.500 as case studies.

Chapters 14–15: Time and Global States; Coordination and Agreement

These are the book's chapters on timing and coordination algorithms: synchronizing physical clocks, logical time, global states and distributed debugging, then distributed mutual exclusion, elections, coordination and agreement in group communication, and consensus.

Chapters 16–18: Transactions and Concurrency Control; Distributed Transactions; Replication

The data-related chapters move from transactions, nested transactions, locks, optimistic concurrency control and timestamp ordering, to distributed transactions (atomic commit, distributed deadlocks, recovery), and replication (fault-tolerant services, the gossip architecture, Bayou and Coda, and transactions with replicated data).

Chapters 19–20: Mobile and Ubiquitous Computing; Distributed Multimedia Systems

Chapter 19 covers association, interoperation, sensing and context-awareness, security and privacy, adaptation, and Cooltown as a case study. Chapter 20 covers the characteristics of multimedia data, quality of service and resource management, stream adaptation, and the Tiger, BitTorrent and End System Multicast case studies.

Chapter 21: Designing Distributed Systems: Google Case Study

The final chapter is a substantial case study of the Google infrastructure: its overall architecture and design philosophy, communication paradigms, data storage and coordination services, and distributed computation services. The preface presents it as showing how the book's architectural concepts, algorithms and technologies come together in one design.

Key Concepts

Chapters 1–7: Foundations

• Challenges and models: scalability, heterogeneity, security and failure handling, captured in physical, architectural and fundamental models.
• Remote invocation and indirect communication: request-reply, RPC and RMI, and group communication, publish-subscribe and message queues.

Chapters 8–13: Middleware and Services

• Distributed objects and components, web services, peer-to-peer: three approaches to supporting distributed applications.
• Security, file service and naming: cryptography and authentication protocols, NFS and AFS, and DNS and directory services.

Chapters 14–18: Algorithms and Data

• Logical time and global states: ordering events without a shared clock.
• Coordination and agreement: mutual exclusion, elections and consensus.
• Transactions and replication: concurrency control, atomic commit and fault-tolerant replicated services.

Chapters 19–21: Emerging Areas and the Google Case

• Mobile and ubiquitous computing and multimedia: context-awareness, quality of service and stream adaptation.
• Google infrastructure: an end-to-end application of the book's ideas.

Critical Analysis

Strengths

• Breadth with case studies. Many chapters pair concepts with named real systems: Java RMI, CORBA, Enterprise JavaBeans, Pastry, OceanStore, NFS, AFS, Kerberos, Bayou and Coda, and others, and the final chapter shows how many ideas combine in the Google infrastructure.
• Algorithms get their own chapters. Time, coordination and agreement, transactions and replication each have chapters of their own, so the algorithmic core is separate from the systems descriptions.
• Clear route through the material. The preface groups the chapters into seven topic areas, with a diagram of the book's structure and suggested navigation, and points out that Chapter 6 covers a lot of material from which teachers may choose a few techniques.
• Teaching support. The authors' site has presentation points for each chapter, slides, lab projects, source code for programs in the book and supplementary material, while solutions to the exercises are reserved for teachers.

Limitations

• Very large. Twenty-one chapters and a wide range of middleware and application topics cannot all be covered in one course, so instructors and self-study readers must choose.
• Dates from 2011. The edition predates later developments in the field, and the technologies in the web services, distributed objects and Google chapters reflect the state of practice at the time of writing.
• Moved-out material. Two chapters of the fourth edition (a CORBA case study and distributed shared memory) are no longer in the book and are only available from the authors' site.
• Forward references. The preface warns that some topics need a forward reference; for example the XML security material in Chapter 9 makes better sense after the sections of Chapter 11 it refers to.

Where It Fits in the Course

Coulouris and colleagues is the broad, case-study-rich textbook for a distributed systems course. Van Steen and Tanenbaum's Distributed Systems covers architectures, processes, communication, naming, coordination, consistency, fault tolerance and security in a principles-first organization and is a more recent edition (2023, with a free copy on the author's site); the two can serve as alternatives, with this book giving more room to middleware, security and worked case studies. Vitillo's Understanding Distributed Systems is a concise introduction aimed at developers and can come first, and Kleppmann and Riccomini's Designing Data-Intensive Applications treats replication, partitioning and data-system trade-offs from a practical angle that complements Chapters 16 to 18.

Cachin, Guerraoui and Rodrigues's Introduction to Reliable and Secure Distributed Programming is a graduate text that specifies broadcast and consensus abstractions precisely, and is the natural next step after Chapters 14 and 15. Pacheco's An Introduction to Parallel Programming is the companion for readers whose interest is in programming parallel machines and clusters, which this book touches mainly through MPI.

How to Use This Book

The authors write for undergraduate and introductory postgraduate courses and for self-study. They assume basic knowledge of object-oriented programming, operating systems and elementary computer architecture; algorithms are given in Java or ANSI C and in pseudo-code derived from them.

A practical plan:

• Core: Chapters 1 and 2 first, then Chapters 4 and 5 and selected parts of Chapter 6, followed by Chapters 14 and 15 and Chapters 16 to 18 for algorithms and data.
• Read as needed: Chapter 3 if networking is unfamiliar; Chapter 7 for operating system support; Chapters 8 to 10 according to interest in middleware, web services or peer-to-peer systems; Chapters 11 to 13 for security, file systems and naming.
• Optional: Chapters 19 and 20 for mobile, ubiquitous and multimedia systems.
• Capstone: Chapter 21, once the concepts are familiar, to see them together in the Google infrastructure.
• Practice: use the lab projects and source code on the authors' site, and the exercises in the book.