Browse Books

Reviewer: Jiri Horejs

The growing importance of abstraction (neglecting details as long as possible) and specification (“what” as opposed to “how”) in modular program development is widely recognized. However, the gap between advanced theory (of algebraic specifications, particularly) in a corresponding programming environment (languages and exact methodologies) and everyday programming practices is still considerable. This book significantly helps to fill the gap. After a brief description of CLU, an object-oriented language that supports the outlined methodology, three forms of abstraction—procedural, data, and iteration—are discussed in about one-third of the book. A thorough treatment of exceptions and formal specifications constitutes another part, which covers material difficult to find elsewhere in a well-arranged textbook form. The rest is dedicated to topics which are more standard: testing and debugging, verification, design, and implementation. All of the 15 chapters are supplied with examples, exercises, summaries, and hints on further reading. An appendix displays the CLU Reference Manual implementation of a program (a text formatter) that is specified and designed in the text, as well as five programming assignments. The following are possible shortcomings: (1)The presentation is not homogeneous. It ranges from profound discussions of basic programming concepts and precise techniques (surely new for some readers) to a general narrative of well-known topics which could have been made more concise, thus saving some of the 450 pages. However, even here a lot of useful ideas can be found or recalled. (2)To get the full benefit of the book, you have to learn a new programming language; if you are already familiar with CLU, you surely know most of the facts the book is conveying. Nonetheless, it is worth getting acquainted with CLU philosophy. The book shows how to apply the discussed methodology in conjunction with other languages as well. (3)While the book addresses the problem of writing complex programs, most of the examples deal with simple traditional structures like sets, strings, and stacks. However, the authors were fairly inventive in finding good examples; at least one, the text formatter, is not so simple. (4)There are minor flaws in presentation: (a) some constructs are used before being introduced (x:int:= . . . on p. 18, for example); (b) some are denoted differently (e.g., R for rep on p. 72, reversed order of arguments in IS_IN on p. 193); and (c) the definition of sufficient-completeness is perhaps not sufficiently and completely justified. However, these little bugs can hardly cause any serious misunderstanding. Summarizing, the book promotes a highly promising programming approach and presents a lot of useful design suggestions. Although in some parts brevity is not the book's distinguishing feature, it is worth inclusion in your library.