did-you-know? rent-now

Amazon no longer offers textbook rentals. We do!

did-you-know? rent-now

Amazon no longer offers textbook rentals. We do!

We're the #1 textbook rental company. Let us show you why.

9780131489066

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

by
  • ISBN13:

    9780131489066

  • ISBN10:

    0131489062

  • Edition: 3rd
  • Format: Hardcover
  • Copyright: 2004-10-20
  • Publisher: Pearson

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

Purchase Benefits

List Price: $89.99 Save up to $34.42
  • Rent Book $55.57
    Add to Cart Free Shipping Icon Free Shipping

    TERM
    PRICE
    DUE
    USUALLY SHIPS IN 24-48 HOURS
    *This item is part of an exclusive publisher rental program and requires an additional convenience fee. This fee will be reflected in the shopping cart.

Supplemental Materials

What is included with this book?

Summary

This third edition again delivers a clear path for students and professionals to learn and apply object-oriented analysis and design.

Author Biography

Craig Larman serves as chief scientist at Valtech

Table of Contents

Foreword xix
Preface xxi
Part I Introduction
Object-Oriented Analysis and Design
3(14)
What Will You Learn? Is it Useful?
3(3)
The Most Important Learning Goal?
6(1)
What is Analysis and Design?
6(1)
What is Object-Oriented Analysis and Design?
7(1)
A Short Example
8(3)
What is the UML?
11(3)
Visual Modeling is a Good Thing
14(1)
History
15(1)
Recommended Resources
16(1)
Iterative, Evolutionary, and Agile
17(24)
What is the UP? Are Other Methods Complementary?
18(1)
What is Iterative and Evolutionary Development?
19(4)
What About the Waterfall Lifecycle?
23(2)
How to do Iterative and Evolutionary Analysis and Design?
25(2)
What is Risk-Driven and Client-Driven Iterative Planning?
27(1)
What are Agile Methods and Attitudes?
27(3)
What is Agile Modeling?
30(1)
What is an Agile UP?
31(2)
Are There Other Critical UP Practices?
33(1)
What are the UP Phases?
33(1)
What are the UP Disciplines?
34(3)
How to Customize the Process? The UP Development Case
37(1)
You Know You Didn't Understand Iterative Development or the UP When
38(1)
History
39(1)
Recommended Resources
40(1)
Case Studies
41(6)
What is and isn't Covered in the Case Studies?
41(2)
Case Study Strategy: Iterative Development + Iterative Learning
43(1)
Case One: The NextGen POS System
43(1)
Case Two: The Monopoly Game System
44(3)
Part II Inception
Inception is Not the Requirements Phase
47(6)
What is Inception?
48(1)
How Long is Inception?
49(1)
What Artifacts May Start in Inception?
49(2)
You Know You Didn't Understand Inception When
51(1)
How Much UML During Inception?
51(2)
Evolutionary Requirements
53(8)
Definition: Requirements
54(1)
Evolutionary vs. Waterfall Requirements
54(2)
What are Skillful Means to Find Requirements?
56(1)
What are the Types and Categories of Requirements?
56(2)
How are Requirements Organized in UP Artifacts?
58(1)
Does the Book Contain Examples of These Artifacts?
58(1)
Recommended Resources
59(2)
Use Cases
61(40)
Example
63(1)
Definition: What are Actors, Scenarios, and Use Cases?
63(1)
Use Cases and the Use-Case Model
64(1)
Motivation: Why Use Cases?
64(1)
Definition: Are Use Cases Functional Requirements?
65(1)
Definition: What are Three Kinds of Actors?
66(1)
Notation: What are Three Common Use Case Formats?
66(1)
Example: Process Sale, Fully Dressed Style
67(5)
What do the Sections Mean?
72(6)
Notation: Are There Other Formats? A Two-Column Variation
78(2)
Guideline: Write in an Essential UI-Free Style
80(1)
Guideline: Write Terse Use Cases
81(1)
Guideline: Write Black-Box Use Cases
81(1)
Guideline: Take an Actor and Actor-Goal Perspective
82(1)
Guideline: How to Find Use Cases
82(5)
Guideline: What Tests Can Help Find Useful Use Cases?
87(2)
Applying UML: Use Case Diagrams
89(3)
Applying UML: Activity Diagrams
92(1)
Motivation: Other Benefits of Use Cases? Requirements in Context
92(1)
Example: Monopoly Game
93(2)
Process: How to Work With Use Cases in Iterative Methods?
95(4)
History
99(1)
Recommended Resources
99(2)
Other Requirements
101(22)
How Complete are these Examples?
102(1)
Guideline: Should We Analyze These Thoroughly During Inception?
102(1)
Guideline: Should These Artifacts be at the Project Website?
103(1)
NextGen Example: (Partial) Supplementary Specification
104(3)
Commentary: Supplementary Specification
107(2)
NextGen Example: (Partial) Vision
109(2)
Commentary: Vision
111(4)
NextGen Example: A (Partial) Glossary
115(1)
Commentary: Glossary (Data Dictionary)
115(1)
NextGen Example: Business Rules (Domain Rules)
116(1)
Commentary: Domain Rules
117(1)
Process: Evolutionary Requirements in Iterative Methods
118(1)
Recommended Resources
119(4)
Part III Elaboration Iteration 1 --- Basics
Iteration 1---Basics
123(8)
Iteration 1 Requirements and Emphasis: Core OOA/D Skills
124(2)
Process: Inception and Elaboration
126(4)
Process: Planning the Next Iteration
130(1)
Domain Models
131(42)
Example
133(1)
What is a Domain Model?
134(3)
Motivation: Why Create a Domain Model?
137(2)
Guideline: How to Create a Domain Model?
139(1)
Guideline: How to Find Conceptual Classes?
139(4)
Example: Find and Draw Conceptual Classes
143(1)
Guideline: Agile Modeling---Sketching a Class Diagram
144(1)
Guideline: Agile Modeling---Maintain the Model in a Tool?
144(1)
Guideline: Report Objects---Include `Receipt' in the Model?
145(1)
Guideline: Think Like a Mapmaker; Use Domain Terms
145(1)
Guideline: How to Model the Unreal World?
146(1)
Guideline: A Common Mistake with Attributes vs. Classes
146(1)
Guideline: When to Model with `Description' Classes?
147(2)
Associations
149(7)
Example: Associations in the Domain Models
156(2)
Attributes
158(8)
Example: Attributes in the Domain Models
166(2)
Conclusion: Is the Domain Model Correct?
168(1)
Process: Iterative and Evolutionary Domain Modeling
169(1)
Recommended Resources
170(3)
System Sequence Diagrams
173(8)
Example: NextGen SSD
175(1)
What are System Sequence Diagrams?
176(1)
Motivation: Why Draw an SSD?
176(1)
Applying UML: Sequence Diagrams
177(1)
What is the Relationship Between SSDs and Use Cases?
177(1)
How to Name System Events and Operations?
178(1)
How to Model SSDs Involving Other External Systems?
178(1)
What SSD Information to Place in the Glossary?
179(1)
Example: Monopoly SSD
179(1)
Process: Iterative and Evolutionary SSDs
180(1)
History and Recommended Resources
180(1)
Operation Contracts
181(14)
Example
183(1)
Definition: What are the Sections of a Contract?
183(1)
Definition: What is a System Operation?
183(1)
Definition: Postconditions
184(3)
Example: enterltem Postconditions
187(1)
Guideline: Should We Update the Domain Model?
188(1)
Guideline: When Are Contracts Useful?
188(1)
Guideline: How to Create and Write Contracts
189(1)
Example: NextGen POS Contracts
190(1)
Example: Monopoly Contracts
191(1)
Applying UML: Operations, Contracts, and the OCL
191(2)
Process: Operation Contracts Within the UP
193(1)
History
193(1)
Recommended Resources
194(1)
Requirements to Design---Iteratively
195(2)
Iteratively Do the Right Thing, Do the Thing Right
196(1)
Provoking Early Change
196(1)
Didn't All That Analysis and Modeling Take Weeks To Do?
196(1)
Logical Architecture and UML Package Diagrams
197(16)
Example
199(1)
What is the Logical Architecture? And Layers?
199(1)
What Layers are the Focus in the Case Studies?
200(1)
What is Software Architecture?
200(1)
Applying UML: Package Diagrams
201(1)
Guideline: Design with Layers
202(7)
Guideline: The Model-View Separation Principle
209(1)
What's the Connection Between SSDs, System Operations, and Layers?
210(1)
Example: NextGen Logical Architecture and Package Diagram
211(1)
Example: Monopoly Logical Architecture?
212(1)
Recommended Resources
212(1)
On to Object Design
213(8)
Agile Modeling and Lightweight UML Drawing
214(1)
UML Case Tools
215(1)
How Much Time Spent Drawing UML Before Coding?
215(1)
Designing Objects: What are Static and Dynamic Modeling?
216(1)
The Importance of Object Design Skill over UML Notation Skill
217(1)
Other Object Design Techniques: CRC Cards
218(3)
UML Interaction Diagrams
221(28)
Sequence and Communication Diagrams
222(3)
Novice UML Modelers Don't Pay Enough Attention to Interaction Diagrams!
225(1)
Common UML Interaction Diagram Notation
226(1)
Basic Sequence Diagram Notation
227(13)
Basic Communication Diagram Notation
240(9)
UML Class Diagrams
249(22)
Applying UML: Common Class Diagram Notation
250(1)
Definition: Design Class Diagram
251(1)
Definition: Classifier
251(1)
Ways to Show UML Attributes: Attribute Text and Association Lines
252(4)
Note Symbols: Notes, Comments, Constraints, and Method Bodies
256(1)
Operations and Methods
256(2)
Keywords
258(1)
Stereotypes, Profiles, and Tags
259(1)
UML Properties and Property Strings
260(1)
Generalization, Abstract Classes, Abstract Operations
260(1)
Dependency
260(3)
Interfaces
263(1)
Composition Over Aggregation
264(1)
Constraints
265(1)
Qualified Association
265(1)
Association Class
266(1)
Singleton Classes
266(1)
Template Classes and Interfaces
267(1)
User-Defined Compartments
268(1)
Active Class
269(1)
What's the Relationship Between Interaction and Class Diagrams?
269(2)
Grasp: Designing Objects with Responsibilities
271(50)
UML versus Design Principles
272(1)
Object Design: Example Inputs, Activities, and Outputs
272(4)
Responsibilities and Responsibility-Driven Design
276(1)
Grasp: A Methodical Approach to Basic OO Design
277(1)
What's the Connection Between Responsibilities, Grasp, and UML Diagrams?
277(1)
What are Patterns?
278(3)
Where are We Now?
281(1)
A Short Example of Object Design with Grasp
281(10)
Applying Grasp to Object Design
291(1)
Creator
291(3)
Information Expert (or Expert)
294(5)
Low Coupling
299(3)
Controller
302(12)
High Cohesion
314(5)
Recommended Resources
319(2)
Object Design Examples with Grasp
321(42)
What is a Use Case Realization?
322(2)
Artifact Comments
324(3)
What's Next?
327(1)
Use Case Realizations for the NextGen Iteration
327(22)
Use Case Realizations for the Monopoly Iteration
349(11)
Process: Iterative and Evolutionary Object Design
360(2)
Summary
362(1)
Designing for Visibility
363(6)
Visibility Between Objects
363(1)
What is Visibility?
364(5)
Mapping Designs to Code
369(16)
Programming and Iterative, Evolutionary Development
370(1)
Mapping Designs to Code
371(1)
Creating Class Definitions from DCDs
371(1)
Creating Methods from Interaction Diagrams
372(2)
Collection Classes in Code
374(1)
Exceptions and Error Handling
374(1)
Defining the Sale.makeLineItem Method
375(1)
Order of Implementation
375(1)
Test-Driven or Test-First Development
376(1)
Summary of Mapping Designs to Code
376(1)
Introduction to the NextGen POS Program Solution
377(3)
Introduction to the Monopoly Program Solution
380(5)
Test-Driven Development and Refactoring
385(12)
Test-Driven Development
386(3)
Refactoring
389(4)
Recommended Resources
393(4)
Part IV Elaboration Iteration 2 --- More Patterns
UML Tools and UML as Blueprint
397(4)
Forward, Reverse, and Round-Trip Engineering
398(1)
What is a Common Report of Valuable Features?
398(1)
What to Look For in a Tool?
399(1)
If Sketching UML, How to Update the Diagrams After Coding?
399(1)
Recommended Resources
400(1)
Quick Analysis Update
401(6)
Case Study: NextGen POS
401(2)
Case Study: Monopoly
403(4)
Iteration 2---More Patterns
407(6)
From Iteration 1 to 2
408(1)
Iteration-2 Requirements and Emphasis: Object Design and Patterns
409(4)
Grasp: More Objects with Responsibilities
413(22)
Polymorphism
414(7)
Pure Fabrication
421(5)
Indirection
426(1)
Protected Variations
427(8)
Applying GoF Design Patterns
435(40)
Adapter (GoF)
436(2)
Some Grasp Principles as a Generalization of Other Patterns
438(2)
``Analysis'' Discoveries During Design: Domain Model
440(1)
Factory
440(2)
Singleton (GoF)
442(4)
Conclusion of the External Services with Varying Interfaces Problem
446(1)
Strategy (GoF)
447(5)
Composite (GoF) and Other Design Principles
452(9)
Facade (GoF)
461(2)
Observer/Publish-Subscribe/Delegation Event Model (GoF)
463(8)
Conclusion
471(1)
Recommended Resources
471(4)
Part V Elaboration Iteration 3 --- Intermediate Topics
Iteration 3---Intermediate Topics
475(2)
NextGen POS
476(1)
Monopoly
476(1)
UML Activity Diagrams and Modeling
477(8)
Example
477(1)
How to Apply Activity Diagrams?
478(3)
More UML Activity Diagram Notation
481(1)
Guidelines
482(1)
Example: NextGen Activity Diagram
483(1)
Process: Activity Diagrams in the UP
483(1)
Background
484(1)
UML State Machine Diagrams and Modeling
485(8)
Example
486(1)
Definitions: Events, States, and Transitions
486(1)
How to Apply State Machine Diagrams?
487(2)
More UML State Machine Diagram Notation
489(1)
Example: UI Navigation Modeling with State Machines
490(1)
Example: NextGen Use Case State Machine Diagram
491(1)
Process: State Machine Diagrams in the UP
492(1)
Recommended Resources
492(1)
Relating Use Cases
493(8)
The include Relationship
494(3)
Terminology: Concrete, Abstract, Base, and Addition Use Cases
497(1)
The extend Relationship
497(2)
The generalize Relationship
499(1)
Use Case Diagrams
499(2)
More SSDs and Contracts
501(6)
NextGen POS
501(6)
Domain Model Refinement
507(34)
New Concepts for the NextGen Domain Model
508(1)
Generalization
509(2)
Defining Conceptual Superclasses and Subclasses
511(3)
When to Define a Conceptual Subclass?
514(2)
When to Define a Conceptual Superclass?
516(1)
NextGen POS Conceptual Class Hierarchies
516(3)
Abstract Conceptual Classes
519(2)
Modeling Changing States
521(1)
Class Hierarchies and Inheritance in Software
522(1)
Association Classes
522(3)
Aggregation and Composition
525(2)
Time Intervals and Product Prices---Fixing an Iteration 1 ``Error''
527(1)
Association Role Names
528(1)
Roles as Concepts versus Roles in Associations
529(1)
Derived Elements
530(1)
Qualified Associations
531(1)
Reflexive Associations
532(1)
Using Packages to Organize the Domain Model
532(6)
Example: Monopoly Domain Model Refinements
538(3)
Architectural Analysis
541(18)
Process: When Do We Start Architectural Analysis?
542(1)
Definition: Variation and Evolution Points
542(1)
Architectural Analysis
543(1)
Common Steps in Architectural Analysis
544(1)
The Science: Identification and Analysis of Architectural Factors
545(3)
Example: Partial NextGen POS Architectural Factor Table
548(1)
The Art: Resolution of Architectural Factors
549(7)
Summary of Themes in Architectural Analysis
556(1)
Process: Iterative Architecture in the UP
556(2)
Recommended Resources
558(1)
Logical Architecture Refinement
559(20)
Example: NextGen Logical Architecture
560(5)
Collaborations with the Layers Pattern
565(6)
Other Layer Pattern Issues
571(5)
Model-View Separation and ``Upward'' Communication
576(1)
Recommended Resources
577(2)
More Object Design with GoF Patterns
579(34)
Example: NextGen POS
580(1)
Failover to Local Services; Performance with Local Caching
580(5)
Handling Failure
585(6)
Failover to Local Services with a Proxy (GoF)
591(4)
Designing for Non-Functional or Quality Requirements
595(1)
Accessing External Physical Devices with Adapters
595(2)
Abstract Factory (GoF) for Families of Related Objects
597(3)
Handling Payments with Polymorphism and Do It Myself
600(7)
Example: Monopoly
607(3)
Conclusion
610(3)
Package Design
613(8)
Package Organization Guidelines
614(6)
Recommended Resources
620(1)
UML Deployment and Component Diagrams
621(4)
Deployment Diagrams
621(2)
Component Diagrams
623(2)
Designing a Persistence Framework with Patterns
625(30)
The Problem: Persistent Objects
626(1)
The Solution: A Persistence Service from a Persistence Framework
627(1)
Frameworks
627(1)
Requirements for the Persistence Service and Framework
628(1)
Key Ideas
628(1)
Pattern: Representing Objects as Tables
629(1)
UML Data Modeling Profile
629(1)
Pattern: Object Identifier
630(1)
Accessing a Persistence Service with a Facade
631(1)
Mapping Objects: Database Mapper or Database Broker Pattern
632(2)
Framework Design with the Template Method Pattern
634(1)
Materialization with the Template Method Pattern
634(6)
Configuring Mappers with a MapperFactory
640(1)
Pattern: Cache Management
641(1)
Consolidating and Hiding SQL Statements in One Class
641(1)
Transactional States and the State Pattern
642(3)
Designing a Transaction with the Command Pattern
645(2)
Lazy Materialization with a Virtual Proxy
647(4)
How to Represent Relationships in Tables
651(1)
PersistentObject Superclass and Separation of Concerns
652(1)
Unresolved Issues
652(3)
Documenting Architecture: UML & the N+1 View Model
655(18)
The SAD and Its Architectural Views
656(3)
Notation: The Structure of a SAD
659(1)
Example: A NextGen POS SAD
660(5)
Example: A Jakarta Struts SAD
665(4)
Process: Iterative Architectural Documentation
669(1)
Recommended Resources
669(4)
Part VI Special Topics
More on Iterative Development and Agile Project Management
673(10)
How to Plan an Iteration?
674(1)
Adaptive versus Predictive Planning
674(2)
Phase and Iteration Plans
676(1)
How to Plan Iterations with Use Cases and Scenarios?
676(2)
The (In)Validity of Early Estimates
678(2)
Organizing Project Artifacts
680(1)
You Know You Didn't Understand Iterative Planning When
681(1)
Recommended Resources
681(2)
Bibliography 683(6)
Glossary 689(6)
Index 695

Supplemental Materials

What is included with this book?

The New copy of this book will include any supplemental materials advertised. Please check the title of the book to determine if it should include any access cards, study guides, lab manuals, CDs, etc.

The Used, Rental and eBook copies of this book are not guaranteed to include any supplemental materials. Typically, only the book itself is included. This is true even if the title states it includes any access cards, study guides, lab manuals, CDs, etc.

Excerpts

Thank you for reading this book! If I can answer a question, or for consulting or coaching a team (in OOA/D, UML, modeling, iterative and agile methods), please contact me atwww.craiglarman.com. This is a practical introduction to object-oriented analysis and design (OOA/D), and to related aspects of iterative development. I am grateful that the previous editions were extremely popular worldwide. I sincerely thank all the readers! Here is how the book will benefit you. Design WellFirst, the use of object technology is widespread, so mastery of OOA/D is critical for you to succeed in the software world. Learn a Process RoadmapSecond, if you are new to OOA/D, you're understandably challenged about how to proceed; this book presents a well-defined iterative roadmapan agile approach to the Unified Processso that you can move in a step-by-step process from requirements to code. Learn UML for ModelingThird, the Unified Modeling Language (UML) has emerged as the standard notation for modeling, so it's useful to be able to apply it skillfully. Learn Design PatternsFourth, design patterns communicate the "best practice" idioms OO design experts apply. You will learn to apply design patterns, including the popular "Gang-of-Four" patterns, and the GRASP patterns. Learning and applying patterns will accelerate your mastery of analysis and design. Learn from ExperienceFifth, the structure and emphasis in this book are based on years of experience in education and mentoring thousands of people in the art of OOA/D. It reflects that experience by providing a refined, proven, and efficient approach to learning the subject, so your investment in reading and learning is optimized. Learn from a Realistic StudySixth, it exhaustively examines two case studiesto realistically illustrate the entire OOA/D process, and goes deeply into thorny details of the problem. Design to Code, with TDD & RefactoringSeventh, it shows how to map object design artifacts to code in Java. It also introduces test-driven development and refactor. Layered ArchitectureEighth, it explains how to design a layered architecture and relate the UI layer to domain and technical services layers. Design FrameworksFinally, it shows you how to design an OO framework and applies this to the creation of a framework for persistent storage in a database. Educator and Web Resources You may find related articles of interest atwww.craiglarman.com. Hundreds, if not thousands, of teachers use the book worldwide; it's been translated into at least ten languages. At my website there are a variety of educator resources, including all the book figures organized into Microsoft PowerPoint presentations, sample OOA/D PowerPoint presentations, and more. If you're an educator, please contact me for resources. I am collecting material from existing educators using the book, to share with other educators. If you have anything to share, please contact me. Intended Audiencean Introduction! This book is an introductionto OOA/D, related requirements analysis, and to iterative development with the Unified Process as a sample process; it is not meant as an advanced text. It is for the following audience: Developers and students with some experience in OO programming, but who are newor relatively newto OOA/D. Students in computer science or software engineering courses studying object technology. Those with some familiarity in OOA/D who want to learn the UML notation, apply patterns, or who want to deepen their analysis and design skills. Prerequisites Some prerequisites are assumedand necessaryto benefit from this book: Knowledge and experience in an object-oriented programming language such as Java, C#, C++, or Python. Knowledge of fundamental OO concepts, such as class, instance, interface, polymorphism, encapsulation, and inheritance. Fundamental OO concepts are not defined. Java Examples, But... In general, the book presents code examples in Java due to its widespread familiarity. However, the ideas presented are applicable to mostif not allobject-oriented technologies, including C#, Python, and so on. Book Organization The overall strategy in the organization of this book is that analysis and design topics are introduced in an order similar to that of a software development project running across an "inception" phase (a Unified Process term) followed by three. The inception phase chapters introduce the basics of requirements analysis. Iteration 1 introduces fundamental OOA/D and how to assign responsibilities to objects. Iteration 2 focuses on object design, especially on introducing some high-use "design patterns." Iteration 3 introduces a variety of subjects, such as architectural analysis and framework design.

Rewards Program