It is important to note from the outset that this short Lecture Notes in Computer Science (LNCS) volume is the user manual for the common algebraic specification language (CASL), rather than the definitive and more extensive reference manual [1].

CASL was produced by the Common Framework Initiative (COFI), which is associated with ESPRIT and International Federation for Information Processing (IFIP) Working Group (WG) 1.3. It is a distillation and a rationalization of earlier algebraic specification languages. Hence, this volume should be immediately accessible to anyone who has already used such a language to specify a software artifact algebraically (that is, by a set of first-order equalities).

The text is example driven, and many of the examples are those commonly found in any introduction to algebraic specification. Another feature of the book is its use of boxed “headlines” or “points to bear in mind.” These are sprinkled throughout the book, to help guide the reader, and highlight the important philosophical pointers underlying the language design. They are also repeated in Appendix B, which is perhaps what everybody ought to remember about CASL. CASL already has agreed-upon subsets (based largely on the parent languages; for some of these, there exists tool support) and extensions for use in more complex kinds of software.

Part 1 of the book sets the scene, but Part 2 is where we first meet actual specifications (proceeding by way of examples), namely, types, which are (intentionally) almost self-explanatory. Next, we meet partial functions, subsets, and structured specifications. The different kinds of structuring present inexperienced readers with the greatest challenge; they have probably not yet fully appreciated the possible variants, and their mathematical, logical consequences. Starting in chapter 3, we meet generic specifications, which are parameterized by a type (and which may be reused; much is said about this in chapter 7); loose specifications (to which further constructors may be added later); free specifications (in which all different values are distinct); and generated types (in which all results are derived as a consequence of the rules, and nothing else). Some of these distinctions can be confusing at a first glance, but the examples help clarify the differences.

With the specification of a new type or class, we may use local specifications and hiding. Within these constructs, local operators cannot be exported. In contrast to this approach, in chapter 8, we meet so-called architectural specifications. Here, each unit identified in the specification gives rise to a separate implementation task. So, we must address the often-asked question of whether any design decisions should be included within the specification, or if such choices should be left to the implementer. Once a decision has been made, the specification can be written to reflect that decision. How to build and structure new libraries is considered in chapter 9.

Part 3 covers foundations (the details of which are in the reference manual), available tools, and basic libraries. The text finishes with a case study, in which CASL is applied to the familiar steam boiler problem (the initial textual formulation of which is given in Appendix C).

In addition to Appendices B and C, mentioned above, the book also contains Appendix A, which provides a quick reference to the whole language. Accompanying the book is a CD-ROM, which contains the majority of the text, and several libraries. Major libraries of validated CASL specifications are freely available. These are mainly parsers and static checkers; more advanced proof-related tools are still in their infancy.

This book admirably meets its objectives, and may provide many CASL users with all of the information they need to use the language. Only more advanced users need consult the reference manual.