The back cover of this book provides a compact and precise description of the topics it handles, and its main contribution, characterizing the work as a “practical checklist approach to enhancing the quality of software models created with the Unified Modeling Language (UML) Version 2.0.”

Seven chapters and six appendices make up the book. Each chapter starts with a chapter summary, and closes with two sections on discussion topics and references. Chapter 1 outlines the conceptual grid, which the remaining contents are structured around: three modeling spaces (model of problem space (MOPS), model of solution space (MOSS), and model of background space (MOBS)) and three kinds of model checks (syntax, semantics, and aesthetics). Chapter 2 provides a short description of all of the UML diagrams, and chapter 3 presents their strengths and weaknesses, as well as their objectives and the traps for the software engineer. The core chapters of the book (chapters 4 through 6) address the verification and validation of the quality of MOPS, MOSS, and MOBS. The last chapter is a very short discussion of how to embed verification and validation checks into an overall software development process.

The appendices describe the case study used in the book as an underlying example; offer a list of criteria that can be used to evaluate UML tools, and information on some of them; and provide some templates to be used in MOPS. The summaries of the various verification and validation checks for MOPS, MOSS, and MOBS, presented in practically useful checklists, are the most important feature.

All of the considerations are illustrated, and therefore held together, by a single example. The reader can thus easily follow how the features are used, and how they are developed and refined during the life cycle of a model.

To get the correct view of the topic, it is essential to always have in mind the conceptual coordinate system into which all of the contents of the book are embedded: “The problem space deals with all the work that takes place in understanding the problem in the context of the software system before any solution or development is attempted” (page 11), that is, mainly understanding and documenting the requirements. “The solution space is primarily involved in the description of how the solution will be implemented” (page 11), and the background space deals with management and architecture. It is also important to know that “the major part of V&V [verification and validation] deals with the visual aspects of the model” (page 15).

Many of the checks listed in the book are commonplace. However, since real projects are usually much more demanding than the many typical textbook examples, it is very useful to have systematically prepared lists of hints on what to do and how to do it. Unlike the author, who rates his book as “intermediate to advanced” (on page xxviii), I believe it is for an intermediate audience. The book does not present any practically useful information on the big and great semantical progress of UML 2.0, nor does it more than point out the concepts of model-driven development or executable models; only one short paragraph is devoted to each of these two topics (on pages 6 and 16). Likewise, there is not even one example of the use of the object constraint language (OCL). These three topics must be seen as important building blocks of verification and validation activities for UML models. Another reason for the intermediate designation is the author’s suggestion of how to present the material in a one-day workshop. I do not believe that an advanced textbook can properly be presented in four sessions, of 90 minutes each (page xxix). I also do not share the author’s opinion that chapters 2 and 3 together provide a self-sufficient resource on UML diagrams (page xxvi).

I recommend this book to all those who have some basic knowledge of, and some experience with using, UML in small or medium-sized projects. For them, it will serve as a useful guideline for their next UML modeling task. For those who, like me, also expect (based on the “verification and validation” phrase in the title) to read more about, for example, specification, behavioral subtyping, and runtime checking, and about where and how to use OCL for these and other purposes, this is the wrong book.