Applying UML Patterns : An Introduction to Object-Oriented Analysis, Design and Iterative Development

by Craig Larman

Good software starts with a good design, and the subtitle of Applying UML and Patterns, "An Introduction to Object-Oriented Analysis and Design (OOA/D) and the Unified Process" reinforces that that's what this book is about.

The first edition of Applying UML and Patterns became a standard. The second edition uses the unified process (UP) as the iterative process within which OOA/D is introduced, and extends the case study used in the first edition. Other changes have been made to reflect the growing consensus on the most effective ways to work with OOA/D and patterns.

Although you will learn UML, this isn't what Applying UML and Patterns is all about. It's designed to teach you to think of software as a collection of objects with properties and to manipulate the relationships between them. This is far more profound.

The case study enables Craig Larman to carry the design through to Java code. In practice, you will need a basic understanding of OO programming to benefit from Applying UML and Patterns, though you needn't know Java--you can implement the designs in the OO language of your choice with equal facility.

When it comes right down to it, Applying UML and Patterns is all about providing you with a language in which to think about software design. This is quite different from learning a language in which to code a design.

A facility with OOA/D will enable you to design and discuss programs independent of code, to produce more elegant and maintainable software, and to take a 30,000-foot view of the way your software interacts with the world. In effect, it can shift your viewpoint from that of a mechanic to that more sophisticated viewpoint of an engineer. Recommended. --Steve Patient. Amazon.co.uk

Genres: Programming, Computer Science, Technology, Software, Technical, Nonfiction, Architecture

592 pages, Kindle Edition

First published January 1, 1997

Reviews

[Barbara Notte · Rating 4 out of 5]

This is one the best books for programmers and I think every programmer should read it. The only problem this book has is some parts of it is written specifically for senior developers and architects; so, you may want to skip them, if you're not a SENIOR developer yet, like myself.

[Matt]

Right on the cover, Martin Fowler says Larman's book is his unreserved recommendation for learning OOD. Circa 2006-2010, that's an incredibly huge endorsement and says more than any amateur review could.

This is a big, college-text-style book. It's dense. I've read it twice through, and that was probably a mistake because it feels like I've failed to really soak it all up. Hence it's back on my to-read list. It might better use the book more as a school text - read a couple chapters, consciously apply that material at work, repeat.

As for content - this is pretty good stuff. If you're trying to learn OOA&D, it feels like what you would have gotten out of a competent and pertinent full-year college course in OO and software engineering. (Yes, it covers much more than "just" OO.) As with many college courses (at least in software), it's thorough, it's "canon", but is ultimately only a start.

Another way I look at the content of this book is in this comparison: Imagine graduating from a college with a basic, vanilla, no-frills CS degree and landing a development job at a non-software company that doesn't have much software practice. You are asked to put together programs to solve problems as you see fit. You grow in areas dependent on your environment and initiative but most likely on happenstance. Constrast with landing a job at a company that has its act together with a mature development environment, effective practices and structure, etc. People are indoctrinated into "the way" (i.e., methods, habits, artifacts, PATTERNS, etc.) You grow in a guided path along what has worked here, and would probably be useful elsewhere as well.

Larman's book helps you move from the former to the latter, as if you'd worked for LarmanCo.

[Peter Sichevsky · Rating 3 out of 5]

Reading this book was a slight deception, not because of the content, but MAINLY because it's a bit messy. The chapters don't correlate with each other very well and the content is not as well organized as I was expecting. Aside from that, I believe I learned something new.

[Recep Karabıçak · Rating 4 out of 5]

This book covers a variety of software development topics like UML, object oriented anlaysis/design, design patterns and iterative/agile development. These are topics to which entire books were dedicated. What you’ll find here will only scratch the surface of each without going into deep discussions.

If you are new to object oriented programming or software development in general this book is a great starting point.

If you are already familiar with the subjects and have some oop, iterative development experience then consider this book to polish your knowledge and fill the gaps.

But if you are on the other end of the scale and feel confident about the topics and been developing for quite some time there is nothing new here.

I am of the second group and found the material helpful. The GRASP idiom was completely new to me. The only issue i see is the usage of Unified Process as an iterative approach. Your chances to put the unified process knowledge to use is very slim in a Scrum world.

[Sergey Teplyakov · Rating 4 out of 5]

One of the best books about software development in general, about OOA/OOD and fundamental design principles in particular.
This is "introductary" book but it would be useful not only for graduates, there is a tons of useful advices that would be helpful for everyone - starting from junior dev to mature senior guy who already forgot the basics.

[Michael Cabus · Rating 5 out of 5]

I must admit I am reviewing a book I read in graduate school. However I wanted to add a review to encourage people in ux design to read it.

It is complex. However it's an entry into understanding how software developers will work with you. Also as a system for defining software models and requirements it is an excellent system.

And learning Object-oriented design is fun. It's nicely analytical, and will even help you understand programming.

I was rereading some sections this morning for a project; and it will be a life saver.

[Babak Ghadiri · Rating 5 out of 5]

این کتاب رو مارتین فاولر بهترین کتاب مقدماتی برای آشنایی با طراحی شی‌گرا معرفی کرده و به نظر من هم همینطوره.
در این کتاب قسمتهای مهمتر UP و UML و طراحی شی‌گرا و نحوه‌ی استفاده از الگوهای GoF بیان شده اند. به نظرم علاوه بر اینکه برای افراد تازه‌کار در زمینه‌ی تحلیل و طراحی شی‌گرا بسیار مناسبه، برای افراد باتجربه هم خواندنش باارزشه مخصوصا فصلهایی که درباره‌ی الگوهای GRASP توضیح داده و نحوه‌ی استفاده از این الگوها و الگوهای GoF رو در عمل نشان داده است (شامل فصلهای ۱۶، ۱۷، ۲۲، ۲۳، ۳۳، ۳۴). می‌توان فقط همین فصلها رو جداگانه خواند، هر چند کتاب لذتبخشی هست و کامل خواندنش باارزشتره.

[Kennet · Rating 1 out of 5]

It does say quite much about UML if you read through it all (I guess). But to just get the information you're interested in (which UML is much about for me; combine and use the parts that suit your current project), it's quite bad. Hard to use as a reference book. So I didn't like it. It does probably have most information you need though, just not for me.

[Alexander Bos · Rating 4 out of 5]

I hate this topic by heart, and never want to touch UML or Requirements...
The book is pretty good though.

[João Graça · Rating 4 out of 5]

The book is divided in 3 main chapters. The first 2 chapters were very good and I learned a lot form them. The 3rd chapter was not so useful I think, because the knowledge is less applicable to nowadays architectures. The 2 case studies presented along the book were very clear and useful to understand the concepts that Craig Larman wanted to teach

[Alejandro Teruel · Rating 4 out of 5]

In spite of its publication date (2005), the third edition of this book is still well worth considering the main text for an initial undergraduate course in object-oriented software engineering based on agile or iterative development, especially if the course focuses on analysis and design. It is breezy, down-to-earth and practical and gives a good idea of what iterations in inception and an elaboration stages look like.

Based on a well chosen realistic case study -a Point of Sale (POS) system-, Larman slowly and elegantly shows how to conceive and begin to flesh out such a system, covering a number of key points in functional and non-functional requirements engineering, domain analysis, architectural design and pattern-based design, and how to steer clear of classic waterfall-based development pitfalls. The book is clearly based on a practical subset of UML 2 and lighty but clearly and cleanly touches on the Unified Process (UP) of software development. He even covers important basic aspects of software product line development without making a song and dance about it.

The book is divided into three parts and 40 (!) chapters:

I. Introduction (3 chapters);
II. Inception (4 chapters);
III. Elaboration Iteration 1 -Basics (15 chapters);
IV. Elaboration Iteration 2 (5 chapters);
V. Elaboration Iteration 3 (13 chapters):
VI. Special Topics (1 chapter on planning).

What is particularly nice about Larman's book, from a pedagogical point of view, is that intermediate and advanced concepts are covered when needed for the development of the case study. Thus, in the first chapters, a basic class diagram in introduced and used and only later in the book, as the need comes up, are more advanced aspects of class diagrams such as conceptual class hierarchies, inheritance, association classes, aggregation, derived elements, qualified associations and reflexive associations introduced. The same logic is used for different kinds of modeling diagrams.

Larman introduces and uses quite effectively a number of key classical GoF patterns (Facade, Strategy, Composite, Observer, Adapter, Proxy, Abstract Factory, Singleton, Command, State) as well as what he calls GRASP patterns, which are simpler patterns or principles of design including low coupling, high cohesion, polymorphism, indirection and protected variation among many others. Coupling and cohesion are introduced quite airily and vaguely, which is occasionally confusing. Protected variation is an interesting principle which Larman uses both to show the importance of loose coupling and its potential for product-line architectural design.

Larman also relies on a second case study, an automatic Monopoly playing system. This seems to have been tacked on in order to provide a different problem domain to POS, and is satisfactory insofar its design to handle the different kinds of squares in Monopoly, but the rest of the system is covered cursorily and in my opinion, quite unsatisfactorily. In the first chapter Larman introduces, as an example of analysis, rolling dice, but its analysis and later its use as part of the design for the Monopoly case study is shallow and misleading -no effort is made to introduce randomness, or at the very least, criteria or requirements for pseudo-random number generators, a key issue in rolling dice.

Requirements engineering is somewhat limited to Grady's FURPS+ model (Functional, Usability, Reliability, Performance, Supportability requirements) with a nod, in the later chapters to implementation, interface, operational, and legal constraints -quite adequate for the most part for an introductory course on software engineering -although nowadays a little more effort should probably be devoted to security issues than is the case. In this book.

The book is focused on analysis and design which probably explains why key topics in agile development processes such as tests and refactoring are barely mentioned in a brief and, from the point of view of an introductory course on software engineering, a very unsatisfactory Chapter 21 (Test-Driven Development and Refactoring). Its introductory chapter on business modeling is much more satisfactory.

Larman is particularly strong on common-sense modeling and development heuristics. He insists for example on sketching architectural designs for discussion and, as is common in agile practice, letting the design details fill in as programming proceeds -thus for documentation purposes he proposes reverse-engineering the final architectural design of an iteration or stage from the code actually produced. He also recommends steering clear of detailed discussions about some of the UML's more confusing distinctions -thus in general he recommends relying only on includes relations in use cases and skipping extends or generalizes -a very pragmatic suggestion well taking up.

The are three issues he seems to have second thoughts on: error and failure handling, how to include persistent objects, and GUI frameworks. In chapter 35, Larman provides a brief but interesting introduction on exception handling, using elements such as the Adapter, Factory, and Proxy patterns, active objects, and threads. The use of threads will probably be over most undergraduate heads if they are taking a first software engineering course, but it probably works as a reference forward to more advanced courses. The chapter includes two excellent examples for failover mechanisms taken straight from his POS case study, the first by the need to cache product descriptions in a catalog database for performance reasons and the second in order to post receivables into an external accounting system. In chapter 38, Designing a Persistence Framework with Patterns he tackles enough aspects of how to implement persistent objects, particularly and not exclusively by mapping objects into a relational database system, to understand how this is done -I would have loved to have had access to this chapter twenty years ago when I was struggling to understand this key point. In Chapter 39, Documenting Architecture: UML & the N+1 View Model he rather unsuccessfully -in my opinion-, attempts to introduce the basic design architecture of the (somewhat dated) Struts GUI framework.

For a more formal treatment of software development using UML2, I would highly recommend Bernd Bruegge and Allen H. Dutoit's third edition of Object-Oriented Software Engineering Using UML, Patterns, and Java (2009), which also includes a great many interesting exercises -even if its case study, a game tournament support system,while interesting, is in my opinion not as formative as a point of sale system, especially for those students who are interesting in the information systems domain. Larman's book, as several other Goodreads reviewers have pointed out, includes no exercises. However, I suggest, the interested reader can add some exercises to Larman simply by taking into consideration more up to date point of sale systems. While Bruegge and Dutoit's book covers agile processes, it is not as clear as Larman's on what actually goes into one iteration rather than another.

I used the first edition of Larman's book as the key textbook to the introductory course on object-oriented software engineering I taught in 2001. The size of the second edition of the book was a shock to me and prejudiced me against it, I am sorry to say, and I put off adopting it for far too long. I had not come across the third edition until very recently. In spite of its 2005 publication date, the third edition of Larman's book is still, in my opinion, an interesting, well written, and innovative book which beautifully shows how agile, iterative analysis and design can contribute to succesful object-oriented software development.

[Rosivaldo Alves · Rating 4 out of 5]

Eu programo há quase três décadas (sim, não sou mais tão jovem. :-) ). Na primeira década, eu era fluente em programação estruturada. Era fácil divisar uma solução mesmo para problemas de razoável complexidade. Aí veio a programação orientada a objetos. Eu aprendi. Aprendi bem. Na teoria.

Na prática, toda vez que me deparava com um problema, meu raciocínio só me guiava pelo refinamento passo a passo de um algoritmo, técnica usual em programação estruturada. Eu simplesmente não sabia *pensar* orientado a objetos.

Agradeço a Craig Larman e a este livro. Eles me ensinaram a pensar em um novo paradigma. Hoje, eu enxergo com facilidade qualquer problema computacional em termos de objetos, classes, métodos, mensagens, eventos, essas coisas.

Recomendo a todo desenvolvedor.

[Divyesh · Rating 3 out of 5]

The book explores about iterative development needed in an agile environment. However, the author forces you to read the same idea n number of times in the book dispersed in various chapters. This may actually be an iterative process to learn the same concept by studying it again and again but sometimes it fails to impress the reader. However, concepts are defined very clearly and written in an easy-to-understand manner.

[Waldemar Mękal · Rating 5 out of 5]

I wish I could read it a few years ago. Brilliant guide to OO Analysis and Design explaining how to practically do it, how to gather requirements, then analyse it to create domain model and create design model.

There are some part that you can omit or just skim like UML diagrams explanation, but there are also the parts that gives you so much brilliant knowledge and explanations (like GRASP patterns)...

Really, really recommend.

[Ruben Steins · Rating 3 out of 5]

Very broad book that combines a lot of topics: OO, software craftmanship (GRASP), RUP, Agile. Maybe a bit more focus would have been better. Still, a decent book and well usable as a textbook for OO 101.

[Mehmet Davut · Rating 5 out of 5]

Fantastic book! Every software developer who wants to improve architectural and engineering skills should read this one. It replied all the questions in my mind and I feel like it filled a big empty space :)

[Robert · Rating 4 out of 5]

good but not suited as a reference guide. And it's lacking exercises

[Sicofonia · Rating 3 out of 5]

Originally published in 2004, reading this book in 2021 makes it feel a bit out of date.

The premise of this book is to comprehensive show and explain principles of object-oriented design by working on two practical case studies: A point of sale system and the monopoly game. On top of that, it makes use of the Unified Process in order to also explain how to do this OO modeling while developing in iterative-incremental fashion.

A lot of UML is covered, yet this is not a UML book. A lot of patterns are covered, yet this is not a book about patterns. A lot of tips on how to plan iterative projects are given, yet this is not an Agile Project Management book.

I think Larman's efforts here were noble, to incorporate all the techniques that are used to implement a real world project in one single book. And show how to do it by applying those methods on case studies.

The result however is far from satisfying. Because there are two case studies intermingled, I found it really hard having to shift back and forth between the requirements and models of two different things while at the same time trying to mentally digest the new concepts presented to me in terms of UML or OO design patterns. Mind you, what I read was a PDF copy of this book on an ereader; and I'm suspect that having the actual hardcover somehow would facilitate the reading.

By the second half of the book the case studies start to get progressively forgotten and Larman delves in more complex patterns and principles of OO design, architecture and process. And for me it only increased the levels of tediousness.

Larman is busy these days promoting his "de-scaling" framework Large Scale Scrum (LeSS). In hindsight, when writing this book he could have done with the current advice he gives to companies by applying the "Less is More" principle.

So in short, definitely a good book to introduce/revisit both newcomers and seasoned programmers to OO design. However, it suffers from low cohesion (no pun intended) and therefore reading it can be tedious at times.

[Ali · Rating 3 out of 5]

1. This book is definitely not an introductory text as it says. The reader is expected to be comfortable with sufficient software engineering jargon. Since I am a beginner with UML and Patterns (but well-versed with OOP), it was not the best book for me.

2. The book is very broad in the sense that it combines a lot of topics: UML, Agile UP, Patterns and OOA/D.

3. The title of the book is somewhat misleading to me. Although, it is about UML and Patterns, but it's really the sub-title that tells the story. This is a book on object oriented analysis and design (OOA/D). UML and Patterns are simply two of the tools used to teach OOA/D.

[Joona · Rating 4 out of 5]

I found this to be a fine book to learn about basic OOA/D. It also covered other related topics, such as agile development principles and UML quite well, though I didn't find most of these quite as relevant and practical to me as the OOA/D parts. Perhaps those readers who actually utilize formal UML in their workplace will get more out of them, to me many of the design artifacts / documents covered felt like an overkill for most real-world projects. The book was easy to read and provided a decent amount of practical examples.

[Garima Singh · Rating 5 out of 5]

It is a must read for all agile teams. Great book 👍

[Deepak Mishra · Rating 1 out of 5]

Dry book. may be I didn’t read it too well. But It didn’t help me too much.

[Jordan Hernandez · Rating 4 out of 5]

A nice introduction to a OOA and OOD , the GRASP patterns part was fundamental for my projects.

[Sami Ullah · Rating 5 out of 5]

Best book

[Damayanthi Herath · Rating 4 out of 5]

Clearly outlines the concepts behind software modelling and design and presents the effectiveness of UML.

An enjoyable read.

[Paul · Rating 5 out of 5]

Really good reference. Read it from cover to cover. Will always keep this one within reach.

[Héctor Fabio · Rating 4 out of 5]

Libro reciclado y para no olvidar su paso por mi historia.

[Monia Hadhek]

it's amazing and i buy it

[Ivan Krsnik · Rating 4 out of 5]

I came for OOAD, not UML. Chapter 14 is the standout, makes it a worth read.

[David Lindelof · Rating 5 out of 5]

Easily one of the best books on object-oriented design I've ever read.

Through two case studies (a point-of-sale terminal application and a Monopoly game) the author goes through the entire process of eliciting use cases, domain modelling, design modelling, and implementation. The UML notation is introduced and used along the way, as are several patterns---not only the classic GoF patterns, but also some extremely useful design guidelines.

This book should be read by any senior developer who's currently involved in the early stages of a software project. Even if you do not follow its recommendations to the letter, it will certainly improve the chances of success. For example, since reading it I make a nuisance of myself by insisting on having detailed, written use cases---not simply bullet points on some powerpoint.

This book belongs on any developer's bookshelf, right next to the classics.