Amazon no longer offers textbook rentals. We do!

Applying UML and Patterns : An Introduction to Object-Oriented Analysis and Design and the Unified Process

by: Larman, Craig

Applying UML and Patterns : An Introduction to Object-Oriented Analysis and Design and the Unified Process

by: Larman, Craig

ISBN 13:
9780130925695
ISBN 10:
0130925691
Format: Hardcover
Copyright: 01/01/2002
Publisher: Prentice Hall PTR
Newer Edition

Rent

Sorry, this item is currently unavailable.

Note: Supplemental materials are not guaranteed with Rental or Used book purchases.

Extend or Purchase Your Rental at Any Time

Need to keep your rental past your due date? At any time before your due date you can extend or purchase your rental through your account.

Summary

An update to the bestselling UML classic, this title has been revised to cover the unified process and Rational Software's processes. Larman also shows developers how to make practical use of the most significant recent developments in object-oriented analysis and design.

Foreword

Preface

xvii

Part I Introduction

Object-Oriented Analysis and Design

(10)

Applying UML and Patterns in OOA/D

(3)

Assigning Responsibilities

(1)

What Is Analysis and Design?

(1)

What Is Object-Oriented Analysis and Design?

(1)

An Example

(3)

The UML

(1)

Further Readings

(2)

Iterative Development and the Unified Process

(16)

The Most Important UP Idea: Iterative Development

(4)

Additional UP Best Practices and Concepts

(1)

The UP Phases and Schedule-Oriented Terms

(1)

The UP Disciplines (was Workflows)

(3)

Process Customization and the Development Case

(1)

The Agile UP

(1)

The Sequential ``Waterfall'' Lifecycle

(1)

You Know You Didn't Understand the UP When...

(1)

Further Readings

(3)

Case Study: The NextGen POS System

(6)

The NextGen POS System

(1)

Architectural Layers and Case Study Emphasis

(1)

The Book's Strategy: Iterative Learning and Development

(4)

Part II Inception

Inception

(6)

Inception: An Analogy

(1)

Inception May Be Very Brief

(1)

What Artifacts May Start in Inception?

(1)

You Know You Didn't Understand Inception When...

(3)

Understanding Requirements

(4)

Types of Requirements

(1)

Further Readings

(2)

Use-Case Model: Writing Requirements in Context

(38)

Goals and Stories

(1)

Background

(1)

Use Cases and Adding Value

(1)

Use Cases and Functional Requirements

(1)

Use Case Types and Formats

(1)

Fully Dressed Example: Process Sale

(4)

Explaining the Sections

(5)

Goals and Scope of a Use Case

(4)

Finding Primary Actors, Goals, and Use Cases

(4)

Congratulations: Use Cases Have Been Written, and Are Imperfect

(1)

Write Use Cases in an Essential UI-Free Style

(2)

Actors

(1)

Use Case Diagrams

(2)

Requirements in Context and Low-Level Feature Lists

(2)

Use Cases Are Not Object-Oriented

(1)

Use Cases Within the UP

(4)

Case Study: Use Cases in the NextGen Inception Phase

(1)

Further Readings

(2)

UP Artifacts and Process Context

(2)

Identifying Other Requirements

(24)

NextGen POS Examples

(1)

NextGen Example: (Partial) Supplementary Specification

(4)

Commentary: Supplementary Specification

(3)

NextGen Example: (Partial) Vision

(2)

Commentary: Vision

(5)

NextGen Example: A (Partial) Glossary

(1)

Commentary: Glossary (Data Dictionary)

(1)

Reliable Specifications: An Oxymoron?

100

(1)

Online Artifacts at the Project Website

101

(1)

Not Much UML During Inception?

101

(1)

Other Requirement Artifacts Within the UP

101

(3)

Further Readings

104

(1)

UP Artifacts and Process Context

105

(2)

From Inception to Elaboration

107

(10)

Checkpoint: What Happened in Inception?

108

(1)

On to Elaboration

109

(1)

Planning the Next Iteration

110

(2)

Iteration 1 Requirements and Emphasis: Fundamental OOA/D Skills

112

(1)

What Artifacts May Start in Elaboration?

113

(1)

You Know You Didn't Understand Elaboration When...

114

(3)

Part III Elaboration Iteration 1

Use-Case Model: Drawing System Sequence Diagrams

117

(10)

System Behavior

118

(1)

System Sequence Diagrams

118

(1)

Example of an SSD

119

(1)

Inter-System SSDs

120

(1)

SSDs and Use Cases

120

(1)

System Events and the System Boundary

120

(1)

Naming System Events and Operations

121

(1)

Showing Use Case Text

122

(1)

SSDs and the Glossary

122

(1)

SSDs Within the UP

123

(1)

Further Readings

124

(1)

UP Artifacts

125

(2)

Domain Model: Visualizing Concepts

127

(26)

Domain Models

128

(4)

Conceptual Class Identification

132

(4)

Candidate Conceptual Classes for the Sales Domain

136

(1)

Domain Modeling Guidelines

137

(2)

Resolving Similar Conceptual Classes---Register vs. ``POST''

139

(1)

Modeling the Unreal World

140

(1)

Specification or Description Conceptual Classes

140

(4)

UML Notation, Models, and Methods: Multiple Perspectives

144

(2)

Lowering the Representational Gap

146

(2)

Example: The NextGen POS Domain Model

148

(1)

Domain Models Within the UP

148

(2)

Further Readings

150

(1)

UP Artifacts

151

(2)

Domain Model: Adding Associations

153

(14)

Associations

153

(1)

The UML Association Notation

154

(1)

Finding Associations---Common Associations List

155

(2)

Association Guidelines

157

(1)

Roles

157

(2)

How Detailed Should Associations Be?

159

(1)

Naming Associations

160

(1)

Multiple Associations Between Two Types

161

(1)

Associations and Implementation

161

(1)

NextGen POS Domain Model Associations

162

(1)

NextGen POS Domain Model

163

(4)

Domain Model: Adding Attributes

167

(10)

Attributes

167

(1)

UML Attribute Notation

168

(1)

Valid Attribute Types

168

(2)

Non-primitive Data Type Classes

170

(2)

Design Creep: No Attributes as Foreign Keys

172

(1)

Modeling Attribute Quantities and Units

173

(1)

Attributes in the NextGen Domain Model

174

(1)

Multiplicity From SalesLineItem to Item

175

(1)

Domain Model Conclusion

175

(2)

Use-Case Model: Adding Detail with Operation Contracts

177

(16)

Contracts

177

(1)

Example Contract: enterItem

178

(1)

Contract Sections

179

(1)

Postconditions

179

(3)

Discussion---enterItem Postconditions

182

(1)

Writing Contracts Leads to Domain Model Updates

183

(1)

When Are Contracts Useful? Contracts vs. Use Cases?

183

(1)

Guidelines: Contracts

184

(1)

NextGen POS Example: Contracts

185

(1)

Changes to the Domain Model

186

(1)

Contracts, Operations, and the UML

186

(2)

Operation Contracts Within the UP

188

(3)

Further Readings

191

(2)

From Requirements to Design in this Iteration

193

(4)

Iteratively Do the Right Thing, Do the Thing Right

193

(1)

Didn't That Take Weeks To Do? No, Not Exactly

194

(1)

On to Object Design

194

(3)

Interaction Diagram Notation

197

(18)

Sequence and Collaboration Diagrams

198

(1)

Example Collaboration Diagram: makePayment

199

(1)

Example Sequence Diagram: makePayment

200

(1)

Interaction Diagrams Are Valuable

200

(1)

Common Interaction Diagram Notation

201

(1)

Basic Collaboration Diagram Notation

202

(6)

Basic Sequence Diagram Notation

208

(7)

GRASP: Designing Objects with Responsibilities

215

(32)

Responsibilities and Methods

216

(1)

Responsibilities and Interaction Diagrams

217

(1)

Patterns

218

(1)

GRASP: Patterns of General Principles in Assigning Responsibilities

219

(1)

The UML Class Diagram Notation

220

(1)

Information Expert (or Expert)

221

(5)

Creator

226

(3)

Low Coupling

229

(3)

High Cohesion

232

(5)

Controller

237

(8)

Object Design and CRC Cards

245

(1)

Further Readings

246

(1)

Design Model: Use-Case Realizations with GRASP Patterns

247

(32)

Use-Case Realizations

248

(1)

Artifact Comments

249

(3)

Use-Case Realizations for the NextGen Iteration

252

(1)

Object Design: makeNewSale

253

(2)

Object Design: enterItem

255

(5)

Object Design: endSale

260

(4)

Object Design: makePayment

264

(5)

Object Design: startUp

269

(4)

Connecting the UI Layer to the Domain Layer

273

(3)

Use-Case Realizations Within the UP

276

(2)

Summary

278

(1)

Design Model: Determining Visibility

279

(6)

Visibility Between Objects

279

(1)

Visibility

280

(4)

Illustrating Visibility in the UML

284

(1)

Design Model: Creating Design Class Diagrams

285

(16)

When to Create DCDs

285

(1)

Example DCD

286

(1)

DCD and UP Terminology

286

(1)

Domain Model vs. Design Model Classes

287

(1)

Creating a NextGen POS DCD

287

(9)

Notation for Member Details

296

(2)

DCDs, Drawing, and CASE Tools

298

(1)

DCDs Within the UP

298

(1)

UP Artifacts

299

(2)

Implementation Model: Mapping Designs to Code

301

(18)

Programming and the Development Process

302

(2)

Mapping Designs to Code

304

(1)

Creating Class Definitions from DCDs

304

(3)

Creating Methods from Interaction Diagrams

307

(2)

Container/Collection Classes in Code

309

(1)

Exceptions and Error Handling

309

(1)

Defining the Sale--makeLineItem Method

310

(1)

Order of Implementation

311

(1)

Test-First Programming

311

(2)

Summary of Mapping Designs to Code

313

(1)

Introduction to the Program Solution

313

(6)

Part IV Elaboration Iteration 2

Iteration 2 and its Requirements

319

(6)

Iteration 2 Emphasis: Object Design and Patterns

319

(1)

From Iteration 1 to 2

319

(2)

Iteration 2 Requirements

321

(1)

Refinement of Analysis-oriented Artifacts in this Iteration

322

(3)

GRASP: More Patterns for Assigning Responsibilities

325

(16)

Polymorphism

326

(3)

Pure Fabrication

329

(3)

Indirection

332

(2)

Protected Variations

334

(7)

Designing Use-Case Realizations with GoF Design Patterns

341

(42)

Adapter (GoF)

342

(3)

``Analysis'' Discoveries During Design: Domain Model

345

(1)

Factory (GoF)

346

(2)

Singleton (GoF)

348

(4)

Conclusion of the External Services with Varying Interfaces Problem

352

(1)

Strategy (GoF)

353

(5)

Composite (GoF) and Other Design Principles

358

(10)

Facade (GoF)

368

(4)

Observer/Publish-Subscribe/Delegation Event Model (GoF)

372

(8)

Conclusion

380

(1)

Further Readings

380

(3)

Part V Elaboration Iteration 3

Iteration 3 and Its Requirements

383

(2)

Iteration 3 Requirements

383

(1)

Iteration 3 Emphasis

383

(2)

Relating Use Cases

385

(8)

The include Relationship

386

(2)

Terminology: Concrete, Abstract, Base, and Addition Use Cases

388

(1)

The extend Relationship

389

(1)

The Generalize Relationship

390

(1)

Use Case Diagrams

391

(2)

Modeling Generalization

393

(18)

New Concepts for the Domain Model

393

(3)

Generalization

396

(1)

Defining Conceptual Superclasses and Subclasses

397

(3)

When to Define a Conceptual Subclass

400

(3)

When to Define a Conceptual Superclass

403

(1)

NextGen POS Conceptual Class Hierarchies

403

(3)

Abstract Conceptual Classes

406

(2)

Modeling Changing States

408

(1)

Class Hierarchies and Inheritance in Software

409

(2)

Refining the Domain Model

411

(20)

Association Classes

411

(3)

Aggregation and Composition

414

(4)

Time Intervals and Product Prices---Fixing an Iteration 1 ``Error''

418

(1)

Association Role Names

419

(1)

Roles as Concepts vs. Roles in Associations

420

(1)

Derived Elements

421

(1)

Qualified Associations

422

(1)

Reflexive Associations

423

(1)

Ordered Elements

423

(1)

Using Packages to Organize the Domain Model

423

(8)

Adding New SSDs and Contracts

431

(6)

New System Sequence Diagrams

431

(2)

New System Operations

433

(1)

New System Operation Contracts

434

(3)

Modeling Behavior in Statechart Diagrams

437

(10)

Events, States, and Transitions

437

(1)

Statechart Diagrams

438

(1)

Statechart Diagrams in the UP?

439

(1)

Use Case Statechart Diagrams

439

(2)

Use Case Statechart Diagrams for the POS Application

441

(1)

Classes that Benefit from Statechart Diagrams

441

(2)

Illustrating External and Interval Events

443

(1)

Additional Statechart Diagram Notation

444

(2)

Further Readings

446

(1)

Designing the Logical Architecture with Patterns

447

(28)

Software Architecture

448

(2)

Architectural Pattern: Layers

450

(21)

The Model-View Separation Principle

471

(3)

Further Readings

474

(1)

Organizing the Design and Implementation Model Packages

475

(10)

Package Organization Guidelines

476

(6)

More UML Package Notation

482

(1)

Further Readings

483

(2)

Introduction to Architectural Analysis and the SAD

485

(22)

Architectural Analysis

486

(2)

Types and Views of Architecture

488

(1)

The Science: Identification and Analysis of Architectural Factors

488

(3)

Example: Partial NextGen POS Architectural Factor Table

491

(2)

The Art: Resolution of Architectural Factors

493

(6)

Summary of Themes in Architectural Analysis

499

(1)

Architectural Analysis within the UP

500

(5)

Further Readings

505

(2)

Designing More Use-Case Realizations with Objects and Patterns

507

(30)

Failover to Local Services; Performance with Local Caching

507

(5)

Handling Failure

512

(7)

Failover to Local Services with a Proxy (GoF)

519

(4)

Designing for Non-Functional or Quality Requirements

523

(1)

Accessing External Physical Devices with Adapters; Buy vs. Build

523

(2)

Abstract Factory (GoF) for Families of Related Objects

525

(3)

Handling Payments with Polymorphism and Do It Myself

528

(7)

Conclusion

535

(2)

Designing a Persistence Framework with Patterns

537

(30)

The Problem: Persistent Objects

538

(1)

The Solution: A Persistence Service from a Persistence Framework

538

(1)

Frameworks

539

(1)

Requirements for the Persistence Service and Framework

540

(1)

Key Ideas

540

(1)

Pattern: Representing Objects as Tables

541

(1)

UML Data Modeling Profile

541

(1)

Pattern: Object Identifier

542

(1)

Accessing a Persistence Service with a Facade

543

(1)

Mapping Objects: Database Mapper or Database Broker Pattern

543

(3)

Framework Design with the Template Method Pattern

546

(1)

Materialization with the Template Method Pattern

546

(6)

Configuring Mappers with a MapperFactory

552

(1)

Pattern: Cache Management

552

(1)

Consolidating and Hiding SQL Statements in One Class

553

(1)

Transactional States and the State Pattern

554

(2)

Designing a Transaction with the Command Pattern

556

(3)

Lazy Materialization with a Virtual Proxy

559

(3)

How to Represent Relationships in Tables

562

(1)

PersistentObject Superclass and Separation of Concerns

563

(1)

Unresolved Issues

564

(3)

Part VI Special Topics

On Drawing and Tools

567

(8)

On Speculative Design and Visual Thinking

567

(1)

Suggestions for UML Drawing Within the Development Process

568

(3)

Tools and Sample Features

571

(2)

Example Two

573

(2)

Introduction to Iterative Planning and Project Issues

575

(14)

Ranking Requirements

576

(3)

Ranking Project Risks

579

(1)

Adaptive vs. Predictive Planning

579

(2)

Phase and Iteration Plans

581

(1)

Iteration Plan: What to Do in the Next Iteration?

582

(1)

Requirements Tracking Across Iterations

583

(2)

The (In)Validity of Early Estimates

585

(1)

Organizing Project Artifacts

585

(1)

Some Team Iteration Scheduling Issues

586

(2)

You Know You Didn't Understand Planning in the UP When...

588

(1)

Further Readings

588

(1)

Comments on Iterative Development and the UP

589

(14)

Additional UP Best Practices and Concepts

589

(2)

The Construction and Transition Phases

591

(1)

Other Interesting Practices

592

(1)

Motivations for Timeboxing an Iteration

593

(1)

The Sequential ``Waterfall'' Lifecycle

593

(6)

Usability Engineering and User Interface Design

599

(1)

The UP Analysis Model

599

(1)

The RUP Product

600

(1)

The Challenge and Myths of Reuse

601

(2)

More UML Notation

603

(6)

General Notation

603

(1)

Implementation Diagrams

604

(2)

Template (Parameterized, Generic) Class

606

(1)

Activity Diagrams

607

(2)

Bibliography

609

(6)

Glossary

615

(6)

Index

621

Amazon no longer offers textbook rentals. We do!

Applying UML and Patterns : An Introduction to Object-Oriented Analysis and Design and the Unified Process

Applying UML and Patterns : An Introduction to Object-Oriented Analysis and Design and the Unified Process

9780130925695

0130925691

Summary

Table of Contents

Supplemental Materials

Write a Review

Amazon no longer offers textbook rentals. We do!

Applying UML and Patterns : An Introduction to Object-Oriented Analysis and Design and the Unified Process

Applying UML and Patterns : An Introduction to Object-Oriented Analysis and Design and the Unified Process

9780130925695

0130925691

Summary

Table of Contents

Supplemental Materials

Write a Review

Related Products