Browse Books

Reviewer: Wei-Ming Hu

Some of the key algorithms for reliable broadcast, synchronized access to data, and achieving consensus are covered in this textbook, on abstractions and algorithms for building distributed systems. The book begins by describing how to model fundamental concepts such as processes, failures, communications, time, and the perfect failure detector abstraction. This is followed by a discussion of the first class of algorithms: reliable broadcast. The book starts with the simple best-effort broadcast, and successively adds reliability, uniformity, and, eventually, causal broadcast. Both deterministic and probabilistic algorithms are described. From here, the book moves on to distributed shared memory. This chapter describes how one or more processes can write a value that is then read by one or more other processes. The initial algorithm implements single writer/multiple reader, and then successively adds atomicity, multiple writers, and recovery. The next major topic is distributed algorithms for achieving consensus, namely, agreeing on a common value. Starting with a basic flooding algorithm, the chapter explains how to achieve uniform agreement, abortable consensus, and variants that use logging and randomized algorithms. The last chapter of the book describes variants of consensus abstractions, such as total order broadcast, terminating reliable broadcast, group membership, and view synchronous communications. To supplement the algorithms in the book, each chapter contains a hands-on section that presents some exercises that can be solved and executed using the Java-based, open source Appia protocol framework. Those interested in the details of how these algorithms are implemented should definitely go through these hands-on sections. In addition, every chapter also ends with a historical notes section that describes the history and origin of these ideas and algorithms. The book is well organized. It incrementally introduces the key concepts and simple algorithms, and then builds on them to achieve various properties such as reliability and atomicity. This structure gives a good picture of how these various algorithms relate. The book does a good job of describing the core algorithms at a high level. I appreciated the historical notes, because they help place the various papers that one may have read in a larger context. The book, however, does not address how well these algorithms fare in practice. For example, fault detectors are imperfect, and that usually forces certain tradeoffs that affect where these algorithms can be employed. Likewise, a more complete failure model, and a description of how these algorithms behave, would also be helpful. Overall, the book succeeds in providing a good introduction to this important area. Online Computing Reviews Service

Reviewer: Burkhard Englert

Developing correct distributed programs remains one of the most challenging problems software developers face. In this book, Guerraoui and Rodrigues successfully discuss and illustrate these difficulties. The book offers an introductory description of several common distributed programming abstractions as well as the algorithms that are used to implement these abstractions. These programming abstractions encapsulate the difficulties of robust cooperation between several processes and all of the challenging algorithmic issues and functions (as an intermediate layer between the network communication and the distributed application layers). As a result, this book will interest both distributed application programmers, who are provided with a library of abstraction interface specifications, and distributed system builders, who are provided with a library of algorithms that implement the given abstractions. A companion set of examples implemented in Java and running in the Appia protocol composition framework is included with the book. Appia is an open-source layered communication toolkit. It consists of a core, that is used to compose protocols, and a set of protocols, that provide group communication, ordering guaranties, atomic broadcast, and other properties. Being open source, it is easily accessible to any interested reader. The examples presented allow readers to experience first hand some of the implementation details that are not obviously comprehended from the algorithms presented in the text. In the first chapter, the authors present several applications that depend on distributed programming abstractions. These applications are not discussed in detail, but are pertinent to later chapters of the book. This is a very helpful chapter for anyone who wants to use the book as a teaching tool. It provides good examples that can be used in cooperation with the material covered in a course on distributed algorithms. More experienced users, namely application programmers or system builders, may choose to skip this introduction. The second chapter discusses the distributed system models that are used throughout the book. Within the context of the book, this means a description of process and link abstractions, on which all other abstractions are built. Chapter 3 presents the reliable broadcast abstraction. Chapter 4 discusses the shared memory abstraction, and chapter 5 discusses the consensus abstraction. Finally, chapter 6 presents some variants of consensus, particularly atomic broadcast, terminating (reliable) broadcast, (nonblocking) atomic commitment, group membership, and view-synchronous communication. Each chapter that discusses programming abstractions proceeds in a similar manner. Algorithms that implement a given abstraction are first presented for a simplified model. Then, they are adapted for more realistic models. This gives the reader some insight into how modeling assumptions affect the algorithm design. The chapters end with a hands-on section where readers are encouraged to implement the presented abstractions using the Appia framework. Some readers may find the book disappointing in regard to its apparent lack of rigor. There are no formal correctness proofs, only more informal correctness arguments. Any reader not satisfied will be able to supply these proofs using other resources. There are no theorems in the book. This allows the authors to focus entirely on the design of the algorithms. The strengths of this book lie in the connections made between distributed algorithms and actual implementations. This demonstrates the practicalities of these algorithms to the user. However, one should not assume that this book is a distributed programming manual. The organization of this book directly reflects the subject it discusses. As distributed algorithm abstractions are sandwiched between application and network layers, this book is sandwiched between formal textbooks on distributed algorithms and distributed programming manuals. Overall, the book fulfills an important practical need, which is teaching students how distributed algorithms are actually used. At the same time, a focus on the development of correct algorithms is maintained. The exercises at the end of each chapter also reflect this philosophy. They are not programming exercises. Almost all of the exercises relate to some aspect of the algorithms previously presented. This does not mean, however, that the implementations are simply filler. Particularly in a teaching environment, implementations are incredibly useful tools that facilitate learning. This book will open doors for students who might otherwise shy away from the area of distributed algorithms because of the perceived difficulty and abstractness of the subject. The hands-on approach will allow students to gain a better understanding of the underlying concepts. In this sense, I highly recommend this book to anyone thinking about teaching a more applied course in distributed algorithms. It may also prove useful to those wanting first-hand experience with algorithms in distributed computing. Online Computing Reviews Service