| 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 |
