This book presents a broad overview of parallel programming with a strong emphasis on programming languages and the various methods they provide. It is intended as a text for an advanced undergraduate course. Students can learn about parallel programming outside of the traditional context of operating systems. The intial portion of the book introduces background material on the general development of hardware and software technology. This is followed by a basic description of the key approaches to parallelism, including mutual exclusion, process synchronization, and message passing. The remainder (and overwhelming majority) of the book is devoted to 20-page overviews of different parallel languages. In the category of asynchronous languages, the author covers Modula-2, Pascal Plus, Ada, and Occam. Under synchronous programming, he covers CFT FORTRAN, CDC Cyber FORTRAN, Illiac IV CFD FORTRAN, DAP FORTRAN, and Actus. The first two illustrate optimizing compiler approaches to parallelism, the next two demonstrate machine-specific language changes, and the last one (the author’s own variant of FORTRAN) describes a more high-level set of language primitives. The book concludes with an overview of data flow programming and highlights the VAL language.

Overall, the book presents a clear and balanced view of parallel programming. In the early portion on key approaches, the author develops each of the options in a sound manner and compares them by solving the same set of problems in each one. The language descriptions heavily emphasize the mechanisms for providing parallelism and process interaction. The only diversions tend to be on mechanisms a language might provide for data abstraction. I felt the language descriptions were quite objective--with three notable exceptions. The author shows a clear bias aganst FORTRAN optimizing compilers schemes (CFT and CDC FORTRAN) and a bias toward his own language. The latter is understandable. However, in the former the author avoids discussing some of the most advanced FORTRAN optimization work (e.g., Kuck and Kennedy) by only discussing some existing production systems. Readers could be left with some unfairly pessimistic views.

I found the presentation and writing style of the book to be entirely acceptable. The author does his best to develop each of the language sections in the same manner. None of the example programs are very long, but they convey the critical points. There is some degree of repetition between the sections on key approaches and the early language descriptions, but that may be useful for an undergraduate text. The index and references (except for the glaring omissions of Kuck and Kennedy) appear to be satisfactory. Each chapter has questions for readers; most of them are the common parallel programming problems used by everyone else in this area--for example, readers/writers, dining philosphers, and matrix arithmetic.

In my mind, the ultimate value of this book as an undergraduate text critically depends on the teaching style of the instructor. The book primarily contains ten examples of parallel programming languages that use a spectrum of different approaches. At least in several cases, certain pairs of languages do not differ all that much, but overall they do cover a dramatic range of options. An instructor who likes to teach by example should find this text fits her or his style well. An instructor who likes to emphasize concepts first and not focus on specific language implementations may find the points he or she wants to make deeply embedded in a particular language description or, worse, spread across several different languages and left for the reader to infer. Even so, I find this book makes a positive contribution by covering the topic of parallel programming as a subject in its own right--independent of operating systems. Given the direction of parallel computing, I believe this is a good idea.