Unified Process Explained, The

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

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 Book

The 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



Updates

Submit Errata

