Browse Books

Reviewer: Teodor Rus

The algebraic theory of processes is a hot topic in computer science. This area of research is full of traps, however, because few researchers develop a formal concept of a process before developing an algebraic theory of processes. Apparently this does not matter too much as long as a process is whatever everybody feels fits his or her theory of processes. Indeed, the informal concept of a process encompasses such a generality that allows everything that is provided with a certain type of behavior to be seen as a process. The theory of processes (algebraic or not) matters, however, when one tries to use it to model the process of an actual behavior, such as the process management system of an operating system. The intuitive term “process” (as defined in a Webster dictionary) denotes a pair consisting of an “agent” and an “expression,” where the agent is implicitly provided and performs the actions explicitly specified by the expression. The expression in this definition seems to be a “well formed word” in terms of the actions performed by the implicit process. Notice that only when paired do the agent and its computing task as specified by the expression define a process. The binding time of the agent to its computing task expression, while defining a process, determines the state of that process. If the agent is not bound to the expression, this does not mean that the agent is missing but rather that the process is not active. Perhaps due to the implicit presence of the agent in the intuitive definition of the process that it carries out, most of the process theories developed in computer science forget either the agent or the expression. This leads to a theory of processes which resembles some specific field of activity which is designed by the rules of handling expressions (when the agent is forgotten), or by the rules of handling agent (i.e., automaton) behavior (when the expression is forgotten). Probably the reason the theory of processes is so hot in computer science is that the concept of a process is successfully used in the operating system design and implementation. The operating system, however, operates with a rather specific concept of a process defined as the “program execution by a processor.” As originally introduced by Dennis and Van Horn [1], this concept is modeled algebraically by “an abstraction that demands and releases resources while it carries out a computation task.” This book “presents a semantic theory of communicating processes and a logical proof system for reasoning about them.” It starts by considering the following concept of a process as its object of study: “We consider a process to be a machine for performing actions in some prescribed manner.” Never again is the author more specific about the concept of a process studied in the book. Actually, the book develops a language for describing the behavior of a process of word derivation with a rewriting system using well-defined operations of “stitching trees” called the “Example Process Language, EPL.” Thus, the book does not use the type of rewriting rules provided by the derivation relation defined by formal grammars. Instead, an algebraic language process trace derivation is developed [2]. A good review of the contents of this book is presented in its Outlook section (pp. 13–15). Therefore, I would rather try to signal to the reader those parts which I found really useful as well as those parts which I found really useless. The splitting of the book into three parts was logically determined by the algebraic approach followed by the author. Part 1 of the book is dedicated to the study of finite processes. As the author notes on the bottom of page 13, the EPL studied in this part is “nothing more than a word algebra over a [finite] set of combinators,” that is, a finite signature. Chapter 1, “Algebras,” provides a very useful treatment of some algebraic concepts, which are too often used in computer science and not too often explained in the context of the computer science where they are used. I like to believe that this chapter is best read with its goal in mind. However, had the author succeeded in relating the concept of “full abstraction” (often used in algebraic semantics) to those of “congruence relation” and “free generation of an algebra,” he would have helped to avoid much confusion. Chapter 2, “Testing Processes,” is dedicated to the development of a behavioral theory of processes called “testing equivalence.” The flavor of a process as the “process of program execution” is very obvious here and the techniques developed for testing equivalence are similar to those usually taken in the design of operating systems. As a matter of fact, the concept of an “experimental system” developed in this part could provide a good algebraic model of the operating system of a real computer. The author uses the process trace model and a tree algebra in order to develop the relations of process equivalence. The second part of the book, “Recursive Processes,” is dedicated to an extension of the EPL discussed in Part 1 to support infinite processes. This is done by allowing recursion as a combinator (or an operation scheme) in the signature of the algebra of processes (studied in this part), and allowing the natural and structural induction as proof mechanisms. The algebraic model of recursive processes is provided by continuous algebras, algebras whose carriers are partial orders that satisfy certain continuity constraints. Chapter 3, “Continuous Algebras,” provides an excellent treatment of the concept of continuous algebra. Chapter 4, “Recursive Processes,” is the most elaborate in the book and provides the theory of recursive processes using the language of continuous algebras. The third part of the book, “Communicating Processes,” is dedicated to the study of the EPL language provided with process communication primitives. The material discussed in this part is concentrated in just one chapter, called “Communicating Processes.” The only model of communicating processes discussed is that provided by message passing over communication channels. Each chapter of the book ends with more or less complicated exercises meant to illustrate the material discussed in that chapter, and the book concludes with a historical note that traces the development of the concepts discussed in the book.