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

~ (Author)

Editorial Reviews

Amazon.com Review

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 --This text refers to an out of print or unavailable edition of this title.

Product Description

"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"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"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"This book makes learning UML enjoyable and pragmatic by incrementally introducing it as an intuitive language for specifying the artifacts of object analysis and design. It is a well written introduction to UML and object methods by an expert practitioner." --Cris Kobryn, Chair of the UML Revision Task Force and UML 2.0 Working Group*A brand new edition of the world's most admired introduction to object-oriented analysis and design with UML *Fully updated for UML 2 and the latest iterative/agile practices *Includes an all-new case study illustrating many of the book's key points Applying UML and Patterns is the world's #1 business and college introduction to "thinking in objects"--and using that insight in real-world object-oriented analysis and design. Building on two widely acclaimed previous editions, Craig Larman has updated this book to fully reflect the new UML 2 standard, to help you master the art of object design, and to promote high-impact, iterative, and skillful agile modeling practices. Developers and students will learn object-oriented analysis and design (OOA/D) through three iterations of two cohesive, start-to-finish case studies. These case studies incrementally introduce key skills, essential OO principles and patterns, UML notation, and best practices. You won't just learn UML diagrams--you'll learn how to apply UML in the context of OO software development. Drawing on his unsurpassed experience as a mentor and consultant, Larman helps you understand evolutionary requirements and use cases, domain object modeling, responsibility-driven design, essential OO design, layered architectures, "Gang of Four" design patterns, GRASP, iterative methods, an agile approach to the Unified Process (UP), and much more. This edition's extensive improvements include *A stronger focus on helping you master OOA/D through case studies that demonstrate key OO principles and patterns, while also applying the UML *New coverage of UML 2, Agile Modeling, Test-Driven Development, and refactoring *Many new tips on combining iterative and evolutionary development with OOA/D *Updates for easier study, including new learning aids and graphics *New college educator teaching resources *Guidance on applying the UP in a light, agile spirit, complementary with other iterative methods such as XP and Scrum *Techniques for applying the UML to documenting architectures *A new chapter on evolutionary requirements, and much more Applying UML and Patterns, Third Edition, is a lucid and practical introduction to thinking and designing with objects--and creating systems that are well crafted, robust, and maintainable.

See all Editorial Reviews

Product Details

• Hardcover: 736 pages
• Publisher: Prentice Hall PTR; 3 edition (October 30, 2004)
• Language: English
• ISBN-10: 0131489062
• ISBN-13: 978-0131489066
• Product Dimensions: 10.1 x 8.3 x 1.6 inches
• Shipping Weight: 3.2 pounds (View shipping rates and policies)
• Average Customer Review: 4.4 out of 5 stars  See all reviews (120 customer reviews)
• Amazon.com Sales Rank: #24,921 in Books (See Bestsellers in Books)

  Popular in these categories: (What's this?)

  #3 in	Books > Computers & Internet > Programming > Software Design, Testing & Engineering > UML
  #43 in	Books > Computers & Internet > Programming > Software Design, Testing & Engineering > Object-Oriented Design

Customer Reviews

Most Helpful Customer Reviews

65 of 68 people found the following review helpful:

5.0 out of 5 stars Great Introduction To OO Analysis and Design, December 21, 2001

By	David C. Veeneman (Lincolnshire, IL USA) - See all my reviews (REAL NAME)

This review is from: Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and the Unified Process (2nd Edition) (Hardcover)

This book is the best introduction I have seen to object-oriented analysis and design. It explains the 'Unified Process' of analysis and design, including UML and the use of patterns. I am a big fan of this book because it emphasizes the "why"--the reason for each element of the process from a business perspective. For example, instead of simply offering a recipe for writing use cases, the book talks about why one might include or exclude specific elements to achieve specific objectives.

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.

25 of 25 people found the following review helpful:

5.0 out of 5 stars Except for the title, a great book!, January 14, 2002

By	R. Dameron "been-there" (Longmont, CO United States) - See all my reviews (REAL NAME)

This review is from: Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and the Unified Process (2nd Edition) (Hardcover)

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.

17 of 17 people found the following review helpful:

5.0 out of 5 stars Underlying principles and practice: Excellent job., March 1, 2005

By	C. Constantinides (Canada) - See all my reviews

There is a lot of textbooks on UML in the market, similarly on development processes like the Unified Process, design patterns and OOA/D. Many textbooks that I have seen provide a dry list of UML notations, or a dry list of process guidelines, or trivial examples on how a design pattern can be implemented. However, no other textbook in my opinion makes an excellent job in putting everything together in a case study (the 3rd edition provides two case studies) in order to illustrate (1) what is the significance of each one of the above, (2) how they fit together and (3) what are possible tradeoffs. The author very clearly explains what are the underlying principes behind object-oriented software development and (more importantly) how these principles can be put into practice.

Since the first edition I found Craig's writing style very easy to follow and as a graduate student taking software engineering and related classes I used this textbook as a self study to learn about OOA/D and UML. As an instructor I have been using this textbook for a number of software engineering and related classes (both senior level undergraduate and graduate), and the feedback I receive from students is very positive. I also recommend this book to students who are undertaking final-year undergraduate projects or graduate projects, and we have found this book to be very valuable for projects that involve several stages of analysis, design and implementation and who want to know how a process such as the Unified Process can be used in an agile manner. My experience tells me that this last point is very important for students who would work individually or in small groups over a (usually) short period of time to complete a development project.

Several of my previous students who are now employed in the IT industry as developers are telling me that they still use this book and find it a very valuable reference.

The book has also sparked interesting discussions among colleagues and researchers on various aspects on OOA/D and it is a valuable source. More particularly, the book successfully manages to integrate the principle of Design by Contract beyond implementation. Craig's approach to introduce operation contracts places emphasis on assertions from early stages of development and shows how this emphasis is propagated to detailed design (through UML communication diagrams) and through the use of responsibility patterns.

Regarding a comment on GRASP by a previous (and anonymous) reviewer, I would like to point out that a pattern is a set of principles (can be on any level of granularity) that solves a recurring problem at any stage during development. This (albeit informal) definition does not confine patterns to structural or behavioral design (along the lines of the GoF design patterns). Craig makes that very clear in the book particularly in the second and third edition) and I'm afraid to say that the reviewer who made the comment either skipped that part or misunderstood it.