Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and the Unified Process (2nd Edition)
Binding : Hardcover
ProductGroup : Book
Manufacturer : Prentice Hall PTR
Label : Prentice Hall PTR
Publisher : Prentice Hall PTR
Studio : Prentice Hall PTR
Lowest Used Price: USD $5.95
Lowest New Price: USD $18.99
“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”
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
Great introduction to OOAD, Iterative Development, and Unified Process (2009-03-24)
Let me say to begin that I am a graduate student in computer engineering, without a strong OO background. Sure I knew inheritance, polymorphism, and even some UML. But how do you really use them in practice? I have been eager to learn what this OOAD is all about, and anyway it's a valuable skill to possess.
Now where to begin learning OOAD? As I scratched the surface I encountered such oft-cited works as Design Patterns by the "Gang of Four", Booch's Object-Oriented Analysis and Design with Applications, and Object-Oriented Modeling and Design by Rumbaugh et al. Obviously many books attempt to explain the OO paradigm. Specifically I want one that is: 1.) interesting, 2.) informed, and 3.) insightful.
That's why I'm glad I chose this book. It's unmistakably for serious readers, and not as easily accessible or "witty" as a few others. On the other hand, if you want to encounter *many* useful concepts and suggestions from an authoritative source, then I can't imagine a better choice than Applying UML and Patterns. I've read it cover-to-cover once, and have already begun referring back to it for my own purposes.
Sometimes it's useful to understand the author's perspective, to know if you will learn anything useful from their books. Craig Larman is obviously a proponent of agile risk-driven software development, OOAD, and using the UML sparsely as a communicative tool ("sketching" vs. "blueprinting").
Larman makes a very strong case for his perspective, too. After all, everyone knows requirements evolve and change over time, as does design. So why not adopt a process that accomodates this? Similarly, the UML is potentially a complicated language, but why get caught up on notation? The point is to communicate something of value, especially during design, when collaborative decisions must be made - leave the rest to CASE tools. Don't be scared of the Unified Process either, as it provides a great context in which to discuss business processes and risk-driven software development, even if you never explicitly use it.
By the time you finish this book you will: have a good overview of iterative and agile software development, know aspects of the unified process, know the basics of the OO paradigm, know how to assign responsibilities to objects, have been exposed to the most common design patterns, have encountered a few analysis patterns, and have a wealth of tips and suggestions to draw from in your own work.
All of this is presented in the context of a case study on a fictional point-of-sale system. The book slightly favors Java in its examples, but as these are fairly sparse and generally brief, it should be easy enough to follow for those familiar with C++ or C#. The author tries to note whenever choice of language has a significant impact.
Even at nearly 40 chapters, I wish the book were longer, as Larman's writing style is coherent and enjoyable. You'll likely find yourself wanting to know more about software architecture or the details of certain patterns, and luckily the book is full of citations and suggested reading material.
It's a great place to start for students and professionals, anyone who wants to pick up OOAD. If you only want a reference on patterns, then this is probably not the book for you. It doesn't go into great detail about the more complex patterns. Therefor it's recommended that you own some of the classic patterns literature. Likewise if you primarily need a reference on UML, I'd recommend Martin Fowler's excellent UML Distilled. Again, the bibliography of Applying UML and Patterns is an abundant source of related works, for those digging a bit deeper.
A straight forward introduction to OOAD and UML (2009-02-07)
Whether you are looking for understanding the concepts of OOAD or simply understanding what UML can provide to your software designs, this book is an excellent option. Goods practical explanations and a bunch of easy-to-understand examples.
A Legendary title - A must read for any OO Software Developer (2009-01-22)
Coming from a backgroud of legacy application development using procedural languages for about 6 years, I did quite a bit of research on what is the right way to get baptised in the OO world. I have read some OO language books (C# in particular). Those books seem to scratch the surface and just talk about WHAT is it and left me wanting for more details and more example oriented material when it comes to WHY and HOW to do it in the OO way. Then I came accross this book. After reading half way through it, I can fairly say that this is mother of all the books that I have read in my journey to learn the OOA/D concepts. I wish I had known about it much earlier.
The book starts from a forest view of OO software development, stresses on the role a UML should and should not play in your OOA/D, the Agile methodologies and iterative development and then slowly progresses into the finer details of GRASP patterns for OOA/D which are fundamental to any OO design and development.
I'm in no way implying that this book is for beginners getting to know the OOA/D, this book is applicable to both Novice and Experience developers alike without stressing on a specific technology.
I have heard of some books by Martin Fowler and the GoF. However, in my opinion the OO Design Patterns and Architecural ideas should be a logical next step after grasping the basic OOA/D principles.
ALL in ALL it is a legendary title and shall be there on my shelf for ever.
Thank you! (2009-01-13)
Great service! Purchased the book as a gift. Gift receiver asked for this book and is working through it.
An introduction of philosophy for programmers/managers (2008-12-01)
One sentence summary:
Highly recommended for project managers and programmers who does more than coding.
In general:
This is a great book for introducing Object Oriented Analysis and Desisgn (OOA/D). This book is especially useful if a reader has been involved in some real-world programming projects using the Waterfall method, or have asked questions like "Why my customer always change the requirement".
About the writing:
The language is clear to understand even for non-native English speakers. I especially like the the slide-like way of presenting the current chapter's purpose with a view of the big picture of OOA/D.
Leave a Reply