Skip to content

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

Spend $50 to get a free DVD!

ISBN-10: 0131489062

ISBN-13: 9780131489066

Edition: 3rd 2005 (Revised)

Authors: Craig Larman

List price: $89.99
Shipping box This item qualifies for FREE shipping.
Blue ribbon 30 day, 100% satisfaction guarantee!
what's this?
Rush Rewards U
Members Receive:
Carrot Coin icon
XP icon
You have reached 400 XP and carrot coins. That is the daily max!


The mastery of object-oriented analysis and design (OOA/D) principles andconcepts is critical for anyone seeking to create robust and maintainable objectsystems. This third edition presents a well-defined roadmap, so the reader canmove along a step-by-step process from requirements gathering all the way tocode generation. The author teaches the skill of OOA/D using the latestversion of the industry standard modeling language (UML 2.0). He also allowsthe reader to learn and apply the popular concept of design patterns, andtherefore helps readers accelerate their mastery of analysis and design. Theauthor retains his thorough treatment of a single case study to help readers gaina big picture…    
Customers also bought

Book details

List price: $89.99
Edition: 3rd
Copyright year: 2005
Publisher: Prentice Hall PTR
Publication date: 10/20/2004
Binding: Hardcover
Pages: 736
Size: 8.00" wide x 10.25" long x 1.50" tall
Weight: 3.784
Language: English

Object-Oriented Analysis and Design
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
Recommended Resources
Iterative, Evolutionary, and Agile
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...
Recommended Resources
Case Studies
What is and isn't Covered in the Case Studies?
Case Study Strategy: Iterative Development + Iterative Learning
The NextGen POS System
The Monopoly Game System
Inception is Not the Requirements Phase
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
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?
Recommended Resources
Use Cases
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?
Recommended Resources
Other Requirements
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
Recommended Resources
Elaboration Iteration 1 - Basics
Iteration 1-Basics
Iteration 1 Requirements and Emphasis: Core OOA/D Skills
Process: Inception and Elaboration
Process: Planning the Next Iteration
Domain Models
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?
Example: Associations in the Domain Models
Example: Attributes in the Domain Models
Conclusion: Is the Domain Model Correct?
Process: Iterative and Evolutionary Domain Modeling
Recommended Resources
System Sequence Diagrams
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
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
Recommended Resources
Requirements to Design-Iteratively
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
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?
Recommended Resources
On to Object Design
Agile Modeling and Lightweight UML Drawing
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
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
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
Stereotypes, Profiles, and Tags
UML Properties and Property Strings
Generalization, Abstract Classes, Abstract Operations
Composition Over Aggregation
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
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
Information Expert (or Expert)
Low Coupling
High Cohesion
Recommended Resources
Object Design Examples with GRASP
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
Designing for Visibility
Visibility Between Objects
What is Visibility
Mapping Designs to Code
Programming and Iterative, Evolutionary Development
Mapping Designs to Code
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
Test-Driven Development
Recommended Resources
Elaboration Iteration 2 - More Patterns
UML Tools and UML as Blueprint
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?
Recommended Resources
Quick Analysis Update
Case Study: NextGen POS
Case Study: Monopoly
Iteration 2-More Patterns
From Iteration 1 to 2
Iteration-2 Requirements and Emphasis: Object Design and Patterns
GRASP: More Objects with Responsibilities
Pure Fabrication
Protected Variations
Applying GoF Design Patterns
Adapter (GoF)
Some GRASP Principles as a Generalization of Other Patterns
"Analysis" Discoveries During Design: Domain Model
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)
Recommended Resources
Elaboration Iteration 3 - Intermediate Topics
Iteration 3-Intermediate Topics
NextGen POS
UML Activity Diagrams and Modeling
How to Apply Activity Diagrams?
More UML Activity Diagram Notation
Example: NextGen Activity Diagram
Process: Activity Diagrams in the UP
UML State Machine Diagrams and Modeling
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
Recommended Resources
Relating Use Cases
The include Relationship
Terminology: Concrete, Abstract, Base, and Addition Use Cases
The extend Relationship
The generalize Relationship
Use Case Diagrams
More SSDs and Contracts
NextGen POS
Domain Model Refinement
New Concepts for the NextGen Domain Model
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
Process: When Do We Start Architectural Analysis?
Definition: Variation and Evolution Points
Architectural Analysis
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
Recommended Resources
Logical Architecture Refinement
Example: NextGen Logical Architecture
Collaborations with the Layers Pattern
Other Layer Pattern Issues
Model-View Separation and "Upward" Communication
Recommended Resources
More Object Design with GoF Patterns
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
Package Organization Guidelines
Recommended Resources
UML Deployment and Component Diagrams
Deployment Diagrams
Component Diagrams
Designing a Persistence Framework with Patterns
The Problem: Persistent Objects
The Solution: A Persistence Service from a Persistence Framework
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
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
Recommended Resources
Special Topics
More on Iterative Development and Agile Project Management
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...
Recommended Resources