Books‎ > ‎

Applying UML and Patterns

posted Oct 8, 2011, 9:55 AM by Fernando Berzal   [ updated Oct 8, 2011, 10:49 AM ]

An introduction to object-oriented analysis and design and iterative development 

Software development books tend to focus on the details of the particular techniques they address, which makes it easy to forget the big picture. Typical books address each topic as if it belonged to a separate world. This book, in contrast, demonstrates how many different techniques and practices nicely fit together in the software development process.

This book is outstanding because of its peculiar organization. The book unfolds as an actual software project (two parallel projects, actually). The two case studies weave together the concepts covered, which are introduced at the points of the projects when they are most useful, lowering the learning curve. From a pedagogical point of view, the recurring use of the same case studies throughout the book is much better than devising unrelated examples for each topic covered (in spite of the typical, well-understood, fairly unimaginative, and, to some extent, boring point of sale (POS) system). Even though you may find this technique repetitious at times, since it often returns to the same underlying concepts to reinforce explained ideas, every experienced instructor uses this basic teaching technique. In any case, the projects follow an iterative process, so the book just reflects what actually happens in practice.

With respect to the book's contents, Larman demystifies the unified process. He focuses on its inception and elaboration phases, where most of the analysis and design work is done. Even though the book title focuses on unified modeling language (UML) and patterns, the books goes far beyond the use of UML diagrams to communicate ideas, and Gang of Four (GoF) [1] design patterns to codify design best practices. Fortunately, the misleading title may attract the people who can benefit most from the contents of the book, namely, those developers who want to expand their development skills. Larman also addresses analysis techniques, such as use case modeling [2], which are wrongly identified as "object-oriented analysis," when there is nothing object-oriented about them [3]. It is a stretch these days to talk about "object-oriented analysis."

The book mainly focuses on object-oriented design and its underlying principles, which are presented as "general responsibility assignment software principles." These are no more than general heuristics on how responsibilities should be assigned to software classes. Their discussion is noteworthy, but is also harder to understand for novice designers, because it requires a higher abstraction capability, a priceless ability for any self-respecting practitioner. Larman does a great job of introducing basic concepts and patterns, while demonstrating how to use UML to our advantage.

Apart from its in-depth coverage of object-oriented design, the book also presents other techniques that are useful in software development. These include the functionality-usability-reliability-performance-supportability (FURPS+) requirements categorization system; use cases, à la Cockburn; and the application of design by contract ideas, during the early phases of the project, by means of operation contracts. Larman also covers layered architectures, package design guidelines, and the N+1 view model for describing "the big ideas of the system." Some readers may feel that their pet techniques deserve a more in-depth treatment, which is virtually impossible if we take into account the broad scope of the book. For those interested in the details, Larman provides pointers to more information.

In summary, this is probably the best book I have seen on object-oriented design at the introductory level. Although it requires previous object-oriented programming knowledge (preferably in Java), it is easy to follow. The book is an ideal choice for self-learning, because it provides insight beyond the "how" of techniques, and explains the "why" behind them. Use it as a starting point, before attempting to fully understand more expert-oriented titles, if you are relatively new to object orientation. Use it as a refresher, to see how everything fits together, if you are more experienced.

-- Fernando Berzal, ACM Computing Reviews, 2005


[1] Gamma, E.; Helm, R.; Johnson, R.; Vlissides, J.: Design Patterns. Addison-Wesley, Boston, MA, 1995. 

[2] Cockburn, A.: Writing Effective Use Cases. Addison-Wesley, Boston, MA, 2001.

[3] Davis, A.M.: Great Software Debates. IEEE Computer Society, Los Alamitos, CA, 2004.