- Shopping Bag ( 0 items )
Ships from: acton, MA
Usually ships in 1-2 business days
Ships from: acton, MA
Usually ships in 1-2 business days
The first edition of Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design quickly emerged as the leading OOA/D introduction; it has been translated into seven 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.
Put simply, the book shows newcomers to OOA/D how to "think in objects." It does so 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, and * the Unified Process. For a more detailed list of topics, please see the accompanying table of contents.
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
This is the book that teaches introductory 00AD by using a single case study throughout the book (for the first edition, often cited as a strong advantage). Since OOAD ideas must be communicated in some language, the popular UML diagramming notation is also taught, as a vehicle for expressing OOAD thoughts.
To invent, you need a good imagination and a pile of junk.
This chapter communicates the principles, using the NextGen POS example, by which an object-oriented designer assigns responsibilities and establishes object interactions—a core skill in object-oriented development.
The assignment of responsibilities and design of collaborations are very important and creative steps during design, either while diagraming or while programming.
The material is intentionally detailed; it attempts to exhaustively illustrate that there is no “magic” or unjustifiable decisions in object design—assignment of responsibilities and the choice of object interactions can be rationally explained and learned.
UML interaction diagrams are a common language to illustrate use-case realizations. And as was explored in the prior chapter, there are principles and patterns of object design, such as Information Expert and Low Coupling, that can be applied during this design work.
To review, Figure 17.20 (near the end of this chapter) illustrates the relationship between some UP artifacts:
In the current iteration we are considering various scenarios and system events such as:
Figure 17.1 Collaboration diagrams and system event message handling.
On the other hand, if sequence diagrams are used, it may be possible to fit all system event messages on the same diagram, as in Figure 17.2....
|1||Object-Oriented Analysis and Design||3|
|2||Iterative Development and the Unified Process||13|
|3||Case Study: The NextGen POS System||29|
|6||Use-Case Model: Writing Requirements in Context||45|
|7||Identifying Other Requirements||83|
|8||From Inception to Elaboration||107|
|9||Use-Case Model: Drawing System Sequence Diagrams||117|
|10||Domain Model: Visualizing Concepts||127|
|11||Domain Model: Adding Associations||153|
|12||Domain Model: Adding Attributes||167|
|13||Use-Case Model: Adding Detail with Operation Contracts||177|
|14||From Requirements to Design in this Iteration||193|
|15||Interaction Diagram Notation||197|
|16||GRASP: Designing Objects with Responsibilities||215|
|17||Design Model: Use-Case Realizations with GRASP Patterns||247|
|18||Design Model: Determining Visibility||279|
|19||Design Model: Creating Design Class Diagrams||285|
|20||Implementation Model: Mapping Designs to Code||301|
|21||Iteration 2 and its Requirements||319|
|22||GRASP: More Patterns for Assigning Responsibilities||325|
|23||Designing Use-Case Realizations with GoF Design Patterns||341|
|24||Iteration 3 and Its Requirements||383|
|25||Relating Use Cases||385|
|27||Refining the Domain Model||411|
|28||Adding New SSDs and Contracts||431|
|29||Modelling Behavior in Statechart Diagrams||437|
|30||Designing the Logical Architecture with Patterns||447|
|31||Organizing the Design and Implementation Model Packages||475|
|32||Introduction to Architectural Analysis and the SAD||485|
|33||Designing More Use-Case Realizing with Objects and Patterns||507|
|34||Designing a Persistence Framework with Patterns||537|
|35||On Drawing and Tools||567|
|36||Introduction to Iterative Planning and Project Issues||575|
|37||Comments on Iterative Development and the UP||589|
|38||More UML Notation||603|
Here is how the book will benefit you.
Design robust and maintainable object systems.
First, the use of object technology has proliferated in the development of software, and mastery of OOA/D is critical for you to create robust and maintainable object systems.
Follow a roadmap through requirements, analysis, design, and coding.
Second, if you are new to OOA/D, you are understandably challenged about how to proceed through this complex subject; this book presents a well-defined roadmap-the Unified Process-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 OOA/D 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 the GRASP patterns which communicate fundamental principles of responsibility assignment in object 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 thousands of people in the art of OOA/D. 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 OOA/D 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 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 technical services layers.
Design a framework.
Finally, it shows you how to design an object-oriented framework and applies this to the creation of a framework for persistent storage in a database.
The overarching objective is this:
Help students and developers create object 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 an introduction to OOA/D, related requirements analysis, and to iterative development with the Unified Process as a sample process; it is not meant as an advanced text. It is for the following audience:
Some prerequisite knowledge is assumed—and necessary—to benefit from this book:
Fundamental object technology concepts are not defined.
In general, the book presents code examples in Java or discusses Java implementations, due to its widespread familiarity. However, the ideas presented are applicable to most—if not all—object-oriented programming languages.
The overall strategy in the organization of this book is that analysis and design topics are introduced in an order similar to that of a software development project running across an "inception" phase (a Unified Process term) followed by three iterations.
www.craiglarman.comfor articles related to object technology, patterns, and process.
While retaining the same core as the first edition, the second is refined in many ways, including:
Craig Larman serves as Director of Process for Valtech, an international consulting company with divisions in Europe, Asia, and North America, specializing in e-business systems development, object technologies, and iterative development with the Unified Process.
Since the mid 1980s, Craig has helped thousands of developers to apply object-oriented programming, analysis, and design, and assisted organizations adopt iterative development practices.
After a failed career as a wandering street musician, he built systems in APL, PL/I, and CICS in the 1970s. Starting in the early 1980s-after a full recovery- he became interested in artificial intelligence (having little of his own), natural language processing, and knowledge representation, and built knowledge systems with Lisp machines, Lisp, Prolog, and Smalltalk. He plays bad lead guitar in his part-time band, the Changing Requirements (it used to be called the Requirements, but some band members changed...).
He holds a B.Sc. and M.Sc. in computer science from Simon Fraser University in Vancouver, Canada.
Craig can be reached at