Browse Books

Reviewer: John L. Bennett

Peridot is a new experimental tool for creating visual user interfaces without programming. The interface designer draws the screen that the user will see, performs sample user actions, and gives examples of typical values. Peridot infers how the constructed parts will interact, checks these inferences with the designer to be sure they are valid, and produces parametrized procedures that can be called from application programs. The program is implemented in Interlisp-D on a Xerox 1109, and Myers has used it to duplicate many of the interaction techniques found in the Macintosh Toolbox. The work, as documented in this outstanding book, makes major research contributions to the evolving area of user interface management systems (UIMSs). Though based on doctoral work done over several years at the University of Toronto, this book provides depth of insight, quality of design, and explanatory value far beyond what you might expect to find in a typical thesis. Peridot integrates techniques of visual programming, programming by example, constraints, and plausible inference in a masterful demonstration of skilled design tradeoffs. The book will be useful to a wide variety of people. The cross-references throughout the book and the detailed index will be helpful to both casual and intensive readers, and the comprehensive illustrations provide an essential visual perspective. As a reviewer I have prior familiarity with UIMS work, but I have not constructed a UIMS. Thus, I can interpret and appreciate the contribution of the work, but I cannot provide a point-by-point critique of details. One of the merits of this book is that Myers himself is refreshingly candid and thorough throughout the book in stating explicitly the limits of what he has accomplished and in making cogent suggestions for extensions needed. Chapter 1 provides a valuable and well-written tutorial by defining terms, outlining the motivation for a UIMS, listing problems with existing UIMS designs, and setting out the goals and design principles for Peridot. The specific contributions of the Peridot work are listed here (and repeated in chapter 15 as a conclusion). Chapter 2 gives a 23-page, critical, in-depth review of related work and indicates the specific problems addressed by Peridot. These two chapters alone will be worth the price of the book to a reader who wants to gain a compact, insightful, and comprehensive review of the field with pointers to sources for more detail. Chapter 3 provides an overview of the scope of Peridot through the use of an extended example. Chapters 4 through 9, written in an easy-to-read modular form, discuss the authors accomplishments in addressing a range of difficult problems: :9BEstablishing graphical constraints between objects (e.g., string centering within a rectangle even though the rectangle changes shape) and simple though effective inferencing (to guess what these constraints should be), Visual editing of graphic objects (e.g., erasing, copying, and changing dependencies), Specifying iterations (e.g., formatting menu items after the first two in a list have been laid out on the screen), Using conditionals (e.g., to control visibility or shading of constructed objects when they are shown on the screen to users), Using active values as an efficient, easy-to-understand way of controlling displayed objects at run time (e.g., object position can be set by the mouse or by an application procedure), and Handling the mouse (e.g., design decisions that allow the mouse interactions to be programmed by demonstration). Only the mouse, a clock, and a custom-built slider box are currently supported as input devices at run time. Myers indicates in chapter 10 how other input devices could be integrated to allow additional multiple, concurrent user-device interactions. After the interface is designed, the system can write out procedures to be called by an Interlisp application at run time. As chapter 11 points out, some environment-specific constraints are present, and an extension to Peridot is needed in order to read procedures back in for further editing. Such a detail would be of most interest to Interlisp users, but the author, as he does throughout the book, states the problem in such a way that the issues become general for the implementer of a UIMS in other environments. The closing chapters compare the Peridot results in visual programming and example-based programming with the challenges outlined in chapter 2, describing future work that could extend the Peridot ideas. Myers makes important points about the value of iterative design techniques that include the user as part of the design cycle. In one informal experiment he compared the time it took him and a novice Peridot user to construct example menus with the time it took others using tools familiar to them. What took Myers and the novice 4 and 15 minutes, respectively, took five expert programmers from 11-2- to 8 hours to accomplish. While Myers recognizes that these results are hardly conclusive, he is justified in citing them as evidence of the productivity gains that may be available with the use of the techniques embodied in Peridot. In another small test, five experienced programmers and five nonprogrammers who had some computer experience used the system for about 11-2- hours one-on-one with Myers so that he could guide the learning process (no users manual or online help is available). This helped him to understand what it would be like for other people to construct simple menus of their own design with the system. I applaud Myerss reports of empirical testing and his acknowledgment of the design refinements he made to the Peridot user interface as a result of this experience. But the after-the-fact small trials were done too late to have any real influence on the design—a situation all too common in computer science practice. This reader wonders, however, if Myers might not have had some major design insights if he had involved users as an essential part of the design process rather than as an apparent afterthought. Tools such as Peridot that are now becoming available make such user-in-the-loop design procedures increasingly feasible in computer science. I recommend this as a milestone book by a knowledgeable author in a field important for rapid evolution toward more usable computer applications.