- Hardcover: 507 pages
- Publisher: Prentice Hall PTR; 1st edition (October 30, 1997)
- Language: English
- ISBN-10: 0137488807
- ISBN-13: 978-0137488803
- Product Dimensions: 8.3 x 1.1 x 10.3 inches
- Shipping Weight: 2.6 pounds (View shipping rates and policies)
- Average Customer Review: 131 customer reviews
- Amazon Best Sellers Rank: #2,728,947 in Books (See Top 100 in Books)
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Applying UML and Patterns 1st Edition
Use the Amazon App to scan ISBNs and compare prices.
Fulfillment by Amazon (FBA) is a service we offer sellers that lets them store their products in Amazon's fulfillment centers, and we directly pack, ship, and provide customer service for these products. Something we hope you'll especially enjoy: FBA items qualify for FREE Shipping and Amazon Prime.
If you're a seller, Fulfillment by Amazon can help you increase your sales. We invite you to learn more about Fulfillment by Amazon .
There is a newer edition of this item:
The Amazon Book Review
Author interviews, book reviews, editors picks, and more. Read it now
Frequently bought together
Customers who viewed this item also viewed
Written for the developer with previous programming and design experience, Applying UML and Patterns combines UML, software patterns, and Java to illustrate the author's own design strategy. Though author Craig Larman sometimes relies heavily on the jargon of software engineering, there's no doubt that his book contains some immediately useful ideas on software design, using the latest and greatest in software-engineering research.
This book begins by outlining a basic process of software design using iterative, object-oriented techniques. The case study used for this text is a point-of-sale (POS) system, a helpful real-world example. The book constructs use case diagrams and basic conceptual and class models for this system. The author then adds sequence diagrams to show how the POS system will do its processing and collaboration diagrams to show how objects will interact with one another. The author uses standard UML diagrams to document the design.
When it comes to refining class design, the author's experience with patterns really shines. His General Responsibility Assignment Software Patterns (GRASP) suggest guidelines for designing classes that work together effectively. Larman believes that the ability to assign responsibilities to classes effectively is one of the most important aspects of good object-oriented design. His patterns allow this to happen and provide an interesting contribution to the design process. (The author also introduces more widely used software patterns to enhance the design process.)
When it comes to coding the design, Java is the programming language of choice for this text. Further chapters discuss how to refine an initial design using an iterative process of software engineering. While it's unlikely that readers will adopt Larman's approach to software design in its entirety, his guidelines--and application of patterns to class design, all documented using UML--make this a worthwhile text for the more experienced reader. --Richard Dragan
From the Inside Flap
Congratulations and thank you for reading this book! You hold in your hands a practical guide and roadmap through the landscape of object-oriented analysis and design. Here is how it will benefit you.
Design robust and maintainable object systems.
First, the use of object technology is proliferating in the development of software-even more so with the widespread adoption of Java-and mastery of object-oriented analysis and design is critical for you to create robust and maintainable object-oriented systems. It also opens up new opportunities for you as an architect, analyst, and designer.
Follow a roadmap through requirements, analysis, design and coding.
Second, if you are new to object-oriented analysis and design, you are understandably challenged about how to proceed through this complex subject; this book presents a well-defined activity roadmap so that you can move in a step-by-step process from requirements to code.
Use the UML to illustrate analysis and design models.
Third, the Unified Modeling Language (UML) has emerged as the standard notation for modeling; so it is useful for you to be conversant in it. This book teaches the skills of object-oriented analysis and design using the UML notation.
Improve designs by applying the "gang-of-four" and GRASP design patterns.
Fourth, design patterns communicate the "best practice" idioms and solutions that object-oriented design experts apply in order to create systems. In this book you will learn to apply design patterns, including the popular "gang-of-four" patterns, and most importantly the GRASP patterns which communicate very fundamental principles of responsibility assignment in object-oriented design. Learning and applying patterns will accelerate your mastery of analysis and design.
Learn efficiently by following a refined presentation.
Fifth, the structure and emphasis in this book is based on years of experience in training and mentoring people in the art of object-oriented analysis and design. It reflects that experience by providing a refined, proven, and efficient approach to learning the subject so your investment in reading and learning is optimized.
Learn from a realistic exercise.
Sixth, it exhaustively examines a single case study-to realistically illustrate the entire object-oriented analysis and design process, and goes deeply into thorny details of the problem; it is a realistic exercise.
Translate to code.
Seventh, it shows how to map object-oriented design artifacts to code in Java.
Design a layered architecture.
Eighth, it explains how to design a layered architecture and relate the graphical user interface layer to domain and system services layers. This is a matter of practical importance that is often overlooked.
Design a framework.
Finally, it shows you how to design an object-oriented framework and specifically applies this to the creation of a framework for persistent storage in a database.
The overarching objective is this:
Help students and developers create better object-oriented designs through the application of a set of explainable principles and heuristics.
By studying and applying the information and techniques presented here, you will become more adept at understanding a problem in terms of its processes and concepts, and designing a solid solution using objects.
This book is for the following audience:
Developers with experience in an object-oriented programming language, but who are new-or relatively new-to object-oriented analysis and design. Students in computer science or software engineering courses studying object technology. Those with some familiarity in object-oriented analysis and design who want to learn the Unified Modeling Language notation, apply patterns, or who want to sharpen and deepen their analysis and design skills.
Some prerequisite knowledge is assumed-and necessary-to benefit from this book:
Knowledge and experience in an object-oriented programming language such as C++, Java, or Smalltalk. Knowledge of fundamental object technology concepts, such as class, instance, interface, polymorphism, encapsulation, and inheritance.
Fundamental object technology concepts are not defined.
The overall strategy in the organization of this book is that object-oriented analysis and design topics are introduced in an order similar to that of a software development project running across two iterative development cycles. The first development cycle introduces analysis and design. In the second development cycle, new analysis and design topics are presented and existing ones are explored more deeply.
Figure 1. The organization of the book follows that of a development project.
Motivation for this Book
Object technology holds great promise, but its potential will not be fully realized without the appropriate skills. It is my goal to promote the successful adoption of object technology through the skillful activity of object-oriented analysis and design, and to promote the acquisition of related abilities, because I observe these are critical for the successful creation and maintenance of significant systems.
Thanks to all the users and students of the UML and object-oriented analysis and design who I have tried to assist; they are my best teachers.
Special thanks to the reviewers of this book (or portions), including Kent Beck, Jens Coldewey, Clay Davis, Tom Heruska, Luke Hohmann, David Norris, David Nunn, Brett Schuchert, and the entire Mercury team. Thanks to Grady Booch for reviewing a tutorial related to this work, and to Jim Rumbaugh for some feedback related to the relationship between the UML and process.
For insightful feedback on process and models, thanks to Todd Girvin, John Hebley, Tom Heruska, David Norris, David Nunn, Charles Rego, and Raj Wall.
Many thanks to Grady Booch, Ivar Jacobson, and Jim Rumbaugh for the development of the Unified Modeling Language; creating an open, standard notation in the current Tower of Babel environment is most welcome. In addition, I have learned much from their teachings.
Thanks to my colleague Jef Newsom for providing the case study Java solution. Thanks to my publisher at Prentice-Hall, Paul Becker, for believing that this would be a worthwhile project.
Finally, a special thanks to Graham Glass for opening a door.
About the Author
Craig Larman has a B.Sc. and M.Sc. in computing science and since 1978 has been developing large and small software systems on platforms ranging from mainframes to microcomputers, using software technologies ranging from 4GLs to logic programming to object-oriented programming.
In the early 1980s he fell in love with artificial intelligence and knowledge systems programming techniques, from which he received his first exposure to object-oriented programming (in Lisp). He has taught and worked with object-oriented programming in Lisp since 1984, Smalltalk since 1986, C++ since 1991, and recently Java, in conjunction with teaching a variety of object-oriented analysis and design methods. He has assisted over 2,000 students in learning object technology topics.
He is currently Principal Instructor at ObjectSpace, a company specializing in distributed computing, agents, and object technology.
Craig may be reached at clarman@acm
Top customer reviews
There was a problem filtering reviews right now. Please try again later.
This book hit me a bit by surprise. As I get more and more into OOA/D I found that learning the UML would probably be very beneficial. I decided to go ahead and pick up a UML primer in hopes of learning everything about the UML. I decided on this book. This books main focus isn't exactly on the UML (although you learn a great deal about that too). Instead this book focuses more on OOA/D theory and the unified process to software development. You learn all about how to create software in iterations rather then the common waterfall method. In a nutshell, you learn that it's not really such a good idea to plan out every aspect of your system, do all of the architecture and then implement (this is known as the waterfall method). Instead you learn about how to create software in iterations, treat each iteration as its own project and build to adapt for potential changes.
Along the way of learning OOA/D, the unified process and design theory, you also learn how to create the most common UML diagrams. This includes use case, domain model, interaction, class diagrams and others. Craig Larman also touches up on other topics such as design patterns, visual thinking and much much more. There is a whole lot of ground covered in this book.
While I was reading this book I was constantly reminded of Steve McConnell's writing style (in case you didn't know, Steve McConnell is the author of Code Complete 1st and 2nd edition, Rapid Development and a few other epic software titles). The writing style is very similar, which is a huge plus - as I am a big fan of Steve McConnell.
I highly recommend this title to all software developers. This is one of those eye-openers that will make a few flickering light bulbs shine brightly. If you are a fan of Steve McConnell books then I am almost 100% sure you will benefit from this exceptional title. Actually, whilst reading Steve McConnell's Code Complete I remember wishing Steve would write a book focusing on OOA/D. This is "almost" that book.
1. The book is for everybody who wants to be walked through a OO process and shown how to implement consumable artifacts, then carry them foward into the next phase. I would not recommend this for absolute beginners, just beginners to OOAD.
2. Learn UML from the source? The UML User Guide is not that good of a book. Fowler's UML distilled is excellent but he's not the source.
3. Learn Design Patterns from GoF? This book is meant to address fundamentals. GRASP is applied before GoF. Besides this is an intro to OOAD, the GoF book is far beyond an introduction and on applies to OOD.
4. The reviewer said that Craig uses patterns as a comercial tactic. Obviously this person doesn't understand what patterns are. It serves as a method of communication. When you say, "Which pattern did you use?" it allows people to coomunicate based on expert advice instead of their own opinion. Anti-Patterns aren't like Design Patterns but they are patterns. GRASP patterns are the best way I've seen to explain fundamental OO concepts.
5. AS far as the comment, "in the small", this is an introduction! It walks you through a sample process, since it is an intro to OOAD, it walks you through the MOST IMPORTANT aspects, which includes use cases, conceptual modeling, and reusable design techniques.
6. I really don't know what to say about the contracts. I typically don't use them, and wouldn't get to hung up about it.
This review turned out to be more of a review on a previous review. Let me end that section with:
Why is this expert in OOAD reading an intro book? How could somebody who needs an introduction be so critical of one? If you need to read an introduction, it means you don't know all that much, and thus how would you judge it so critically.
For those of you interested. This book is the ultimate classic introduction to OOAD. I read it, then adopted a few different techniques from other authors. I prefer Alistair Cockburn's Use Case style and from what I've heard, Craig Larman likes it to. I would recommend something like this:
Read: Applying UML and Patterns UML Distilled Writing Effective Use Cases then a process book...
- David Roberts