The audience for this textbook is upper-level undergraduates who wish to learn parallel programming. A suggested syllabus is provided, but no specific prerequisites are stated. The authors suggest using the book in an undergraduate or graduate workshop environment. The book includes nine chapters. Each chapter except the first has exercises, most of which require programming. The language of discourse is C-Linda, and an appendix serves as a language reference. A short bibliography is included.

Chapter 1 introduces the “what,” “why,” and “how” of parallelism. The fundamental notion presented is that parallelism is one way to solve problems fast, and that sequential programming is a restricted version of parallel programming. Parallel programming is considered the norm, and sequential programming is the exception.

Chapter 2 discusses basic paradigms for network coordination, including result parallelism, agenda parallelism, and specialist parallelism. The analogy of building a house serves nicely to introduce these notions. Guidance is given about when to use the various models. The authors briefly discuss some of the other parallel programming methods and implementations, such as communicating sequential processes (CSP), remote procedure call (RPC), monitors, and other synchronization techniques. They make clear that the book will deal primarily with parallel programming  techniques. 

Chapter 3 introduces the basic data structures: semaphores, bugs, name-accessed structures (such as records), and position-accessed structures (such as arrays). Live data structures and message passing are also discussed. Linda is introduced as a model of coordination for executing multiple threads.

Chapter 4 focuses on debugging and performance measurement. Problems such as deadlock and non-determinism are introduced. The discussion of performance considerations includes load balancing and starvation. The chapter briefly discusses modeling of parallel programs.

Chapter 5 synthesizes the previous chapters to treat an example problem (finding all primes between 1 and n) using the three paradigms introduced in chapter 2. Examples are given in C-Linda (a version of C enhanced with language support for the Linda model).

Chapters 6, 7, and 8 investigate three programs that are naturally agenda-parallel, result-parallel, and specialist-parallel, respectively. The problems are database search with a complex search criterion, wavefront computation of a matrix, and data-stream analysis. In each case, analysis of the problem and an initial solution eventually result in an efficient agenda-parallel solution.

Chapter 9 introduces the dining philosophers and readers-writers problems. The main example of the chapter is a “meeting maker” (calendar management) example.

The book is nicely written and would be suitable for a seminar. A student with no background in parallel programming would have to do a lot of outside reading to be adequately prepared and to appreciate some of the problems. The programming examples are interesting and well thought out. The book lacks sufficient depth for a graduate-level course. I recommend it for an upper-level undergraduate seminar course, provided the supporting tools were available.