Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and Iterative Development (3rd Edition)

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

Book Description
“People often ask me which is the best book to introduce them to the world of OO design. Ever since I came across it, `Applying UML and Patterns' has been my unreserved choice.” —Martin Fowler, author, “UML Distilled” and “Refactoring”

The first edition of “Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design” quickly emerged as the leading OOA/D introduction; translated to many languages and adopted in universities and businesses worldwide. In this second edition, well-known object technology and iterative methods leader Craig Larman refines and expands this text for developers and students new to OOA/D, the UML, patterns, use cases, iterative development, and related topics.

The book helps newcomers to OOA/D learn how to “think in objects” by presenting three iterations of a single, cohesive case study, incrementally introducing the requirements and OOA/D activities, principles, and patterns that are most critical to success. It introduces the most frequently used UML diagramming notation, while emphasizing that OOA/D is much more than knowing UML notation. All case study iterations and skills are presented in the context of an “agile” version of the Unified Process -- a popular, modern iterative approach to software development. Throughout, Larman presents the topics in a fashion designed for learning and comprehension.

Among the topics introduced in Applying UML and Patterns are: * requirements and use cases, * domain object modeling, * core UML, * designing objects with responsibilities, * “Gang of Four” and other design patterns, * mapping designs to code (using Java as an example), * layered architectures, * architectural analysis, * package design, * iterative development, * the Unified Process.Foreword by Philippe Kruchten, the lead architect of the Rational Unified Process.

“Too few people have a knack for explaining things. Fewer still have a handle on software analysis and design. Craig Larman has both.” —John Vlissides, author, “Design Patterns” and “Pattern Hatching”

“This edition contains Larman's usual accurate and thoughtful writing. It is a very good book made even better.” —Alistair Cockburn, author, “Writing Effective Use Cases” and “Surviving OO Projects”

Those (like me) who have avoided Unified Process because it looks too rigid, bureaucratic, and form-laden will love this book. The author argues convincingly that UP is best implemented in an iterative process that looks more like Extreme Programming than the cumbersome waterfall process one typically associates with UP. Then the book shows how to implement a UP process in enough detail, with enough examples, and with enough flexibility, that a project leader can readily put this form of UP into practice.

I have avoided UP for years, but this book may have made a convert out of me. It's the first book I have seen that makes an effective business case for UP and presents a practical guide to its implementation. I have no hesitation recommending it to anyone, from novice project leaders to seasoned software architects.


Balanced Real-World Advice For Best Practices Software Development   February 18, 2006
John Freeman (Vienna, VA United States)
8 out of 8 found this review helpful

I read the first edition of this book years ago when I was making the transition to objects. It was about the tenth book on the subject that I had read, but it was the first one that consistently anticipated the questions that came up when I was actually trying to build something using UML, long after the hype and "objects will save us" party atmosphere had died down. Craig Larman has carefully remembered, or has taught this enough to have been reminded of, the kinds of questions software practitioners actually encounter on the way to building systems using UML. This 3rd edition is twice as big as the first, and it is twice as good only because it is twice as much of Larman's excellent teaching.

This book is so good that even developers experienced with UML, the GRASP patterns, and agile development methods will gain from it, reminding us once again to balance the best practices that we apply perhaps a little unevenly at times. It is clearly a book by someone who has been there, and has remembered what it was like during the learning process. But perhaps its greatest strength is its application of very good theory in a very pragmatic way, in short, its balance. This is one of a very few books that I recommend to everyone I know in software.



The road from programmer to OO developer   August 26, 2001
Jane Griscti (Whitby, Ontario Canada)
43 out of 43 found this review helpful

Trying to make the journey from programmer to OO developer? Have you learned an OOP language? Read a few books and articles on Use Cases, UML, Refactoring, Patterns and RUP? Do you have the vocabulary but still find yourself struggling with the grammar when you sit down and actually try to design and code an application? Yeah, yeah . . . you know it's an 'art', that's nice, but where do you start? How does all this OOA/OOD/OOP stuff work together? How do you apply it? If all of this seems familiar, look no more; Mr. Larman's book was written for you! For someone used to procedural programming, walking into OO land is like being dropped into the middle of a strange country without a map. Mr. Larman's book is the Fodor's travel guide you've been searching for. He places OO development in a context which is understandable while he explains the basics of each OO tool and describes how and where they are best used along the road that leads from a problem domain to a true OO application. The book is well written, provides real world examples of design problems you're likely to encounter and best of all: it is not a description of how someone else solved a particular problem! It gives you a framework you can use to solve development problems on your own! If you are trying to make that leap from programmer to OO developer; pick up this book and confirm for yourself that finally, finally you have found the right text to guide you on your journey.


Except for the title, a great book!   January 15, 2002
R. Dameron (Longmont, CO United States)
21 out of 21 found this review helpful

This book IS what the subtitle says: An Intro to OO Analysis and Design and the Unified Process. It is a GREAT introduction. It also uses patterns and does a good job of explaining why various approaches are what *good* programmers do. But it does strike me that the main title was invented to get the most "hits" on a variety of searches one might try. It's not primarily about "applying UML" which is a good thing, despite the title. It does use UML as its notation whenever notation is needed and it explains the usage well. I am using this book as a text in the first of a 3-course graduate series on software engineering. The reactions from students (all with industry experience, most without OO experience) have been quite positive. The use of an example that runs throughout the book provides a vehicle for getting deeper and deeper into certain topics. Larman writes in a very readable style but he doesn't write "down" to the reader. His motivations for various techniques/approaches are reasoned and appropriate. He references excellent books as well. As the professor, I have used some of these to develop certain topics more deeply in my accompanying lectures.


The Best OO Analysis and Design tutorial book   January 8, 2002
Vinit Carpenter (Brookfield, WI USA)
3 out of 4 found this review helpful

There are already some great reviews for this book and I don't feel like I can add anything new, but I still want to get my vote in and say that this book is really THE BEST Object Orientated Analysis and Design tutorial book.

The book starts and builds upon itself, chapters after chapter as you move forward through the book using the Java programming language. The topics covered in this book include OO fundamentals, UML, design patterns, Unified process, and many other great topics. I wanted to steal a line from the review by Dan Moth where he says, `Craig Larman proves it (OOA/D) to be a science and not art or magic'. I couldn't have stated this any better. This is a great book and must be in every developer's book shelf, especially ones starting out in OOA/D.