Browse Books

Reviewer: Charles Thacker

Oberon is a computing environment for a single-user workstation, designed and implemented at the Swiss Federal Institute of Technology (ETH) in Zurich by N. Wirth and J. Gutknecht. The Oberon system [1] is a user's guide and high-level description of the system. Programming in Oberon [2] is the reference for the Oberon language and contains examples and exercises that make it suitable as a textbook. Project Oberon is the third volume in the Oberon trilogy. It is a detailed case study of the design of this innovative system. Wirth and Gutknecht's primary goal was not only to build a system that provides most of the capabilities found in today's workstation environments, but to do so using modern software engineering concepts so that the result could be used as teaching material. To meet this goal within a reasonable time with the limited manpower available (the designers themselves), the authors omitted many of the features usually found in such systems. Rather than layering a graphical user interface on an operating system designed for timesharing, the system was designed from scratch to provide an interactive, extensible window-based user interface tightly integrated with a task management facility optimized to support user interaction. This book contains 14 chapters. Slightly less than half of the text consists of program listings of the system's modules. The first two chapters describe the authors' motivation for the construction of Oberon and introduce the modules that are described in the balance of the book. Although versions of Oberon exist for a number of machines, the description here is based on the implementation for the Ceres workstation developed at ETH. Fortunately, most of Oberon is machine-independent, so the listings provided apply to all implementations. Chapter 3 describes the Oberon task manager. Perhaps the most unfamiliar idea in Oberon is that the unit of execution is not a program but an individual procedure invocation. Command procedures are activated by clicking a mouse button on a string of the form “Module.Procedure” anywhere on the display. Command procedures are parameterless, but they can interrogate their environments (typically nearby text) for their operands. An example is the command “Edit.Open name.txt,” which activates the procedure Open in module Edit (loading the module dynamically if it is not already present in memory). The procedure then opens a viewer (window) displaying the contents of the file “name.txt.” A unique cursor identifies a position within the text of the active viewer, and characters and mouse events from the user are delivered by the system to a handler provided by the application at the time of its creation. Since user-initiated events can be handled rapidly, the need for preemptive multi tasking is eliminated; the task manager is a loop that polls for events and dispatches them to the appropriate handler. Chapters 4 and 5 describe the display management facilities and the text subsystem. In Oberon, text strings are an abstract data type. Their creation, modification, display, and ultimate deallocation are handled uniformly. This high level of integration simplifies the creation of new utilities for manipulating text. The standard text editor, for example, consists of only nine pages of code. These chapters contain extensive discussion of the authors' design choices, and a careful reading will reward those interested in the design of user interfaces. Chapters 6 through 8 describe the lower levels of the system, including the module loader, the file system, and the management of storage. They will be of interest primarily to operating system designers. The modules described here are specific to the Ceres implementation of Oberon, and are quite different in versions of the system that are built on UNIX or MS-DOS. Chapters 9 through 11 discuss Oberon extensions that have been provided for a network and for file, mail, and print servers. The designs are Spartan and the implementations small. They nevertheless have proven adequate to support a user community of over 80 faculty members and a large student population at ETH. Chapter 12 presents the Oberon compiler. As with the rest of the system, the design is straightforward. A recursive descent parser and a single-pass design make the compiler extremely fast. Much of the apparent complexity in the version described here is due to the complexity of the target architecture, the (CISC) NS32000. No optimization of the generated code is done, which increases the speed of compilation at the expense of execution. For interactive program development on modern workstations, this choice is undoubtedly correct. Chapter 13 describes the Oberon graphics editor Draw . It demonstrates how the system may be extended to provide new abstract data types using the type extension facility of the Oberon language. The graphics editor is heavily object-oriented, and its description is one of the better tutorials I have read on the utility of object-oriented techniques. The final chapter describes the tools used to bootstrap the system and to recover from disk errors. Since these tools are highly machine-dependent, no program listings are provided, but the discussion of the facilities required for these tasks will interest designers of real systems that must cope with real errors. Oberon demonstrates that a system that supports most of the computational needs of a single user need not be large, slow, and complex. Project Oberon is probably the most complete description of a system of this scale that has ever been written. It not only provides a clear description of the system, but also gives the reader an understanding of the design issu es faced by the authors, and how these were resolved. It is difficult to teach good design practice other than by example, and this book provides a wealth of examples. The writing is clear, a number of figures and illustrations enhance the text, and few production errors have occurred. I recommend it highly.