Register your product to gain access to bonus material or receive a coupon.
Unified Process Explained, The
- By Kendall Scott
- Published Nov 26, 2001 by Addison-Wesley Professional.
Book
- Sorry, this book is no longer in print.
Description
- Copyright 2002
- Dimensions: 7-3/8" x 9-1/4"
- Pages: 208
- Edition: 1st
- Book
- ISBN-10: 0-201-74204-7
- ISBN-13: 978-0-201-74204-6
For software developers seeking a more effective approach to design and analysis, the Rational Unified Process (RUP) combines the best ideas from several market-leading analysis and design methodologies, together with best practices proven in real-world enterprise projects. However, many developers and managers find RUP overwhelming when they first encounter it. In this book, Kendall Scott simplifies RUP, scaling it down and organizing it into bite-size chunks that are easy to understand -- and use. The author begins with an overview of RUP, presenting a nutshell description, history, major themes, and key terminology. Next, he introduces each of RUP's five workflows -- Requirements, Analysis, Design, Implementation, and Test -- covering goals, roles, activities, artifacts, and more. Each Activity is illuminated with a diagram clearly explaining its nonlinear nature. Scott details the Inception, Elaboration, and Construction phases of the RUP process, culminating in a description of the Transition phase, in which the project team rolls out its system to customers. From start to finish, Scott relies on the same Internet Bookstore case study that he has used successfully in his best-selling UML Explained. For all software engineers, developers, analysts, architects, project and IT managers seeking to optimize their software development processes; and for every IT professional using or considering RUP.
Sample Content
Online Sample Chapter
Overview of the Unified Process
Downloadable Sample Chapter
Click below for Sample Chapter related to this title:
scottch1.pdf
Table of Contents
1. Overview.
Introduction.
History.
Use Case Driven.
Architecture-Centric.
Understanding the Big Picture.
Organizing the Development Effort.
Facilitating the Possibilities for Reuse.
Evolving the System.
Guiding the Use Cases.
Iterative and Incremental.
Logical Progress Toward a Robust Architecture.
Dealing With Ongoing Changes in Requirements.
Greater Flexibility to Change the Plan.
Continuous Integration.
Early Understanding.
Ongoing Focus on Risk.
The Four Phases.
Inception.
Elaboration.
Construction.
Transition.
The Five Workflows.
Requirements.
Analysis.
Design.
Implementation.
Test.
Iterations and Increments.
Artifacts, Workers, and Activities.
Artifacts.
Workers.
Activities.
2. The Requirements Workflow.
Introduction.
Reach Agreement on the System Context.
List Candidate Requirements.
Identify and Negotiate Functional Requirements.
Specify Nonfunctional Requirements.
Artifacts.
Domain Model.
Business Model.
Glossary.
Actor.
Use Case 24.
User-Interface Prototype.
Use Case Model.
Architecture Description (View of the Use Case Model).
Supplementary Requirements.
Workers.
System Analyst.
Use Case Specifier.
User-Interface Designer.
Architect.
Activities.
Build the Domain Model.
Build the Business Model.
Find Actors and Use Cases.
Prototype the User Interface.
Prioritize the Use Cases.
Detail a Use Case.
Structure the Use Case Model.
3. The Analysis Workflow.
Introduction.
Artifacts.
Analysis Class.
Use Case Realization-Analysis.
Analysis Package.
Analysis Model.
Architecture Description (View of the Analysis Model).
Workers.
Architect.
Use Case Engineer.
Component Engineer.
Activities.
Perform Architectural Analysis.
Analyze a Use Case.
Analyze a Class.
Analyze a Package.
4. The Design Workflow.
Introduction.
Artifacts.
Design Class.
Use Case Realization-Design.
Interface.
Design Subsystem.
Design Model.
Architecture Description (View of the Design Model).
Deployment Model.
Architecture Description (View of the Deployment Model).
Workers.
Architect.
Use Case Engineer.
Component Engineer.
Activities.
Perform Architectural Design.
Design a Use Case
Design a Class.
Design a Subsystem.
5. The Implementation Workflow.
Introduction.
Artifacts.
Component.
Interface.
Implementation Subsystem.
Implementation Model.
Architecture Description (View of the Implementation Model).
Integration Build Plan.
Workers.
Architect.
Component Engineer.
System Integrator.
Activities.
Perform Architectural Implementation.
Implement a Class.
Perform Unit Test.
Implement a Subsystem.
Integrate the System.
6. The Test Workflow.
Introduction.
Artifacts.
Test Case.
Test Procedure.
Test Component.
Test Model.
Test Plan.
Defect.
Test Evaluation.
Workers.
Test Engineer.
Component Engineer.
Integration Tester.
System Tester.
Activities.
Plan Test.
Design Test.
Implement Test.
Perform Integration Test.
Perform System Test.
Evaluate Test.
7. The Inception Phase.
Introduction.
Getting Started.
Plan the Inception Phase.
Expand the System Vision.
Establish the Evaluation Criteria.
Requirements Activities.
Build the Domain Model.
Build the Business Model.
Find Actors and Use Cases.
Prioritize the Use Cases.
Detail a Use Case.
Analysis Activities.
Perform Architectural Analysis.
Analyze a Use Case.
Design Activities.
Perform Architectural Design.
Taking Stock.
Assess Each Iteration.
Assess the Phase as a Whole.
Looking Ahead.
Make the Initial Business Case.
Do Initial Planning for the Elaboration Phase.
8. Elaboration Phase.
Introduction.
Getting Started.
Plan the Elaboration Phase.
Establish the Evaluation Criteria.
Requirements Activities.
Build the Domain Model.
Build the Business Model.
Find Actors and Use Cases.
Prototype the User Interface.
Prioritize the Use Cases.
Detail a Use Case.
Structure the Use Case Model.
Analysis Activities.
Perform Architectural Analysis.
Analyze a Use Case.
Analyze a Class.
Analyze a Package.
Design Activities.
Perform Architectural Design.
Design a Use Case.
Design a Class.
Design a Subsystem.
Implementation Activities.
Perform Architectural Implementation.
Implement a Class.
Perform Unit Test.
Implement a Subsystem.
Integrate the System.
Test Activities.
Plan Test.
Design Test.
Implement Test.
Perform Integration Test.
Perform System Test.
Evaluate Test.
Taking Stock.
Assess Each Iteration.
Assess the Phase as a Whole.
Looking Ahead.
Make the Full Business Case.
Do Initial Planning for the Construction Phase.
9. The Construction Phase.
Introduction.
Getting Started.
Plan the Construction Phase.
Establish the Evaluation Criteria.
Requirements Activities.
Find Actors and Use Cases.
Prototype the User Interface.
Prioritize the Use Cases.
Detail a Use Case.
Structure the Use Case Model.
Analysis Activities.
Perform Architectural Analysis.
Analyze a Use Case.
Analyze a Class.
Analyze a Package.
Design Activities.
Perform Architectural Design.
Design a Use Case.
Design a Class.
Design a Subsystem.
Implementation Activities.
Implement a Class.
Perform Unit Test.
Implement a Subsystem.
Integrate the System.
Test Activities.
Plan Test.
Design Test.
Implement Test.
Perform Integration Test.
Perform System Test.
Evaluate Test.
Taking Stock.
Assess Each Iteration.
Assess the Phase as a Whole.
Looking Ahead.
Do Initial Planning for the Transition Phase.
10. The Transition Phase.
Introduction.
Getting Started.
Plan the Transition Phase.
Establish the Evaluation Criteria.
Activities.
Get the Beta Release Out.
Install the Beta Release.
Respond to Test Results.
Adapt the Product to Varied User Environments.
Complete the Artifacts.
Taking Stock.
Assess Each Iteration.
Assess the Phase as a Whole.
Looking Ahead.
Complete the Business Case.
Do a Postmortem for the Project.
Plan the Next Release or Generation.
Appendix A. The Rational Unified Process.
Workflows.
Project Management.
Business Modeling.
Requirements.
Analysis and Design.
Implementation.
Test.
Configuration and Change Management.
Environment.
Deployment.
Artifact Sets.
Workers.
Appendix B. Extreme Programming and the RUP.
A High-Level View of XP.
Values.
Fundamental Principles.
Development Practices.
XP and the RUP: Common Ground.
XP and the RUP: Key Differences.
So, Is XP an Instance of the RUP Or Not?
Appendix C. The ICONIX Process.
Bibliography.
Glossary.
Index. 0201742047T08212001
Preface
Why This Book?
From the moment the Unified Process made its appearance, I heard many people describing it as really big and complicated, at conferences like UML World and in various public forums, such as Rational's Object Technology User Group (OTUG) mailing list. I agreed that in comparison to other well-known processes, it was rather large, but I didn't think that it was all that complicated, all things considered.
In Chapter 2 of UML Explained, I managed to describe the fundamental concepts that underlie the Unified Process in about ten pages. While I was still writing that book, it occurred to me that I could probably describe the most important details of the Unified Process in a book not much bigger than that one (that is, 200 pages rather than my usual 150 or so). So, I set about writing this book partially to debunk the notion that the process contained just too much for the average person to get his or her arms around, and also to establish that the process doesn't specify tasks that people on a project don't do anyway, in one way or another.
The result is a book that I've specifically conceived as a companion piece to UML Explained. Rather than try to teach you about the UML, which the Unified Process makes fairly heavy use of, I've included references to chapters and sections in that book that offer details about the various UML diagrams and techniques that come into play within the process. I've also brought a number of the diagrams over from that book into this one, to help the continuity and flow across both books. As Picasso said, "Good artists borrow; great artists steal."
Here are some other key features of this book:
- I've made domain modeling and business modeling, which tend to get short shrift in other books about this process, full players, with the associated artifacts and activities part of the Requirements workflow where they belong.
- I've minimized the amount of project management material. Walker Royce's Software Project Management: A Unified Framework (Addison-Wesley, 1998) is the definitive work on how to do project management in conjunction with the Unified Process, and I see no need to try to add value to what he's written.
- Chapters 7 through 9 include the story of how The Internet Bookstore, a sample project, was designed and built. Whereas Chapters 2 through 6 include diagrams from UML Explained relevant to that example, the later chapters explain how the project team broke the system down into chunks in the course of doing iterative and incremental development. Applying Use Case Driven Object Modeling with UML (Rosenberg and Scott, Addison-Wesley, 2001) contains other views of the same bookstore project. (My attitude is, stick with what you know!)
My goal was to write a book that would demystify what people like to call A Real Big Process or some variation of that. I hope you think I've succeeded.
Organization of This BookThe body of this book can usefully be divided into four parts.
The first part comprises Chapter 1. This chapter provides an overview of the Unified Process, in the form of a "nutshell" description, some history, exploration of the major themes (use case driven, architecture-centric, and iterative and incremental), and definitions of the major terminology: workflows, phases, iterations and increments, and artifacts, workers, and activities.
The second part comprises Chapters 2 through 6. These chapters provide the details about the five workflows (Requirements, Analysis, Design, Implementation, and Test) that the process defines. Each chapter includes the following:
- An introduction that offers a brief overview of what's included in the workflow and its primary goals
- Descriptions of the various artifacts that get produced during the workflow
- Descriptions of the various roles that people play during the workflow, expressed in terms of "workers"
- Descriptions of the various activities that workers perform during the workflow in order to produce the artifacts
Each of the Activities sections has a diagram that shows the nonlinear nature of the given workflow. Solid lines on this diagram show logical sequences in which to perform the activities; in some cases, one activity is basically a prerequisite to another activity, whereas in other cases, the work that the team performs for one activity will cause a cycling back to one or more activities that it previously performed. Dashed lines are for data flow: The contents of the artifact that results when one activity is finished feed into the next activity or a previous activity.
The third part comprises Chapters 7 through 9. These chapters provide the details about three of the four phases (Inception, Elaboration, and Construction) that the process defines. Each chapter includes the following:
- An introduction that offers a brief overview of what the project team does during the phase, including its primary goals and a high-level look at how each of the five workflows "cuts across" the phase. (You might think of the workflows and the phases as forming a matrix, with the workflows running down the left-hand side and the phases across the top.)
- A description of the tasks that the project manager should perform before the development team begins the activities defined by the phase.
- Descriptions of the activities, defined by one or more of the workflows, that the project team performs during the phase. These descriptions are expressed in terms of what specifically needs to happen during the phase (the team performs an activity to a greater or lesser extent depending on the context) and also in terms of The Internet Bookstore. The bookstore team did one iteration of Inception, three of Elaboration, and two of Construction; each chapter provides part of their story with text that describes what they did for each activity during each iteration and excerpts from the various models that they produced along the way.
Each of these chapters also calls out the deliverables of the given phase at appropriate places.
The fourth part comprises Chapter 10. This chapter describes the Transition phase, which is the phase during which the project team rolls out the system to its customers. The format for this chapter is the same as that for Chapters 7 through 9. This chapter is in a separate part because workflow activities don't cut across Transition the way they do the other three phases, and because the chapter doesn't discuss the bookstore project.
The book also includes the following end matter:
- Appendix A, which describes what the Rational Unified Process (RUP) adds to the core Unified Process
- Appendix B, which compares and contrasts the RUP with the fundamental aspects of eXtreme Programming (XP)
- Appendix C, which describes the ICONIX process, whose roots are the same as those for the Unified Process
- A bibliography, which lists all the books I mention and a few more for the sake of reference
- A glossary, which contains definitions for all the terms I introduce
- A complete index
0201742047P11142001
Index
A
active class
and architectural design 63
defined 50
activities
Analysis workflow 44
Design workflow 62, 63
Implementation workflow 76
Requirements workflow 28
Test workflow 82
activity 18
activity diagram
defined 51
example 52
and use cases 34
actor
and business model 30
defined 4, 24
and domain model 30
examples 24, 31
finding 30
and requirements 31
versus worker 18
alternate course of action
defined 25
examples 34, 109
length of text 33
Ambler, Scott 110
Analysis and Design workflow (RUP) 148
analysis class
attributes 46
defined 38
and design class 50
expanding 45
refining 46
reuse 41
types 38
analysis model
and architecture description 42
defined 42
as deliverable 95, 110, 132
and deployment model 50
and design model 49, 50
example 96
introduction 37
refining and expanding 49
and use case model 14, 37, 42
analysis package
building 46
defined 41
and design model 63
and design subsystems 56
dividing up tasks 46
examples 42, 113
and use case packages 45
Analysis workflow
and Construction phase 131
and Elaboration phase 109
and Inception phase 95
introduction 37
overview 15
analysis-level class diagram 40, 112
Analyze a Class activity
in Construction phase 132
defined 45
in Elaboration phase 112
Analyze a Package activity
in Construction phase 133
defined 46
in Elaboration phase 113
Analyze a Use Case activity
in Construction phase 132
defined 45
in Elaboration phase 110
in Inception phase 95
architect
Perform Architectural Analysis activity 44
Perform Architectural Design activity 62
Perform Architectural Implementation activity 75
Prioritize the Use Cases activity 33
roles 28, 43, 60, 74
architectural baseline
building 122
defined 101
as deliverable 102
evaluating 122
as evaluation criterion 103
initial definition 12
and models 12, 17
as small, skinny system 12
and system integration 136
testing 124
architectural patterns 6, 63, 64
architectural risks 10
architecturally significant
elements of analysis model 42
elements of deployment model 59
elements of design model 57
elements of implementation model 73
use cases 26
architecture
analyzing 44
defined 5
designing 62
implementing 75
and iterative and incremental development 8
layers 110
modifying 127
real-world realization 69
reasons for importance 5, 6, 7
and use cases 7
architecture description
analysis model 42
defined 5
as deliverable 106, 110, 129, 145
deployment model 59
design model 57
implementation model 73
outline 44
purpose 6
and risks 10
use case model 26
architecture-centric 5
artifact 18
artifacts
Analysis workflow 38
Design workflow 50
Implementation workflow 70
Requirements workflow 21
Test workflow 79
B
basic course of action
defined 25
examples 34, 94, 109
length of text 33
Beck, Kent 151, 153
beta release
and Construction phase 127
installing 143
releasing 142
big picture 6
black-box testing
and test cases 79
and test procedures 80
and unit testing 77
blueprint 49
Booch, Grady 3
boundary object
defined 38
examples 40, 111
notation 38
brainstorming 29
Build the Business Model activity
defined 30
in Elaboration phase 105
in Inception phase 92
Build the Domain Model activity
defined 29
in Elaboration phase 104
in Inception phase 91
builds
defined 8
and integration build plan 73
and stubs 136
and system integration 78
business actor 23
business case
completing 145
defined 99
as deliverable 100, 126, 140
as evaluation criterion 90, 104
finalizing 12
and Inception phase 87
initial version 99
making 125
starting 11
updating 140
and vision statement 89
business entity 23
business model
and actors 30
building 30
defined 20, 23
as deliverable 92, 105
and domain model 30
and Requirements workflow 30
and use cases 30
Business Modeling workflow (RUP) 148
business object model 23
business processes 20
business use case 23
business use case model 23
C
candidate architecture
defined 87
as deliverable 92
and Elaboration phase 12
as evaluation criterion 90
expanding into baseline 109
and Inception phase 12
initial definition 11
candidate requirements 20
change control board 143
class
analyzing 45
designing 65
implementing 75
responsibilities 46
class diagram
analysis-level 40
defined 22
design-level 54
domain-level 23
examples 22, 91, 105, 112, 117
class flow graph 77
cohesion 45, 46
Coleman, Russ 123
collaboration
defined 39
examples 41, 65
collaboration diagram
defined 53
example 55
component
versus class 70
defined 70
and design classes 76
examples 71, 72
and nodes 58
testing 76
component diagram
defined 70
examples 71, 119, 120
component engineer
Analyze a Class activity 46
Analyze a Package activity 46
Design a Class activity 65
Design a Subsystem activity 66
Implement a Class activity 76
Implement a Subsystem activity 78
Implement Test activity 84
Perform Unit Test activity 77
roles 43, 62, 74, 81
component-based development (CBD) 6
concurrency
and active classes 50
on activity diagram 51
and architectural design 63
Configuration and Change Management workflow (RUP) 149
conformance-directed testing 83
constraint 21
Construction phase
deliverables 128, 129, 132, 133, 135, 137, 140
evaluation criteria 129
and five workflows 127
overview 13
planning 126, 128
primary goal 127
tasks 13
context 91
inside versus outside 99
reaching agreement 20
context diagram 31
control flow graph 77
control object
defined 39
examples 40, 111
notation 39
and state diagrams 51
coupling 46
of analysis packages 45
of classes 46
of design subsystems 66
of implementation subsystems 78
coverage 84
cycle 10
D
defect
defined 80
and test evaluation 81
and test model 79
and Transition phase 143
Deployment artifact set 150
deployment component 70
deployment diagram
defined 59
example 60
deployment model
and analysis model 50
and architecture description 59
defined 58
as deliverable 96, 114, 133
example contents 61, 114
expanding 69
introduction 49
and use case model 14
deployment package
and deployment model 59
example 61
Deployment workflow (RUP) 149
Design a Class activity
in Construction phase 134
defined 65
in Elaboration phase 115
Design a Subsystem activity
in Construction phase 134
defined 66
in Elaboration phase 116
Design a Use Case activity
in Construction phase 133
defined 64
in Elaboration phase 114
Design artifact set 149
design class
and analysis class 50
attributes 66
and components 76
defined 50
expanding 75
operations 65
reuse 56
design mechanisms 63
design model
and analysis model 49, 50
and analysis packages 63
and architecture description 57
defined 56
as deliverable 96, 114, 115, 133
example contents 57, 58, 98, 115, 117
and implementation model 69
introduction 49
and use case model 14
design package
and design model 56
examples 57, 58
design patterns 64
design subsystem
and analysis packages 56
defined 56
example 134
and implementation subsystems 72, 78
Design Test activity
in Construction phase 137
defined 83
in Elaboration phase 123
Design workflow
and Construction phase 133
and Elaboration phase 113
and Inception phase 95
introduction 49
overview 15
design-level class diagram 54
Detail a Use Case activity
in Construction phase 131
defined 33
in Elaboration phase 108
in Inception phase 94
document stereotype 70
domain model
and actors 30
building 29
and business model 30
defined 20, 22
as deliverable 91, 104
and prototypes 32
and Requirements workflow 29
and use cases 30, 33
domain-level class diagram 23, 91, 105
E
Elaboration phase
deliverables 102, 103, 104, 105, 106, 110, 114, 115, 118, 121, 126
evaluation criteria 103
and five workflows 102
overview 12
planning 100, 103
primary goals 101
tasks 12
engineering artifacts 18
entity object
defined 39
examples 40, 111
notation 39
Environment workflow (RUP) 149
Evaluate Test activity
in Construction phase 139
defined 84
in Elaboration phase 124
example project
introduction 1
Iteration 1 91, 92, 93, 94, 95, 97
Iteration 2 104, 106, 107, 108, 110, 111, 114, 115, 116, 117, 118, 123
Iteration 3 104, 106, 107, 108, 111, 113, 115, 116, 117, 123
Iteration 4 104, 106, 107, 108, 111, 112, 116, 117, 119, 120, 121, 122, 123, 124
Iteration 5 130, 131, 132, 133, 134, 135, 136, 137, 138, 139
Iteration 6 131, 135, 136, 137, 138, 139
exceptional flow of events
defined 25
examples 34, 109
length of text 33
executable stereotype 70
execution component 70
extend relationship
defined 35
example 36
extension point
defined 35
example 36
Extreme Programming (XP)
common ground with RUP 154
development practices 153
differences from RUP 155
fundamental principles 152
versus ICONIX process 157
initial definition 151
values 151
F
fault efficiency 83
fault-directed testing 83
feature list
defined 20
as deliverable 88
and Inception phase 88
feature sufficiency 83
file stereotype 70
Find Actors and Use Cases activity
in Construction phase 129
defined 30
in Elaboration phase 106
in Inception phase 92
flow of events 25
flowchart 34, 51
framework
defined 63
example 65
functional decomposition 4
G
generalization
examples 36
of use cases 36
glossary
and Build the Domain Model activity 29
defined 23
grammatical inspection 29
I
ICONIX process
big picture 158
versus Extreme Programming (XP) 157
versus RUP 157
traceability 157
-ilities 10, 90
Implement a Class activity
in Construction phase 135
defined 75
in Elaboration phase 120
Implement a Subsystem activity
in Construction phase 136
defined 78
in Elaboration phase 122
Implement Test activity
in Construction phase 137
defined 84
in Elaboration phase 123
Implementation artifact set 150
implementation model
and architecture description 73
building 75
defined 72
as deliverable 118, 135
and design model 69
example contents 119, 120
and use case model 14
implementation package
example 73
and implementation model 72
implementation subsystem
defined 72
and design subsystems 72, 78
Implementation workflow
and Construction phase 135
and Elaboration phase 118
introduction 69
overview 15
Implementation workflow (RUP) 148
implementation-based testing 77
Inception phase
deliverables 88, 89, 90, 91, 92, 93, 95, 96, 100
evaluation criteria 90
and five workflows 88
overview 11
planning 89
primary goal 87
tasks 11
include relationship
defined 35
examples 35
increment 7, 16
Initial Operational Capability major
milestone 13
Integrate the System activity
in Construction phase 136
defined 78
in Elaboration phase 122
integration build plan
creating 78
defined 73
expanding 78
integration tester
Perform Integration Test activity 84
roles 81
integration testing
defined 83
performing 84
interface
class 55
component 71
defined 55
examples 56, 72
Internet time 6
iteration
assessing 98, 125, 139, 145
defined 7, 16
iterative and incremental
advantages 7, 8, 9
basic steps 16
illustrated 17
and models 17
J
Jacobson, Ivar 2, 3, 23, 157
JAD
see Joint Application Development (JAD)
Joint Application Development (JAD) 31
L
library stereotype 70
Life-Cycle Architecture major milestone 12
Life-Cycle Objectives major milestone 12
M
main flow of events
defined 25
examples 34, 94, 109
length of text 33
maintenance 6
major milestone
defined 10
Initial Operational Capability 13
Life-Cycle Architecture 12
Life-Cycle Objectives 12
Product Release 13
make versus buy 10
management artifacts 18
Management artifact set 149
method flow graph 77
models
analysis 15
and architectural baseline 17
defined 1
deployment 15
design 15
implementation 15
and iterative and incremental development 17
test 16
use case 14
Model-View-Controller (MVC)
architectural pattern 65
momentum 9
N
negative testing 80
node
defined 58
examples 59, 60
nonfunctional requirements 32, 83
capturing 32
defined 21
and supplementary requirements 26
and system testing 83
noun-verb analysis 29
O
Objectory 2, 3
OML
see Open Modeling Language (OML)
Open Modeling Language (OML) 36
P
package
analyzing 46
defined 25
examples 26, 42, 57, 58, 61, 65, 67, 73, 113
patterns
architectural 6, 63
defined 63
design 64
examples 64, 65
Perform Architectural Analysis activity
in Construction phase 132
defined 44
in Elaboration phase 109
in Inception phase 95
Perform Architectural Design activity
in Construction phase 133
defined 62
in Elaboration phase 113
in Inception phase 96
Perform Architectural Implementation activity
defined 75
in Elaboration phase 118
Perform Integration Test activity
in Construction phase 138
defined 84
in Elaboration phase 124
Perform System Test activity
in Construction phase 138
defined 84
in Elaboration phase 124
Perform Unit Test activity
in Construction phase 135
defined 77
in Elaboration phase 121
phase
assessing 99, 125, 139, 145
defined 10
phases
Construction 13
Elaboration 12
Inception 11
Transition 13
Plan Test activity
in Construction phase 136
defined 82
in Elaboration phase 122
postmortem 8, 17, 146
Prioritize the Use Cases activity
in Construction phase 131
defined 33
in Elaboration phase 108
in Inception phase 93
problem space 22, 29, 158
Product Release major milestone 13
Project Management workflow (RUP) 148
project plan
as deliverable 89, 103, 129
initial version 89
updating 17, 103, 128, 142
prototype
and actors 30, 32
as artifact 25
and domain model 32
and ICONIX process 158
and requirements 8, 25
and use cases 21, 30, 32
Prototype the User Interface activity
in Construction phase 130
defined 32
in Elaboration phase 107
Proxy design pattern 64
R
Rational Objectory Process (ROP) 3
Rational Unified Process (RUP)
see RUP
realization 55
realize 55
regression testing 83
requirements
and actors 31
dealing with changes 8
difficulty in capturing 19
as evaluation criteria 90, 103
and features 21
negotiating 8, 10, 19, 21, 38
and system testing 83
traceability 157
and use cases 4, 21, 33
Requirements artifact set 149
requirements risk 8, 10, 102
Requirements workflow
and Construction phase 129
and Elaboration phase 104
and Inception phase 91
introduction 19
overview 14
Requirements workflow (RUP) 148
responsibility-based testing 77
reuse
of analysis classes 41
and Analysis workflow 37
and architecture 5, 6
of design classes 56
of project artifacts 146
of test cases 83
right system 10, 19
risk list
as deliverable 90, 104
initial version 90
updating 17
risks
categories 9
and Construction phase 127
critical 11, 16, 87, 90, 101, 103, 127
and Elaboration phase 101, 102
as evaluation criteria 90, 103
and Inception phase 87
and iterative and incremental development 8, 9
preliminary assessment 89
significant 12, 93, 101, 102, 103, 108, 127
and test design 83
and test planning 83
robustness analysis
defined 39
and ICONIX process 159
and use cases 45
robustness diagram
and Analyze a Use Case activity 45
characteristics 45
defined 40
and Design a Use Case activity 64
examples 40, 96, 97, 111
and packages 42
Rosenberg, Doug 29, 157
Rumbaugh, Jim 3
RUP
common ground with XP 154
contents 147
differences from XP 155
history 3
versus ICONIX process 157
versus Unified Process 1
workflows 147
ruthless prioritization 8
S
scaffolding 6
scope
as evaluation criterion 90
defining 11
and Inception phase 87
sequence diagram
defined 52
examples 54, 116, 117
service 41
service package 41
service subsystem 56
small, skinny system 12
special requirements
and Analysis workflow 45, 46
defined 32
and Design workflow 65
and Requirements workflow 32
specification testing 77
state diagram
defined 51
example 53
and unit testing 77
statechart diagram
defined 51
example 53
storyboards 25
stress testing 80
structural testing 77
Structure the Use Case Model activity
in Construction phase 131
defined 35
in Elaboration phase 109
subsystem
designing 66
examples 67
implementing 78
supplementary requirements 26, 32
system analyst
Build the Business Model activity 30
Build the Domain Model activity 29
Find Actors and Use Cases activity 30, 135
roles 27
Structure the Use Case Model activity 35
system integrator
Integrate the System activity 78
roles 75
system tester
Perform System Test activity 84
roles 82
system testing
focus 83
performing 84
T
table stereotype 70
technical risks 10, 102
test case
and black-box testing 79
defined 79
integration testing 83
reusing 83
system testing 83
and test procedures 80
and white-box testing 80
test component
creating 84
defined 80
test engineer
Design Test activity 83
Evaluate Test activity 84
Plan Test activity 82
roles 81
test evaluation
building 84
defined 81
test harness 80
test model
building 83
contents 83, 84
defined 80
as deliverable 121, 137
and use case model 14
test plan
defined 80
developing 82
test procedure
and black-box testing 80
defined 80
reusing 83
and test components 80
and white-box testing 80
test script 80
test strategy 83
Test workflow
and Construction phase 136
and Elaboration phase 122
introduction 79
overview 15
Test workflow (RUP) 148
three amigos 3
traceability
of classes 65
of models 49
of packages 46, 63, 65
of requirements 4, 32, 157
of subsystems 65, 72, 78
Transition phase
deliverables 143, 144, 145
evaluation criteria 142
and five workflows 141
overview 13
planning 140, 142
primary goal 141
tasks 13
U
use case
alternate course of action 25
analyzing 45
and architecture 7
basic course of action 25
and black-box testing 79
and business model 30
defined 4, 21, 24
designing 64
detailing 33
and domain model 30, 33
examples 25, 31
exceptional flow of events 25
and extend relationship 35
features 4
finding 30
generalization 36
good qualities 33
and ICONIX process 158
and include relationship 35
main flow of events 25
prioritizing 33
and prototypes 21
and requirements 21, 33
versus requirements 4
and system decomposition 4
and system testing 83
and test planning 83
use case diagram
defined 20, 31
examples 31, 93, 94, 107, 130
use case driven 4, 157
use case engineer
Analyze a Use Case activity 45
Design a Use Case activity 64
roles 43, 61
use case model
and analysis model 37
and architecture description 26
defined 25
as deliverable 92, 106, 129
example contents 26
and other models 14
refining and expanding 37
structuring 35
use case package
and analysis packages 45
dividing up tasks 32
example 26
use case ranking list 93
use case realizationnanalysis
defined 39
examples 41
realizing physically 51
use case realizationndesign
defined 51
example 54
and integration testing 83
and white-box testing 80
use case specifier
Detail a Use Case activity 33
roles 27
user acceptance testing 143
user interface
attributes 46
prototyping 32
user manual 21, 144
user-interface designer
Prototype the User Interface activity 32
roles 27
user-interface prototype
as artifact 25
building 32
V
vision statement 89
W
waterfall 8
white-box testing
and test cases 80
and test procedures 80
and unit testing 77
work product component 70
work unit 23
worker
versus actor 18
defined 18
in RUP 150
workers
Analysis workflow 43
Design workflow 59
Implementation workflow 74
Requirements workflow 27
Test workflow 81
workflow 13
workflows
Analysis 15
Design 15
Implementation 15
Requirements 14
Test 15
wrapping 56
X
XP
see Extreme Programming 151