Applying UML and Patterns An Introduction to Object-Oriented Analysis and Design and Iterative Development

by Larman, Craig

• ISBN13: 9780131489066
• ISBN10: 0131489062
• Edition: 3rd
• Format: Hardcover
• Copyright: 2004-10-20
• Publisher: Pearson

Summary

This third edition again delivers a clear path for students and professionals to learn and apply object-oriented analysis and design.

Author Biography

Craig Larman serves as chief scientist at Valtech

Table of Contents

Foreword	xix
Preface	xxi
Part I Introduction
Object-Oriented Analysis and Design	3	(14)
What Will You Learn? Is it Useful?	3	(3)
The Most Important Learning Goal?	6	(1)
What is Analysis and Design?	6	(1)
What is Object-Oriented Analysis and Design?	7	(1)
A Short Example	8	(3)
What is the UML?	11	(3)
Visual Modeling is a Good Thing	14	(1)
History	15	(1)
Recommended Resources	16	(1)
Iterative, Evolutionary, and Agile	17	(24)
What is the UP? Are Other Methods Complementary?	18	(1)
What is Iterative and Evolutionary Development?	19	(4)
What About the Waterfall Lifecycle?	23	(2)
How to do Iterative and Evolutionary Analysis and Design?	25	(2)
What is Risk-Driven and Client-Driven Iterative Planning?	27	(1)
What are Agile Methods and Attitudes?	27	(3)
What is Agile Modeling?	30	(1)
What is an Agile UP?	31	(2)
Are There Other Critical UP Practices?	33	(1)
What are the UP Phases?	33	(1)
What are the UP Disciplines?	34	(3)
How to Customize the Process? The UP Development Case	37	(1)
You Know You Didn't Understand Iterative Development or the UP When	38	(1)
History	39	(1)
Recommended Resources	40	(1)
Case Studies	41	(6)
What is and isn't Covered in the Case Studies?	41	(2)
Case Study Strategy: Iterative Development + Iterative Learning	43	(1)
Case One: The NextGen POS System	43	(1)
Case Two: The Monopoly Game System	44	(3)
Part II Inception
Inception is Not the Requirements Phase	47	(6)
What is Inception?	48	(1)
How Long is Inception?	49	(1)
What Artifacts May Start in Inception?	49	(2)
You Know You Didn't Understand Inception When	51	(1)
How Much UML During Inception?	51	(2)
Evolutionary Requirements	53	(8)
Definition: Requirements	54	(1)
Evolutionary vs. Waterfall Requirements	54	(2)
What are Skillful Means to Find Requirements?	56	(1)
What are the Types and Categories of Requirements?	56	(2)
How are Requirements Organized in UP Artifacts?	58	(1)
Does the Book Contain Examples of These Artifacts?	58	(1)
Recommended Resources	59	(2)
Use Cases	61	(40)
Example	63	(1)
Definition: What are Actors, Scenarios, and Use Cases?	63	(1)
Use Cases and the Use-Case Model	64	(1)
Motivation: Why Use Cases?	64	(1)
Definition: Are Use Cases Functional Requirements?	65	(1)
Definition: What are Three Kinds of Actors?	66	(1)
Notation: What are Three Common Use Case Formats?	66	(1)
Example: Process Sale, Fully Dressed Style	67	(5)
What do the Sections Mean?	72	(6)
Notation: Are There Other Formats? A Two-Column Variation	78	(2)
Guideline: Write in an Essential UI-Free Style	80	(1)
Guideline: Write Terse Use Cases	81	(1)
Guideline: Write Black-Box Use Cases	81	(1)
Guideline: Take an Actor and Actor-Goal Perspective	82	(1)
Guideline: How to Find Use Cases	82	(5)
Guideline: What Tests Can Help Find Useful Use Cases?	87	(2)
Applying UML: Use Case Diagrams	89	(3)
Applying UML: Activity Diagrams	92	(1)
Motivation: Other Benefits of Use Cases? Requirements in Context	92	(1)
Example: Monopoly Game	93	(2)
Process: How to Work With Use Cases in Iterative Methods?	95	(4)
History	99	(1)
Recommended Resources	99	(2)
Other Requirements	101	(22)
How Complete are these Examples?	102	(1)
Guideline: Should We Analyze These Thoroughly During Inception?	102	(1)
Guideline: Should These Artifacts be at the Project Website?	103	(1)
NextGen Example: (Partial) Supplementary Specification	104	(3)
Commentary: Supplementary Specification	107	(2)
NextGen Example: (Partial) Vision	109	(2)
Commentary: Vision	111	(4)
NextGen Example: A (Partial) Glossary	115	(1)
Commentary: Glossary (Data Dictionary)	115	(1)
NextGen Example: Business Rules (Domain Rules)	116	(1)
Commentary: Domain Rules	117	(1)
Process: Evolutionary Requirements in Iterative Methods	118	(1)
Recommended Resources	119	(4)
Part III Elaboration Iteration 1 --- Basics
Iteration 1---Basics	123	(8)
Iteration 1 Requirements and Emphasis: Core OOA/D Skills	124	(2)
Process: Inception and Elaboration	126	(4)
Process: Planning the Next Iteration	130	(1)
Domain Models	131	(42)
Example	133	(1)
What is a Domain Model?	134	(3)
Motivation: Why Create a Domain Model?	137	(2)
Guideline: How to Create a Domain Model?	139	(1)
Guideline: How to Find Conceptual Classes?	139	(4)
Example: Find and Draw Conceptual Classes	143	(1)
Guideline: Agile Modeling---Sketching a Class Diagram	144	(1)
Guideline: Agile Modeling---Maintain the Model in a Tool?	144	(1)
Guideline: Report Objects---Include `Receipt' in the Model?	145	(1)
Guideline: Think Like a Mapmaker; Use Domain Terms	145	(1)
Guideline: How to Model the Unreal World?	146	(1)
Guideline: A Common Mistake with Attributes vs. Classes	146	(1)
Guideline: When to Model with `Description' Classes?	147	(2)
Associations	149	(7)
Example: Associations in the Domain Models	156	(2)
Attributes	158	(8)
Example: Attributes in the Domain Models	166	(2)
Conclusion: Is the Domain Model Correct?	168	(1)
Process: Iterative and Evolutionary Domain Modeling	169	(1)
Recommended Resources	170	(3)
System Sequence Diagrams	173	(8)
Example: NextGen SSD	175	(1)
What are System Sequence Diagrams?	176	(1)
Motivation: Why Draw an SSD?	176	(1)
Applying UML: Sequence Diagrams	177	(1)
What is the Relationship Between SSDs and Use Cases?	177	(1)
How to Name System Events and Operations?	178	(1)
How to Model SSDs Involving Other External Systems?	178	(1)
What SSD Information to Place in the Glossary?	179	(1)
Example: Monopoly SSD	179	(1)
Process: Iterative and Evolutionary SSDs	180	(1)
History and Recommended Resources	180	(1)
Operation Contracts	181	(14)
Example	183	(1)
Definition: What are the Sections of a Contract?	183	(1)
Definition: What is a System Operation?	183	(1)
Definition: Postconditions	184	(3)
Example: enterltem Postconditions	187	(1)
Guideline: Should We Update the Domain Model?	188	(1)
Guideline: When Are Contracts Useful?	188	(1)
Guideline: How to Create and Write Contracts	189	(1)
Example: NextGen POS Contracts	190	(1)
Example: Monopoly Contracts	191	(1)
Applying UML: Operations, Contracts, and the OCL	191	(2)
Process: Operation Contracts Within the UP	193	(1)
History	193	(1)
Recommended Resources	194	(1)
Requirements to Design---Iteratively	195	(2)
Iteratively Do the Right Thing, Do the Thing Right	196	(1)
Provoking Early Change	196	(1)
Didn't All That Analysis and Modeling Take Weeks To Do?	196	(1)
Logical Architecture and UML Package Diagrams	197	(16)
Example	199	(1)
What is the Logical Architecture? And Layers?	199	(1)
What Layers are the Focus in the Case Studies?	200	(1)
What is Software Architecture?	200	(1)
Applying UML: Package Diagrams	201	(1)
Guideline: Design with Layers	202	(7)
Guideline: The Model-View Separation Principle	209	(1)
What's the Connection Between SSDs, System Operations, and Layers?	210	(1)
Example: NextGen Logical Architecture and Package Diagram	211	(1)
Example: Monopoly Logical Architecture?	212	(1)
Recommended Resources	212	(1)
On to Object Design	213	(8)
Agile Modeling and Lightweight UML Drawing	214	(1)
UML Case Tools	215	(1)
How Much Time Spent Drawing UML Before Coding?	215	(1)
Designing Objects: What are Static and Dynamic Modeling?	216	(1)
The Importance of Object Design Skill over UML Notation Skill	217	(1)
Other Object Design Techniques: CRC Cards	218	(3)
UML Interaction Diagrams	221	(28)
Sequence and Communication Diagrams	222	(3)
Novice UML Modelers Don't Pay Enough Attention to Interaction Diagrams!	225	(1)
Common UML Interaction Diagram Notation	226	(1)
Basic Sequence Diagram Notation	227	(13)
Basic Communication Diagram Notation	240	(9)
UML Class Diagrams	249	(22)
Applying UML: Common Class Diagram Notation	250	(1)
Definition: Design Class Diagram	251	(1)
Definition: Classifier	251	(1)
Ways to Show UML Attributes: Attribute Text and Association Lines	252	(4)
Note Symbols: Notes, Comments, Constraints, and Method Bodies	256	(1)
Operations and Methods	256	(2)
Keywords	258	(1)
Stereotypes, Profiles, and Tags	259	(1)
UML Properties and Property Strings	260	(1)
Generalization, Abstract Classes, Abstract Operations	260	(1)
Dependency	260	(3)
Interfaces	263	(1)
Composition Over Aggregation	264	(1)
Constraints	265	(1)
Qualified Association	265	(1)
Association Class	266	(1)
Singleton Classes	266	(1)
Template Classes and Interfaces	267	(1)
User-Defined Compartments	268	(1)
Active Class	269	(1)
What's the Relationship Between Interaction and Class Diagrams?	269	(2)
Grasp: Designing Objects with Responsibilities	271	(50)
UML versus Design Principles	272	(1)
Object Design: Example Inputs, Activities, and Outputs	272	(4)
Responsibilities and Responsibility-Driven Design	276	(1)
Grasp: A Methodical Approach to Basic OO Design	277	(1)
What's the Connection Between Responsibilities, Grasp, and UML Diagrams?	277	(1)
What are Patterns?	278	(3)
Where are We Now?	281	(1)
A Short Example of Object Design with Grasp	281	(10)
Applying Grasp to Object Design	291	(1)
Creator	291	(3)
Information Expert (or Expert)	294	(5)
Low Coupling	299	(3)
Controller	302	(12)
High Cohesion	314	(5)
Recommended Resources	319	(2)
Object Design Examples with Grasp	321	(42)
What is a Use Case Realization?	322	(2)
Artifact Comments	324	(3)
What's Next?	327	(1)
Use Case Realizations for the NextGen Iteration	327	(22)
Use Case Realizations for the Monopoly Iteration	349	(11)
Process: Iterative and Evolutionary Object Design	360	(2)
Summary	362	(1)
Designing for Visibility	363	(6)
Visibility Between Objects	363	(1)
What is Visibility?	364	(5)
Mapping Designs to Code	369	(16)
Programming and Iterative, Evolutionary Development	370	(1)
Mapping Designs to Code	371	(1)
Creating Class Definitions from DCDs	371	(1)
Creating Methods from Interaction Diagrams	372	(2)
Collection Classes in Code	374	(1)
Exceptions and Error Handling	374	(1)
Defining the Sale.makeLineItem Method	375	(1)
Order of Implementation	375	(1)
Test-Driven or Test-First Development	376	(1)
Summary of Mapping Designs to Code	376	(1)
Introduction to the NextGen POS Program Solution	377	(3)
Introduction to the Monopoly Program Solution	380	(5)
Test-Driven Development and Refactoring	385	(12)
Test-Driven Development	386	(3)
Refactoring	389	(4)
Recommended Resources	393	(4)
Part IV Elaboration Iteration 2 --- More Patterns
UML Tools and UML as Blueprint	397	(4)
Forward, Reverse, and Round-Trip Engineering	398	(1)
What is a Common Report of Valuable Features?	398	(1)
What to Look For in a Tool?	399	(1)
If Sketching UML, How to Update the Diagrams After Coding?	399	(1)
Recommended Resources	400	(1)
Quick Analysis Update	401	(6)
Case Study: NextGen POS	401	(2)
Case Study: Monopoly	403	(4)
Iteration 2---More Patterns	407	(6)
From Iteration 1 to 2	408	(1)
Iteration-2 Requirements and Emphasis: Object Design and Patterns	409	(4)
Grasp: More Objects with Responsibilities	413	(22)
Polymorphism	414	(7)
Pure Fabrication	421	(5)
Indirection	426	(1)
Protected Variations	427	(8)
Applying GoF Design Patterns	435	(40)
Adapter (GoF)	436	(2)
Some Grasp Principles as a Generalization of Other Patterns	438	(2)
``Analysis'' Discoveries During Design: Domain Model	440	(1)
Factory	440	(2)
Singleton (GoF)	442	(4)
Conclusion of the External Services with Varying Interfaces Problem	446	(1)
Strategy (GoF)	447	(5)
Composite (GoF) and Other Design Principles	452	(9)
Facade (GoF)	461	(2)
Observer/Publish-Subscribe/Delegation Event Model (GoF)	463	(8)
Conclusion	471	(1)
Recommended Resources	471	(4)
Part V Elaboration Iteration 3 --- Intermediate Topics
Iteration 3---Intermediate Topics	475	(2)
NextGen POS	476	(1)
Monopoly	476	(1)
UML Activity Diagrams and Modeling	477	(8)
Example	477	(1)
How to Apply Activity Diagrams?	478	(3)
More UML Activity Diagram Notation	481	(1)
Guidelines	482	(1)
Example: NextGen Activity Diagram	483	(1)
Process: Activity Diagrams in the UP	483	(1)
Background	484	(1)
UML State Machine Diagrams and Modeling	485	(8)
Example	486	(1)
Definitions: Events, States, and Transitions	486	(1)
How to Apply State Machine Diagrams?	487	(2)
More UML State Machine Diagram Notation	489	(1)
Example: UI Navigation Modeling with State Machines	490	(1)
Example: NextGen Use Case State Machine Diagram	491	(1)
Process: State Machine Diagrams in the UP	492	(1)
Recommended Resources	492	(1)
Relating Use Cases	493	(8)
The include Relationship	494	(3)
Terminology: Concrete, Abstract, Base, and Addition Use Cases	497	(1)
The extend Relationship	497	(2)
The generalize Relationship	499	(1)
Use Case Diagrams	499	(2)
More SSDs and Contracts	501	(6)
NextGen POS	501	(6)
Domain Model Refinement	507	(34)
New Concepts for the NextGen Domain Model	508	(1)
Generalization	509	(2)
Defining Conceptual Superclasses and Subclasses	511	(3)
When to Define a Conceptual Subclass?	514	(2)
When to Define a Conceptual Superclass?	516	(1)
NextGen POS Conceptual Class Hierarchies	516	(3)
Abstract Conceptual Classes	519	(2)
Modeling Changing States	521	(1)
Class Hierarchies and Inheritance in Software	522	(1)
Association Classes	522	(3)
Aggregation and Composition	525	(2)
Time Intervals and Product Prices---Fixing an Iteration 1 ``Error''	527	(1)
Association Role Names	528	(1)
Roles as Concepts versus Roles in Associations	529	(1)
Derived Elements	530	(1)
Qualified Associations	531	(1)
Reflexive Associations	532	(1)
Using Packages to Organize the Domain Model	532	(6)
Example: Monopoly Domain Model Refinements	538	(3)
Architectural Analysis	541	(18)
Process: When Do We Start Architectural Analysis?	542	(1)
Definition: Variation and Evolution Points	542	(1)
Architectural Analysis	543	(1)
Common Steps in Architectural Analysis	544	(1)
The Science: Identification and Analysis of Architectural Factors	545	(3)
Example: Partial NextGen POS Architectural Factor Table	548	(1)
The Art: Resolution of Architectural Factors	549	(7)
Summary of Themes in Architectural Analysis	556	(1)
Process: Iterative Architecture in the UP	556	(2)
Recommended Resources	558	(1)
Logical Architecture Refinement	559	(20)
Example: NextGen Logical Architecture	560	(5)
Collaborations with the Layers Pattern	565	(6)
Other Layer Pattern Issues	571	(5)
Model-View Separation and ``Upward'' Communication	576	(1)
Recommended Resources	577	(2)
More Object Design with GoF Patterns	579	(34)
Example: NextGen POS	580	(1)
Failover to Local Services; Performance with Local Caching	580	(5)
Handling Failure	585	(6)
Failover to Local Services with a Proxy (GoF)	591	(4)
Designing for Non-Functional or Quality Requirements	595	(1)
Accessing External Physical Devices with Adapters	595	(2)
Abstract Factory (GoF) for Families of Related Objects	597	(3)
Handling Payments with Polymorphism and Do It Myself	600	(7)
Example: Monopoly	607	(3)
Conclusion	610	(3)
Package Design	613	(8)
Package Organization Guidelines	614	(6)
Recommended Resources	620	(1)
UML Deployment and Component Diagrams	621	(4)
Deployment Diagrams	621	(2)
Component Diagrams	623	(2)
Designing a Persistence Framework with Patterns	625	(30)
The Problem: Persistent Objects	626	(1)
The Solution: A Persistence Service from a Persistence Framework	627	(1)
Frameworks	627	(1)
Requirements for the Persistence Service and Framework	628	(1)
Key Ideas	628	(1)
Pattern: Representing Objects as Tables	629	(1)
UML Data Modeling Profile	629	(1)
Pattern: Object Identifier	630	(1)
Accessing a Persistence Service with a Facade	631	(1)
Mapping Objects: Database Mapper or Database Broker Pattern	632	(2)
Framework Design with the Template Method Pattern	634	(1)
Materialization with the Template Method Pattern	634	(6)
Configuring Mappers with a MapperFactory	640	(1)
Pattern: Cache Management	641	(1)
Consolidating and Hiding SQL Statements in One Class	641	(1)
Transactional States and the State Pattern	642	(3)
Designing a Transaction with the Command Pattern	645	(2)
Lazy Materialization with a Virtual Proxy	647	(4)
How to Represent Relationships in Tables	651	(1)
PersistentObject Superclass and Separation of Concerns	652	(1)
Unresolved Issues	652	(3)
Documenting Architecture: UML & the N+1 View Model	655	(18)
The SAD and Its Architectural Views	656	(3)
Notation: The Structure of a SAD	659	(1)
Example: A NextGen POS SAD	660	(5)
Example: A Jakarta Struts SAD	665	(4)
Process: Iterative Architectural Documentation	669	(1)
Recommended Resources	669	(4)
Part VI Special Topics
More on Iterative Development and Agile Project Management	673	(10)
How to Plan an Iteration?	674	(1)
Adaptive versus Predictive Planning	674	(2)
Phase and Iteration Plans	676	(1)
How to Plan Iterations with Use Cases and Scenarios?	676	(2)
The (In)Validity of Early Estimates	678	(2)
Organizing Project Artifacts	680	(1)
You Know You Didn't Understand Iterative Planning When	681	(1)
Recommended Resources	681	(2)
Bibliography	683	(6)
Glossary	689	(6)
Index	695

Excerpts

Thank you for reading this book! If I can answer a question, or for consulting or coaching a team (in OOA/D, UML, modeling, iterative and agile methods), please contact me atwww.craiglarman.com. This is a practical introduction to object-oriented analysis and design (OOA/D), and to related aspects of iterative development. I am grateful that the previous editions were extremely popular worldwide. I sincerely thank all the readers! Here is how the book will benefit you. Design WellFirst, the use of object technology is widespread, so mastery of OOA/D is critical for you to succeed in the software world. Learn a Process RoadmapSecond, if you are new to OOA/D, you're understandably challenged about how to proceed; this book presents a well-defined iterative roadmapan agile approach to the Unified Processso that you can move in a step-by-step process from requirements to code. Learn UML for ModelingThird, the Unified Modeling Language (UML) has emerged as the standard notation for modeling, so it's useful to be able to apply it skillfully. Learn Design PatternsFourth, design patterns communicate the "best practice" idioms OO design experts apply. You will learn to apply design patterns, including the popular "Gang-of-Four" patterns, and the GRASP patterns. Learning and applying patterns will accelerate your mastery of analysis and design. Learn from ExperienceFifth, the structure and emphasis in this book are based on years of experience in education 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 StudySixth, it exhaustively examines two case studiesto realistically illustrate the entire OOA/D process, and goes deeply into thorny details of the problem. Design to Code, with TDD & RefactoringSeventh, it shows how to map object design artifacts to code in Java. It also introduces test-driven development and refactor. Layered ArchitectureEighth, it explains how to design a layered architecture and relate the UI layer to domain and technical services layers. Design FrameworksFinally, it shows you how to design an OO framework and applies this to the creation of a framework for persistent storage in a database. Educator and Web Resources You may find related articles of interest atwww.craiglarman.com. Hundreds, if not thousands, of teachers use the book worldwide; it's been translated into at least ten languages. At my website there are a variety of educator resources, including all the book figures organized into Microsoft PowerPoint presentations, sample OOA/D PowerPoint presentations, and more. If you're an educator, please contact me for resources. I am collecting material from existing educators using the book, to share with other educators. If you have anything to share, please contact me. Intended Audiencean Introduction! This book is an introductionto 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: Developers and students with some experience in OO programming, but who are newor relatively newto OOA/D. Students in computer science or software engineering courses studying object technology. Those with some familiarity in OOA/D who want to learn the UML notation, apply patterns, or who want to deepen their analysis and design skills. Prerequisites Some prerequisites are assumedand necessaryto benefit from this book: Knowledge and experience in an object-oriented programming language such as Java, C#, C++, or Python. Knowledge of fundamental OO concepts, such as class, instance, interface, polymorphism, encapsulation, and inheritance. Fundamental OO concepts are not defined. Java Examples, But... In general, the book presents code examples in Java due to its widespread familiarity. However, the ideas presented are applicable to mostif not allobject-oriented technologies, including C#, Python, and so on. Book Organization 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. The inception phase chapters introduce the basics of requirements analysis. Iteration 1 introduces fundamental OOA/D and how to assign responsibilities to objects. Iteration 2 focuses on object design, especially on introducing some high-use "design patterns." Iteration 3 introduces a variety of subjects, such as architectural analysis and framework design.