SSDs Within the UP
by Craig Larman
Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and the Unified Process, Second Edition
- Copyright
- Sample UML Notation
- Praise for Applying UML and Patterns
- Foreword
- Preface
- Introduction
- Object-Oriented Analysis and Design
- Iterative Development and the Unified Process
- Introduction
- The Most Important UP Idea: Iterative Development
- Additional UP Best Practices and Concepts
- The UP Phases and Schedule-Oriented Terms
- The UP Disciplines (was Workflows)
- Process Customization and the Development Case
- The Agile UP
- The Sequential “Waterfall” Lifecycle
- You Know You Didn't Understand the UP When...
- Further Readings
- Case Study: The NextGen POS System
- Inception
- Inception
- Understanding Requirements
- Use-Case Model: Writing Requirements in Context
- Introduction
- Goals and Stories
- Background
- Use Cases and Adding Value
- Use Cases and Functional Requirements
- Use Case Types and Formats
- Fully Dressed Example: Process Sale
- Explaining the Sections
- Goals and Scope of a Use Case
- Finding Primary Actors, Goals, and Use Cases
- Congratulations: Use Cases Have Been Written, and Are Imperfect
- Write Use Cases in an Essential UI-Free Style
- Actors
- Use Case Diagrams
- Requirements in Context and Low-Level Feature Lists
- Use Cases Are Not Object-Oriented
- Use Cases Within the UP
- Case Study: Use Cases in the NextGen Inception Phase
- Further Readings
- UP Artifacts and Process Context
- Identifying Other Requirements
- Introduction
- NextGen POS Examples
- NextGen Example: (Partial) Supplementary Specification
- Commentary: Supplementary Specification
- NextGen Example: (Partial) Vision
- Commentary: Vision
- NextGen Example: A (Partial) Glossary
- Commentary: Glossary (Data Dictionary)
- Reliable Specifications: An Oxymoron?
- Online Artifacts at the Project Website
- Not Much UML During Inception?
- Other Requirement Artifacts Within the UP
- Further Readings
- UP Artifacts and Process Context
- From Inception to Elaboration
- Elaboration Iteration 1
- Use-Case Model: Drawing System Sequence Diagrams
- Moving on to Iteration 1
- Introduction
- System Behavior
- System Sequence Diagrams
- Example of an SSD
- Inter-System SSDs
- SSDs and Use Cases
- System Events and the System Boundary
- Naming System Events and Operations
- Showing Use Case Text
- SSDs and the Glossary
- SSDs Within the UP
- Further Readings
- UP Artifacts
- Domain Model: Visualizing Concepts
- Introduction
- Domain Models
- Conceptual Class Identification
- Candidate Conceptual Classes for the Sales Domain
- Domain Modeling Guidelines
- Resolving Similar Conceptual Classes—Register vs. “POST”
- Modeling the Unreal World
- Specification or Description Conceptual Classes
- UML Notation, Models, and Methods: Multiple Perspectives
- Lowering the Representational Gap
- Example: The NextGen POS Domain Model
- Domain Models Within the UP
- Further Readings
- UP Artifacts
- Domain Model: Adding Associations
- Introduction
- Associations
- The UML Association Notation
- Finding Associations—Common Associations List
- Association Guidelines
- Roles
- How Detailed Should Associations Be?
- Naming Associations
- Multiple Associations Between Two Types
- Associations and Implementation
- NextGen POS Domain Model Associations
- NextGen POS Domain Model
- Domain Model: Adding Attributes
- Use-Case Model: Adding Detail with Operation Contracts
- Introduction
- Contracts
- Example Contract: enterItem
- Contract Sections
- Postconditions
- Discussion—enterItem Postconditions
- Writing Contracts Leads to Domain Model Updates
- When Are Contracts Useful? Contracts vs. Use Cases?
- Guidelines: Contracts
- NextGen POS Example: Contracts
- Changes to the Domain Model
- Contracts, Operations, and the UML
- Operation Contracts Within the UP
- Further Readings
- From Requirements to Design in this Iteration
- Interaction Diagram Notation
- GRASP: Designing Objects with Responsibilities
- Introduction
- Responsibilities and Methods
- Responsibilities and Interaction Diagrams
- Patterns
- GRASP: Patterns of General Principles in Assigning Responsibilities
- The UML Class Diagram Notation
- Information Expert (or Expert)
- Creator
- Low Coupling
- High Cohesion
- Controller
- Object Design and CRC Cards
- Further Readings
- Design Model: Use-Case Realizations with GRASP Patterns
- Introduction
- Use-Case Realizations
- Artifact Comments
- Use-Case Realizations for the NextGen Iteration
- Object Design: makeNewSale
- Object Design: enterItem
- Object Design: endSale
- Object Design: makePayment
- Object Design: startUp
- Connecting the UI Layer to the Domain Layer
- Use-Case Realizations Within the UP
- Summary
- Design Model: Determining Visibility
- Design Model: Creating Design Class Diagrams
- Implementation Model: Mapping Designs to Code
- Introduction
- Programming and the Development Process
- Mapping Designs to Code
- Creating Class Definitions from DCDs
- Creating Methods from Interaction Diagrams
- Container/Collection Classes in Code
- Exceptions and Error Handling
- Defining the Sale--makeLineItem Method
- Order of Implementation
- Test-First Programming
- Summary of Mapping Designs to Code
- Introduction to the Program Solution
- Use-Case Model: Drawing System Sequence Diagrams
- Elaboration Iteration 2
- Iteration 2 and its Requirements
- GRASP: More Patterns for Assigning Responsibilities
- Designing Use-Case Realizations with GoF Design Patterns
- Introduction
- Adapter (GoF)
- “Analysis” Discoveries During Design: Domain Model
- Factory (GoF)
- 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
- Further Readings
- Elaboration Iteration 3
- Iteration 3 and Its Requirements
- Relating Use Cases
- Modeling Generalization
- Introduction
- New Concepts for the 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
- Refining the Domain Model
- Introduction
- Association Classes
- Aggregation and Composition
- Time Intervals and Product Prices—Fixing an Iteration 1 “Error”
- Association Role Names
- Roles as Concepts vs. Roles in Associations
- Derived Elements
- Qualified Associations
- Reflexive Associations
- Ordered Elements
- Using Packages to Organize the Domain Model
- Adding New SSDs and Contracts
- Modeling Behavior in Statechart Diagrams
- Introduction
- Events, States, and Transitions
- Statechart Diagrams
- Statechart Diagrams in the UP?
- Use Case Statechart Diagrams
- Use Case Statechart Diagrams for the POS Application
- Classes that Benefit from Statechart Diagrams
- Illustrating External and Interval Events
- Additional Statechart Diagram Notation
- Further Readings
- Designing the Logical Architecture with Patterns
- Organizing the Design and Implementation Model Packages
- Introduction to Architectural Analysis and the SAD
- Introduction
- Architectural Analysis
- Types and Views of Architecture
- 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
- Architectural Analysis within the UP
- Further Readings
- Designing More Use-Case Realizations with Objects and Patterns
- Introduction
- 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; Buy vs. Build
- Abstract Factory (GoF) for Families of Related Objects
- Handling Payments with Polymorphism and Do It Myself
- Conclusion
- Designing a Persistence Framework with Patterns
- Introduction
- 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
- Special Topics
- On Drawing and Tools
- Introduction to Iterative Planning and Project Issues
- Introduction
- Ranking Requirements
- Ranking Project Risks
- Adaptive vs. Predictive Planning
- Phase and Iteration Plans
- Iteration Plan: What to Do in the Next Iteration?
- Requirements Tracking Across Iterations
- The (In)Validity of Early Estimates
- Organizing Project Artifacts
- Some Team Iteration Scheduling Issues
- You Know You Didn't Understand Planning in the UP When...
- Further Readings
- Comments on Iterative Development and the UP
- Additional UP Best Practices and Concepts
- The Construction and Transition Phases
- Other Interesting Practices
- Motivations for Timeboxing an Iteration
- The Sequential “Waterfall” Lifecycle
- Usability Engineering and User Interface Design
- The UP Analysis Model
- The RUP Product
- The Challenge and Myths of Reuse
- More UML Notation
- Bibliography
- Glossary
- Sample UML Notation
- Index
9.10. SSDs Within the UP
SSDs are part of the Use-Case Model—a visualization of the interactions implied in the use cases. SSDs were not explicitly mentioned in the original UP description, although the UP creators are aware of and understand the usefulness of such diagrams. SSDs are an example of the many possible skillful analysis and design artifacts or activities that the UP or RUP documents do not mention.
Phases
Inception— SSDs are not usually motivated in inception.
Elaboration— Most SSDs are created during elaboration, when it is useful to identify the details of the system events to clarify what major operations the system must be designed to handle, write system operation contracts (discussed in Chapter 13), and possibly support estimation (for example, macroestimation with unadjusted function points and COCOMO II).
Note that it is not necessary to create SSDs for all scenarios of all use cases—at least not at the same time. Rather, create them only for some chosen scenarios of the current iteration.
Finally, it should only take a few minutes or an half hour to create the SSDs.
| Discipline | Artifact | Incep. | Elab. | Const. | Trans. |
|---|---|---|---|---|---|
| IterationÜ | I1 | E1..En | C1..Cn | T1..T2 | |
| Business Modeling | Domain Model | s | |||
| Requirements | Use-Case Model (SSDs) | s | r | ||
| Vision | s | r | |||
| Supplementary Specification | s | r | |||
| Glossary | s | r | |||
| Design | Design Model | s | r | ||
| SW Architecture Document | s | ||||
| Data Model | s | r | |||
| Implementation | Implementation Model | s | r | r | |
| Project Management | SW Development Plan | s | r | r | r |
| Testing | Test Model | s | r | ||
| Environment | Development Case | s | r |
-
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.