Browse Books

Reviewer: James Russell McGraw

Hermes is a language developed by the authors for distributed computing. The features that distinguish Hermes include typestate checking, exception handling clauses, runtime binding of all names, and dynamic definition of processes and message channels. This tutorial and reference manual for Hermes includes numerous well-developed programming examples to convey the meaning of the language to readers. The authors feel that the book is well suited to a broad spectrum of computer scientists, including teachers and system designers and developers. A clear strength backing this book is the existence of a Hermes compiler for several Sun and IBM systems, which can be acquired from the authors. The tutorial section of this book (the first 90 pages) gives a smooth introduction to the Hermes language through a combination of examples and discussion of the guiding principles used in its design. The authors assume readers already have a working knowledge of conventional languages, which makes it easier to get to the key points of this language. The most important language principle seems to be the protection of each process from all others (including other users) via compiler understanding of all potential actions of each process. The authors are so confident of this protection that they do not use separate address spaces for different users. As a result, the Hermes language has well-defined process interfaces and a clear, simple semantics. The typestate checking goes beyond normal type checking in most languages to include concepts like uninitialized variables and other user-defined properties. This level of compile-time checking and the associated exception handling system provide most of the critical security for each process. One aspect of this tutorial that I particularly like is the use of a full chapter to develop a large example—that of a window manager. The tutorial made it easy for me to get a reasonable feel for this language. The reference manual section (180 pages) contains the standard type of precise information on the definition of Hermes. It includes syntax, naming, operations, typing and typesets, and an operational semantics. This part is also easily readable and appears to cover all of the important ideas. As with most reference manuals, the content is somewhat dry. The important point for any reference manual, however, is the ease with which you can find the answers to your questions. This reference section is better than average. My one major disappointment relates to things I would have liked to see in the book. The book contains no overview of the concepts of distributed computing (particularly as distinguished from parallel computing). It does not even reference any good texts on the subject. As a result, I was unsure what realm of applications was intended (for instance, signal processing, scientific computing, or finance). The features seemed insufficient for writing a distributed operating system, but I may be wrong on this point. My perception is that different application domains need different levels of support for efficient execution. Determining how efficient this approach could be was difficult in this case. The lack of initial discussion of distributed computing also means that this text would require supporting material in a classroom situation. I was generally pleased by the writing style and organization. The level of presentation seemed good for students trying to grasp and appreciate a new language. System designers and developers may find the pace a little slow. They may prefer to read some of the technical papers by the authors. On the other hand, most of the important language information is consolidated in this one text. I definitely like the frequent summary paragraphs and the clear writing style. My one criticism is of the list of references. Previous work of the authors makes up more than 40 percent of the references. They have omitted much valuable material. My guess is that this oversight was based on trying to merge information from several of their earlier papers. This book brings together some interesting language ideas for distributed computing and presents them in a cohesive fashion. These ideas have substantial merit for distributed computing, and I found this book an easy vehicle for learning the ideas. Unfortunately, I did not have the time to acquire the software to check it out, but given that the authors are from the IBM T. J. Watson Research Center, I would give them the benefit of the doubt. Probably the best context in which I can recommend this book would be for a class on distributed computing, as a support text for expressing ideas and testing them on a machine.