Foreword |
Preface |
Introduction / Part I: |
Object-Oriented Analysis and Design / 1: |
What Will You Learn? Is it Useful? |
The Most Important Learning Goal? |
What is Analysis and Design? |
What is Object-Oriented Analysis and Design? |
A Short Example |
What is the UML? |
Visual Modeling is a Good Thing |
History |
Recommended Resources |
Iterative, Evolutionary, and Agile / 2: |
What is the UP? Are Other Methods Complementary? |
What is Iterative and Evolutionary Development? |
What About the Waterfall Lifecycle? |
How to do Iterative and Evolutionary Analysis and Design? |
What is Risk-Driven and Client-Driven Iterative Planning? |
What are Agile Methods and Attitudes? |
What is Agile Modeling? |
What is an Agile UP? |
Are There Other Critical UP Practices? |
What are the UP Phases? |
What are the UP Disciplines? |
How to Customize the Process? The UP Development Case |
You Know You Didn't Understand Iterative Development or the UP When... |
Case Studies / 3: |
What is and isn't Covered in the Case Studies? |
Case Study Strategy: Iterative Development + Iterative Learning |
The NextGen POS System / Case 1: |
The Monopoly Game System / Case 2: |
Inception / Part II: |
Inception is Not the Requirements Phase / 4: |
What is Inception? |
How Long is Inception? |
What Artifacts May Start in Inception? |
You Know You Didn't Understand Inception When... |
How Much UML During Inception? |
Evolutionary Requirements / 5: |
Definition: Requirements |
Evolutionary vs. Waterfall Requirements |
What are Skillful Means to Find Requirements? |
What are the Types and Categories of Requirements? |
How are Requirements Organized in UP Artifacts? |
Does the Book Contain Examples of These Artifacts? |
Use Cases / 6: |
Example |
Definition: What are Actors, Scenarios, and Use Cases? |
Use Cases and the Use-Case Model |
Motivation: Why Use Cases? |
Definition: Are Use Cases Functional Requirements? |
Definition: What are Three Kinds of Actors? |
Notation: What are Three Common Use Case Formats? |
Example: Process Sale, Fully Dressed Style |
What do the Sections Mean? |
Notation: Are There Other Formats? A Two-Column Variation |
Guideline: Write in an Essential UI-Free Style |
Guideline: Write Terse Use Cases |
Guideline: Write Black-Box Use Cases |
Guideline: Take an Actor and Actor-Goal Perspective |
Guideline: How to Find Use Cases |
Guideline: What Tests Can Help Find Useful Use Cases? |
Applying UML: Use Case Diagrams |
Applying UML: Activity Diagrams |
Motivation: Other Benefits of Use Cases? Requirements in Context |
Example: Monopoly Game |
Process: How to Work With Use Cases in Iterative Methods? |
Other Requirements / 7: |
How Complete are these Examples? |
Guideline: Should We Analyze These Thoroughly During Inception? |
Guideline: Should These Artifacts be at the Project Website? |
NextGen Example: (Partial) Supplementary Specification |
Commentary: Supplementary Specification |
NextGen Example: (Partial) Vision |
Commentary: Vision |
NextGen Example: A (Partial) Glossary |
Commentary: Glossary (Data Dictionary) |
NextGen Example: Business Rules (Domain Rules) |
Commentary: Domain Rules |
Process: Evolutionary Requirements in Iterative Methods |
Elaboration Iteration 1 - Basics / Part III: |
Iteration 1-Basics / 8: |
Iteration 1 Requirements and Emphasis: Core OOA/D Skills |
Process: Inception and Elaboration |
Process: Planning the Next Iteration |
Domain Models / 9: |
What is a Domain Model? |
Motivation: Why Create a Domain Model? |
Guideline: How to Create a Domain Model? |
Guideline: How to Find Conceptual Classes? |
Example: Find and Draw Conceptual Classes |
Guideline: Agile Modeling-Sketching a Class Diagram |
Guideline: Agile Modeling-Maintain the Model in a Tool? |
Guidelin: Report Objects-Include 'Receipt' in the Model? |
Guideline: Think Like a Mapmaker; Use Domain Terms |
Guideline: How to Model the Unreal World? |
Guideline: A Common Mistake with Attributes vs. Classes |
Guideline: When to Model with 'Description' Classes? |
Associations |
Example: Associations in the Domain Models |
Attributes |
Example: Attributes in the Domain Models |
Conclusion: Is the Domain Model Correct? |
Process: Iterative and Evolutionary Domain Modeling |
System Sequence Diagrams / 10: |
Example: NextGen SSD |
What are System Sequence Diagrams? |
Motivation: Why Draw an SSD? |
Applying UML: Sequence Diagrams |
What is the Relationship Between SSDs and Use Cases? |
How to Name System Events and Operations? |
How to Model SSDs Involving Other External Systems? |
What SSD Information to Place in the Glossary? |
Example: Monopoly SSD |
Process: Iterative and Evolutionary SSDs |
History and Recommended Resources |
Operation Contracts / 11: |
Definition: What are the Sections of a Contract? |
Definition: What is a System Operation? |
Definition: Postconditions |
Example: enterItem Postconditions |
Guideline: Should We Update the Domain Model? |
Guideline: When Are Contracts Useful? |
Guideline: How to Create and Write Contracts |
Example: NextGen POS Contracts |
Example: Monopoly Contracts |
Applying UML: Operations, Contracts, and the OCL |
Process: Operation Contracts Within the UP |
Requirements to Design-Iteratively / 12: |
Iteratively Do the Right Thing, Do the Thing Right |
Provoking Early Change |
Didn't All That Analysis and Modeling Take Weeks To Do? |
Logical Architecture and UML Package Diagrams / 13: |
What is the Logical Architecture? And Layers? |
What Layers are the Focus in the Case Studies? |
What is Software Architecture? |
Applying UML: Package Diagrams |
Guideline: Design with Layers |
Guideline: The Model-View Separation Principle |
What's the Connection Between SSDs, System Operations, and Layers? |
Example: NextGen Logical Architecture and Package Diagram |
Example: Monopoly Logical Architecture? |
On to Object Design / 14: |
Agile Modeling and Lightweight UML Drawing |
UML CASE Tools |
How Much Time Spent Drawing UML Before Coding? |
Designing Objects: What are Static and Dynamic Modeling? |
The Importance of Object Design Skill over UML Notation Skill |
Other Object Design Techniques: CRC Cards |
UML Interaction Diagrams / 15: |
Sequence and Communication Diagrams |
Novice UML Modelers Don't Pay Enough Attention to Interaction Diagrams! |
Common UML Interaction Diagram Notation |
Basic Sequence Diagram Notation |
Basic Communication Diagram Notation |
UML Class Diagrams / 16: |
Applying UML: Common Class Diagram Notation |
Definition: Design Class Diagram |
Definition: Classifier |
Ways to Show UML Attributes: Attribute Text and Association Lines |
Note Symbols: Notes, Comments, Constraints, and Method Bodies |
Operations and Methods |
Keywords |
Stereotypes, Profiles, and Tags |
UML Properties and Property Strings |
Generalization, Abstract Classes, Abstract Operations |
Dependency |
Interfaces |
Composition Over Aggregation |
Constraints |
Qualified Association |
Association Class |
Singleton Classes |
Template Classes and Interfaces |
User-Defined Compartments |
Active Class |
What's the Relationship Between Interaction and Class Diagrams? |
GRASP: Designing Objects with Responsibilities / 17: |
UML versus Design Principles |
Object Design: Example Inputs, Activities, and Outputs |
Responsibilities and Responsibility-Driven Design |
GRASP: A Methodical Approach to Basic OO Design |
What's the Connection Between Responsibilities, GRASP, and UML Diagrams? |
What are Patterns? |
Where are We Now? |
A Short Example of Object Design with GRASP |
Applying GRASP to Object Design |
Creator |
Information Expert (or Expert) |
Low Coupling |
Controller |
High Cohesion |
Object Design Examples with GRASP / 18: |
What is a Use Case Realization? |
Artifact Comments |
What's Next? |
Use Case Realizations for the NextGen Iteration |
Use Case Realizations for the Monopoly Iteration |
Process: Iterative and Evolutionary Object Design |
Summary |
Designing for Visibility / 19: |
Visibility Between Objects |
What is Visibility |
Mapping Designs to Code / 20: |
Programming and Iterative, Evolutionary Development |
Creating Class Definitions from DCDs |
Creating Methods from Interaction Diagrams |
Collection Classes in Code |
Exceptions and Error Handling |
Defining the Sale.makeLineItem Method |
Order of Implementation |
Test-Driven or Test-First Development |
Summary of Mapping Designs to Code |
Introduction to the NextGen POS Program Solution |
Introduction to the Monopoly Program Solution |
Test-Driven Development and Refactoring / 21: |
Test-Driven Development |
Refactoring |
Elaboration Iteration 2 - More Patterns / Part IV: |
UML Tools and UML as Blueprint / 22: |
Forward, Reverse, and Round-Trip Engineering |
What is a Common Report of Valuable Features? |
What to Look For in a Tool? |
If Sketching UML, How to Update the Diagrams After Coding? |
Quick Analysis Update / 23: |
Case Study: NextGen POS |
Case Study: Monopoly |
Iteration 2-More Patterns / 24: |
From Iteration 1 to 2 |
Iteration-2 Requirements and Emphasis: Object Design and Patterns |
GRASP: More Objects with Responsibilities / 25: |
Polymorphism |
Pure Fabrication |
Indirection |
Protected Variations |
Applying GoF Design Patterns / 26: |
Adapter (GoF) |
Some GRASP Principles as a Generalization of Other Patterns |
"Analysis" Discoveries During Design: Domain Model |
Factory |
Singleton (GoF) |
Conclusion of the External Services with Varying Interfaces Problem |
Strategy (GoF) |
Composite (GoF) and Other Design Principles |
Facade (GoF) |
Observer/Publish-Subscribe/Delegation Event Model (GoF) |
Conclusion |
Elaboration Iteration 3 - Intermediate Topics / Part V: |
Iteration 3-Intermediate Topics / 27: |
NextGen POS |
Monopoly |
UML Activity Diagrams and Modeling / 28: |
How to Apply Activity Diagrams? |
More UML Activity Diagram Notation |
Guidelines |
Example: NextGen Activity Diagram |
Process: Activity Diagrams in the UP |
Background |
UML State Machine Diagrams and Modeling / 29: |
Definitions: Events, States, and Transitions |
How to Apply State Machine Diagrams? |
More UML State Machine Diagram Notation |
Example: UI Navigation Modeling with State Machines |
Example: NextGen Use Case State Machine Diagram |
Process: State Machine Diagrams in the UP |
Relating Use Cases / 30: |
The include Relationship |
Terminology: Concrete, Abstract, Base, and Addition Use Cases |
The extend Relationship |
The generalize Relationship |
Use Case Diagrams |
More SSDs and Contracts / 31: |
Domain Model Refinement / 32: |
New Concepts for the NextGen Domain Model |
Generalization |
Defining Conceptual Superclasses and Subclasses |
When to Define a Conceptual Subclass? |
When to Define a Conceptual Superclass? |
NextGen POS Conceptual Class Hierarchies |
Abstract Conceptual Classes |
Modeling Changing States |
Class Hierarchies and Inheritance in Software |
Association Classes |
Aggregation and Composition |
Time Intervals and Product Prices-Fixing an Iteration 1 "Error" |
Association Role Names |
Roles as Concepts versus Roles in Associations |
Derived Elements |
Qualified Associations |
Reflexive Associations |
Using Packages to Organize the Domain Model |
Example: Monopoly Domain Model Refinements |
Architectural Analysis / 33: |
Process: When Do We Start Architectural Analysis? |
Definition: Variation and Evolution Points |
Common Steps in Architectural Analysis |
The Science: Identification and Analysis of Architectural Factors |
Example: Partial NextGen POS Architectural Factor Table |
The Art: Resolution of Architectural Factors |
Summary of Themes in Architectural Analysis |
Process: Iterative Architecture in the UP |
Logical Architecture Refinement / 34: |
Example: NextGen Logical Architecture |
Collaborations with the Layers Pattern |
Other Layer Pattern Issues |
Model-View Separation and "Upward" Communication |
More Object Design with GoF Patterns / 35: |
Example: NextGen POS |
Failover to Local Services; Performance with Local Caching |
Handling Failure |
Failover to Local Services with a Proxy (GoF) |
Designing for Non-Functional or Quality Requirements |
Accessing External Physical Devices with Adapters |
Abstract Factory (GoF) for Families of Related Objects |
Handling Payments with Polymorphism and Do It Myself |
Example: Monopoly |
Package Design / 36: |
Package Organization Guidelines |
UML Deployment and Component Diagrams / 37: |
Deployment Diagrams |
Component Diagrams |
Designing a Persistence Framework with Patterns / 38: |
The Problem: Persistent Objects |
The Solution: A Persistence Service from a Persistence Framework |
Frameworks |
Requirements for the Persistence Service and Framework |
Key Ideas |
Pattern: Representing Objects as Tables |
UML Data Modeling Profile |
Pattern: Object Identifier |
Accessing a Persistence Service with a Facade |
Mapping Objects: Database Mapper or Database Broker Pattern |
Framework Design with the Template Method Pattern |
Materialization with the Template Method Pattern |
Configuring Mappers with a MapperFactory |
Pattern: Cache Management |
Consolidating and Hiding SQL Statements in One Class |
Transactional States and the State Pattern |
Designing a Transaction with the Command Pattern |
Lazy Materialization with a Virtual Proxy |
How to Represent Relationships in Tables |
PersistentObject Superclass and Separation of Concerns |
Unresolved Issues |
Documenting Architecture: UML & the N+1 View Model / 39: |
The SAD and Its Architectural Views |
Notation: The Structure of a SAD |
Example: A NextGen POS SAD |
Example: A Jakarta Struts SAD |
Process: Iterative Architectural Documentation |
Special Topics / Part VI: |
More on Iterative Development and Agile Project Management / 40: |
How to Plan an Iteration? |
Adaptive versus Predictive Planning |
Phase and Iteration Plans |
How to Plan Iterations with Use Cases and Scenarios? |
The (In)Validity of Early Estimates |
Organizing Project Artifacts |
You Know You Didn't Understand Iterative Planning When... |
Bibliography |
Glossary |
Index |