Browse Books

Reviewer: David Bellin

Experienced designers of large systems will find the several dozen design use cases described in this book, using unified modeling language (UML) 2.0 notation, to be useful. The text is neither a college textbook, nor an introduction to its subject. The main part of the text, and, according to the authors, "the reason it was written," contains three sections. One delineates 11 different use case patterns (140 pages). Another defines ten use case blueprints (136 pages). The third outlines eight common mistakes, which also can be described as patterns in themselves (35 pages). Preceding the material described above are two sections that attempt to introduce the concepts of patterns and use cases. Unfortunately, the writing style is dry and pedantic, and there is little of the verve here that is so common to other authors in this community. Readers wishing for more overview material, and a sound basis for extending the concepts into their own domains, would do better by looking at other titles. Classic coverage of UML and use cases, background that is necessary for reading this book, can be found in Fowler [1] or Cockburn [2]. I find it odd that no time is spent by the authors on the pedagogy of patterns, that is, on the people or organizational side of use cases. Leading practitioners agree that this is the area in which many projects, and certainly many technologists, fail. Not only did earlier titles discuss this extensively, including my own work [3], but there are other current titles continuing the discussion [4,5,6]. On the plus side, each pattern and use case is described in detail. For those practitioners with the background, the details are thorough and useful, and there is enough information to see how the pattern or use case might be modified and customized. Unfortunately, the book is just not meant for a wider audience; either a classic book [7], or one of the many other excellent books available [1,2,8], is better in every respect. This text is designed for the very narrow audience of technically experienced, large systems developers. It is interesting, as a side note, that a single publisher seems to publish the bulk of the books on this topic. One wonders why, however, they spread the content over several divisions, with different editors, and little cohesiveness. One cannot blame the authors of this book for this, however. Their title, while dry, may be of service to some programmers of very large systems, for whom the customization of just one use case will be worth the price of entry.