Parallel logic languages have emerged recently as one of the most promising approaches to high-level programming on asynchronous parallel architectures. Much of the low-level detail, such as the use of monitors or rendezvous (which with other languages is seen as lying at the center of parallel programming), is done away with in the logic programming paradigm. The problem that parallel logic programmers have faced is in convincing the rest of the parallel programming world that their approach is more than a curiosity, and is applicable to a wide range of problems extending well beyond the artificial intelligence field from which logic programming arose. A stated aim of this book is to promote parallel logic programming to the wider world. In this aim it is unsuccessful, but in many other ways it is an excellent book.

The heart of the book is the presentation of programs written in parallel logic languages for a dozen or so problems. Most of the problems are tackled in a variety of ways, making the book as a whole a fairly massive compendium of parallel logic programs. The programs are impressive in their conciseness and elegance, but someone who is not already familiar with the parallel logic programming languages would be overwhelmed by the sheer amount of material. As someone who has been programming in these languages for some years, I was pleased to see many of the techniques that I have used codified and demonstrated, but I found understanding the programs hard (though rewarding) work. A novice programmer in parallel logic programming languages would probably do better to start with a simpler tutorial introduction and to turn to this book after gaining familiarity with them.

Part of the problem is the terseness of the programs given. Frequent use is made of one- or two-letter variable names, and the predicate names used are not always meaningful either. A greater use of illustrations, demonstrations of the process structure built up during execution, and a slower lead into the more complex examples would have made the book more tutorial, but it would have left room for a smaller number of examples to be covered.

I also found the way the book flips between two different logic programming languages confusing. The languages concerned illustrate the division that has grown in the parallel logic programming community between the OR-parallel languages, which stay close to the original aim of being “parallel Prologs,” and the stream-AND-parallel languages, which discard many aspects of Prolog in order to efficiently exploit parallel architectures. Although the two languages differ greatly in their operational behavior, their syntax is similar, and in the examples given in the book it is often difficult to tell at a glance which language is under discussion.

The best part of the book is its handling of the actual parallelism in the programs. Previous works on these languages have tended to skate over this subject on the assumption that writing a program in a parallel language is sufficient to gain parallel performance. In fact, parallelism is restricted by data dependencies, and this book is careful to point out exactly where the potential for real parallelism occurs. The author also covers those cases where so much parallelism is available that it becomes unmanageable (this can occur when the parallelism is speculative), and some form of scheduling is required to manage it. The author provides speedup figures obtained on real parallel machines for all the programs, though the figures are given only for shared-memory machines, so the additional problem of communication time in distributed memory machines is not properly covered.

Although a large number of examples are covered, the range of the examples is limited, concentrating particularly on search problems. Therefore, the process view of stream-AND-parallel languages is not covered in great detail. This seems to stem from the standard approach the book uses to solve problems: starting with a solution in the OR-parallel language (which is particularly suited to search problems), and seeing how it can be adapted to the AND-parallel language. Unfortunately, this gives a rather restricted view of the power of the AND-parallel languages, since recent work on these languages has tended to shift away from seeing them as parallel versions of Prolog with its built-in search techniques, and toward seeing them as languages for expressing communicating concurrent processes. Other advanced programming techniques, such as the use of meta-interpreters, are also omitted.

As this book illustrates, parallel logic languages offer a powerful new tool to those wrestling with parallel architectures. Parallelism is not just an added feature of these languages, it is an integral part of them: learning to program in them is learning to program in parallel. This book is a first step in pulling these languages out of the research laboratories and into the real world, and given the paucity of material in book form on these languages, it is to be welcomed. As the book illustrates, however, programming in parallel logic languages is still at an experimental stage, and some time may pass before it has settled down to the point where the definitive primer can be written.