Introduction to Rational Unified Process

Objectives: Rational Unified Process

• Describe the Unified Modeling Language (UML)

• Define what a software development process is
• Describe the Rational Unified Process
• Explain the four phases of the Rational Unified Process
and their associated milestones
• Define iterations and their relation to phases
• Explain the relations between:
– Models and workflows
– Phases, iterations, and workflows
• Define artifact, worker, and activity
• State the importance of automated tool support
Building a System - A Language Is Not Enough

Team-Based
Development

Modeling
Process
Language
 What Is the UML?
• The Unified Modeling Language (UML) is a
language for
• Specifying
• Visualizing
• Constructing
• Documenting
the artifacts of a software-intensive system
UML History
 Inputs to UML
Booch
Rumbaugh Jacobson
Fusion
Meyer
Operation descriptions,
Before and after
Message numbering
conditions

Embley
Harel
Singleton classes,
State charts High-level view

Gamma, et.al
Wirfs-Brock
Frameworks, patterns,
Responsibilities
notes Shlaer - Mellor Odell

Object Lifecycles Classification

The UML Provides Standardized Diagrams
State
State
Diagrams
Class
Diagrams
Use Case Diagrams
Use Case
Diagrams State
Use Case Use Case
Diagrams State
Diagrams
Use Case Diagrams Object
Diagrams
Diagrams
Activity Diagrams
Diagrams
Diagrams

Scenario State
Scenario
Diagrams State
Diagrams
Sequence
Diagrams State
Diagrams
Diagrams Model Diagrams

Scenario Component
Scenario
Diagrams
Component
Diagrams
Component
Collaboration
Diagrams Deployment Diagrams
Diagrams Diagram Diagrams
A Sample UML Diagram: Use Cases
A University Course Registration System

Login

Registrar Maintain Professor Information

View Report Card

Student
Register for Courses Maintain Student Information

Course Catalog
Close Registration Billing System
Select Courses to Teach

Professor

Submit Grades
 A Sample UML Diagram: Classes
<<boundary>>
<<boundary>> MaintainScheduleForm
MainForm

1 0..1
// select maintain schedule() + // open()
+ // select 4 primary and 2 alternate offerings()

1
<<boundary>> <<control>>
1 0..*
CourseCatalogSystem RegistrationController

// get course offerings() // add courses to schedule()

// get course offerings ()
0..1

A University Course Registration System

1

<<entity>>
Schedule

// create with offerings()

 UML Diagrams Are Key System Artifacts
Use-Case
Class Diagram State Diagram
Diagram FileMgr
DocumentList
Document
add file

add( )
name : int
fetchDoc( ) delete( ) docid : int
sortByName( ) numField : int
Writing
add file [ numberOffile==MAX ] /
get( ) flag OFF
open( ) read() fill the
close( ) code..
FileList read( )
sortFileList( ) Openning

Use Case 1 add( )

fList create( )
fillDocument( )
delete( )
1 close file

Actor A Actor B
close file
Closing
Reading

rep
Use Case 2 File

<<entity>>
Repository

Customer
(from Persistence) GrpFile
read( )

name
name : char * = 0

Domain
read( )
readDoc( )

addr
open( )

Deployment
readFile( )
create( )
fillFile( )

receive()
withdraw()
Expert
Use Case 3
fetch()
send()

Diagram
UI

MFC Class
DocumentApp

ºÐ»ê ȯ°æÀÇ Çϵå¿þ¾î¹× ³×Æ®¿÷À¸·ÎÀÇ Á¤º¸ ½Ã½ºÅÛ ¿¬°á ¸ðµ¨

- À©µµ¿ì 95 : Ŭ¶óÀ̾ðÆ®
- À©µµ¿ì NT: ÀÀ¿ë¼-¹ö
- À¯´Ð½º ¸Ó½Å: ÀÀ¿ë ¼-¹ö ¹× µ¥ÀÌŸ ¼-¹ö, Åë½Å ¼-¹ö
- IBM ¸ÞÀÎÇÁ·¹ÀÓ: µ¥ÀÌŸ ¼-¹ö, Åë½Å ¼-¹ö

DocumentList
RogueWave

Persistence
Repository Window95 Windows95

9: sortByName ( ) Windows95

global

¹®¼-°ü¸®

FileManager Ŭ¶óÀ̾ðÆ®.EXE
¹®¼-°ü¸® ¾ÖÇø´

mainWnd : MainWnd Windows

NT

Package
1: Doc view request ( ) L

Document Solaris

2: fetchDoc( )
¹®¼-°ü¸® ¿£Áø.EXE

4: create ( ) gFile : GrpFile

Alpha
UNIX
8: fillFile ( ) ÀÀ¿ë¼-¹ö.EXE

User Interface Diagram

Windows
NT

user : »ç¿ëÀÚ GraphicFile IBM

fileMgr : FileMgr Mainframe

3: create ( )
File FileList
6: fillDocument ( )

Definition
µ¥ÀÌŸº£À̽º¼-¹ö

7: readFile ( )

5: readDoc ( )
document : Document
repository : Repository

Forward Engineering(Code Generation)

Collaboration Diagram Component and

mainWnd fileMgr : document : gFile repository

Diagram Reverse Engineering
user FileMgr Document

Source Code edit, compile, debug, link

ƯÁ¤¹®¼-¿¡ ´ëÇÑ º¸±â¸¦ 1: Doc view request ( )
»ç¿ëÀÚ°¡¿äûÇÑ´Ù.

2: fetchDoc()

3: create ( )

4: create ( )

5: readDoc ( )

È-ÀÏ°ü¸®ÀÚ´Â Àоî¿Â 6: fillDocument ( )

¹®¼-ÀÇ Á¤º¸¸¦ ÇØ´ç ¹®¼-
°´Ã¼¿¡ ¼³Á¤À» ¿äûÇÑ́Ù.

7: readFile ( )

8: fillFile ( )

È-¸é °´Ã¼´Â ÀоîµéÀÎ 9: sort ByName ( )

°´Ã¼µé¿¡ ´ëÇØ À̸§º°·Î
Á¤·ÄÀ» ½ÃÄÑ È-ȩ́¿¡
º¸¿©ÁØ´Ù.

Sequence Diagram

Executable System
 What Is a Process?
A process defines Who is doing What, When
and How to reach a certain goal. In software
engineering the goal is to build a software
product or to enhance an existing one

New or changed Software Engineering New or changed

requirements system
Process
 An Effective Process ...
• Provides guidelines for efficient development of quality
software
• Reduces risk and increases predictability
• Captures and presents best practices
– Learn from other’s experiences
– Mentor on your desktop
– Extension of training material
• Promotes common vision and culture
• Provides roadmap for applying tools
• Delivers information on-line, at your finger tips
 Rational Unified Process Delivers
Best Practices
Rational Unified Process describes how to effectively implement the six
best practices for software development

Manage Requirements

Use
Develop Model Verify
Visually Component
Iteratively Quality Architectures

Control Changes
 Rational Unified Process Is Use-Case
Driven
An actor is
someone or
Check Balance
Client something
outside the
system that
interacts with
Withdraw Money the system
A use case is a
Use Cases for a Cash Machine sequence of
actions a system
performs that
yields an
observable
 Use Cases Include a Flow of Events

Flow of events for the Withdraw Money Use Case

1. The use case begins when the client inserts her ATM card. The
system reads and validates information on the card.
2. The system prompts for the PIN. The system validates the PIN.
3. The system asks which operation the client wishes to perform.
The client selects “Cash withdrawal.”
4. The system requests the amount. The client enters the amount.
5. The system requests the account type. The client selects
checking or savings.
6. The system communicates with the ATM network . . .
Benefits of a Use-Case Driven Process
• Use cases are concise, simple, and understandable by a wide range
of stakeholders
– End users, developers and acquirers understand functional
requirements of the system
• Use cases drive numerous activities in the process:
– Creation and validation of the design model
– Definition of test cases and procedures of the test model
– Planning of iterations
– Creation of user documentation
– System deployment
• Use cases help synchronize the content of different models
 Rational Unified Process Is
Architecture-Centric
• Architecture is the focus of the elaboration phase
– Building, validating, and baselining the architecture
constitute the primary objective of elaboration
• The Architectural Prototype validates the architecture
and serves as the baseline for the rest of development
• The Software Architecture Description is the primary
artifact that documents the architecture chosen
• Other artifacts derive from architecture:
– Design guidelines including use of patterns and
idioms
– Product structure
– Team structure
Representing Architecture: The 4+1 View Model

Logical Implementation
View View

Analysts/
End-user Programmers
Designers
Structure Functionality Software management
Use-Case
View
Process Deployment
View View
System Integrators System Engineering
Performance System topology
Scalability Delivery, installation
Throughput communication
 Benefits of an Architecture-
Centric Process
• Architecture lets you gain and retain intellectual control over a
project, to manage its complexity, and to maintain system
integrity
• Architecture provides an effective basis for large-scale reuse
• Architecture provides a basis for project management
• Architecture facilitates component-based development
– A component fulfills a clear function in the context of a
well-defined architecture
– A component conforms to and provides the physical
realization of a set of interfaces
– Components exist relative to a given architecture
 Process Architecture –
Lifecycle Phases
Inception Elaboration Construction Transition

time

The Rational Unified Process has four phases:

– Inception - Define the scope of project
– Elaboration - Plan project, specify features, baseline
architecture
– Construction - Build the product
– Transition - Transition the product into end user
community
 Phase Boundaries Mark Major
Milestones

Inception Elaboration Construction Transition

time

Lifecycle Lifecycle Initial Operational Product

Objective Architecture Capability Release
Milestone Milestone Milestone
 Iterations and Phases
Inception Elaboration Construction Transition

Preliminary Architect. Architect. Devel. Devel. Devel. Transition Transition

Iteration Iteration Iteration Iteration Iteration Iteration Iteration Iteration

Minor Milestones: Releases

An iteration is a distinct sequence of activities with an

established plan and evaluation criteria, resulting in
an executable release (internal or external)
 Major Workflows Produce Models
Business
Modeling supported by
Business Model

Requirements realized by
Use-Case
Model
Analysis &
Design implemented by
Design
Model

Implementation verified by

Implementation
Model
Test

Test
Model
 Bringing It All Together: The Iterative Model
In an
Phases iteration, you
Process Workflows Inception Elaboration Construction Transition
walk through
Business Modeling all
workflows
Requirements
Analysis & Design
Implementation
Test
Deployment
Supporting
Workflows
Configuration Mgmt
Management
Workflows Environment
group Preliminary Iter. Iter. Iter. Iter. Iter. Iter. Iter.
Iteration(s) #1 #2 #n #n+1 #n+2 #m #m+1
activities
logically Iterations
Summary: Rational Unified Process
• The Unified Modeling Language (UML) is a language
for specifying, visualizing, constructing, and
documenting the artifacts of a software-intensive
system
• A software development process defines Who is doing
What, When and How in building a software product
• The Rational Unified Process has four phases:
Inception, Elaboration, Construction and Transition
• Each phase ends at a major milestone and contains
one or more iterations
• An iteration is a distinct sequence of activities with an
established plan and evaluation criteria, resulting in an
executable release