BOOK REVIEW: Parallel Logic Programming by Akikazu Takeuchi

This book describes the author's work as a member of the Fifth Generation Computing Systems Project. The subject matter is the extension of logic programming by fine-grain parallelism, and the resulting languages and programming techniques. It is not a general survey but a collection of papers revised and repackaged from the author's doctoral thesis. The book begins with a concise review of the basics of mathematical logic and Prolog programming. This treatment is brief and would not serve as a tutorial introduction. AND-parallel logic programming, is then introduced. Parallel logic programming replaces the procedural reading of a logic program with a 'process reading'. A program is viewed as defining a set of concurrent processes which communicate using logical variables. Each process is defined by a set of clauses, and looks similar to a procedure in conventional Prolog. When a process is invoked, a clause is selected and then new processes are forked to execute all the terms in the body of that clause in parallel. Unlike Prolog, which may select several different clauses in turn using a backtracking search, ANDparallel programming commits to a particular clause when a process is invoked. This commitment can be controlled by the pattern of unifications in the clause head, or by guards in the clause body. If no clauses can be selected a process is suspended until a choice can be made. The second part of the book goes on to describe several programming techniques used in parallel logic languages. These include various types of stream communication, using partial data structures to pass requests and responses between processes. Perpetual processes can be used to model objects and streams used to carry messages between them, resulting in an Actor-like concurrent object-oriented framework. This can include delegation and simple constraints upon objects' properties. Several Concurrent Prolog examples, including a simple window manager, are used to explain these techniques and the reviewer found this the most interesting part of the book. The third part extends existing algorithmic debugging techniques to handle parallel programs. The main innovation is the addition of a 'suspension set' to describe processes which are expected to block. The final part describes a new language called ANDOR-II which reintroduce the non determinism of Prolog's backtracking search. The book is generally easy to read. Program fragments and mathematical examples are used liberally and are well supported by narrative text. Although the author is not a native English speaker and the proof-reading is weak in places, this does not overly distract from the presentation of the subject matter. The first ha l f of "Parallel Logic Programming" will provide an introduction to parallel logic languages for readers with a knowledge of logic programming. However, it will be of most interest to active researchers in the field as a good summary of the author's work. James Noble (kjx@comp.vuw.ac.nz)