Browse Books

Reviewer: James Russell McGraw

As indicated in the preface, this volume is a sequel to an earlier book entitled Object-oriented concurrent programming [1]. The current volume examines a style of object-oriented concurrent programming. It is a collection of tutorial and research papers that focus on a particular model and style of programming shared by all the authors, who are associated with the ABCL (An object-Based Concurrent Language) project. The editor indicates that the papers were “revised extensively” for this book. The book contains 11 chapters and an extensive appendix. These chapters cover a wide range of topics and need not be read in sequence to understand all of the material. The book is relatively self-contained; the reader need not have a background in parallel computing or object-oriented programming to understand most of the material. On the other hand, the book is not intended as a tutorial on either topic. Chapters 1 and 2 give a basic overview of the ABCL project, including its computing model and language definition. Objects are independent entities that execute in response to messages. The rules governing the creation, activation, and execution of objects seem robust and powerful. Messages come in three varieties: no reply required, reply required before the sender restarts, and reply required but the sender can restart before receiving it. The definitions of these options are complex, but they give some interesting dimensions of expressive power. Several short examples illustrate the variety of options available. Chapters 3 through 5 emphasize different theoretical aspects of the project. Chapter 3 jumps quickly into the rather esoteric subject of reflective computing. The basic idea is to permit objects to “understand” the states of other objects and alter their definitions on the fly during execution. To permit this activity, the original language definition is restricted in some ways and extended in others. Chapter 4 launches into the topic of developing transformation rules and verifying that such transformations are correct. For this purpose, the original language definition is again restricted, but in a slightly different way. The proof technique is based on the partial ordering of message transmission and receipt times. The examples given appear correct, but some of the more complex transformation rules are not clearly stated and their proofs do not seem to follow directly from the rules given. Chapter 5 is a continuation of this work. Chapters 6 through 8 focus on understanding and using the language. Chapter 6 examines the issue of sharing knowledge among objects, particularly in distributed systems. Four sharing schemes are described, compared, and contrasted—inheritance, delegation, copy, and recipe-query. An awareness of both the Smalltalk and Actor styles of knowledge sharing would be valuable in reading this chapter. Chapter 7 highlights some debugging techniques. In debug mode the system records the local history for each object, that is, the sequence of messages to which the object responds. Various tools permit the examination of these data. Chapter 8 gives an overview of an implementation of ABCL in a distributed environment. This chapter introduces yet another version of the language and only gives a high-level view of the implementation; it contains no performance data. Chapters 9 to 11 analyze different kinds of applications written in the language—a discrete event simulation (chapter 9), an operating systems kernel (chapter 10), and a parallel parser for context-free grammars (chapter 11). All three chapters focus on how the definition of the problem is transformed into the representation of the solution using objects and the various message passing forms. The authors do some performance analysis, but it is mostly algorithm complexity analysis. Overall, this book is weak. It needs far more work to merge the various source papers cleanly. The book contains five different variations on the same language, none of which is developed very far. Too many of the chapters reintroduce the basic definitions and descriptions of objects and messages. In some cases, one chapter references a paper that turns out to be a previous chapter in the book. I do like the basic language definition, and the various message passing forms have considerable expressive power. The one serious omission in the content is performance measurement. The book includes no examples comparing the solution of a problem using this language and implementation against any other implementation. I have no idea how fast or slow this system is. The authors give no clues about this matter, even though they mention the desire for efficiency in several places. The presentation style and format are quite good. The English is almost always clear and accurate. The organization of the chapters is somewhat arbitrary in that they do not usually build on one another, but the overview points this out. The references, index, figures, illustrations, and examples meet the needs of the book. I can best recommend this book for someone who wants a detailed understanding of the status of the ABCL project. It brings together key research papers from this project for easy reference. I would not recommend it as a basic text for a graduate class. The book has no clear flow or development of ideas. It could serve as supporting material in an advanced topics course, but it is so broad that I would suggest using the original papers instead. When I began reading the book, I had high hopes for an interesting learning experience. Sadly, I was quite disappointed.