Please enable JavaScript.
Coggle requires JavaScript to display documents.
Evolution of Software Development Process Models (Unified Process…
Evolution of Software
Development Process Models
Waterfall Model
Incremental
development model
RAD Model
requirements are well understood
and project scope is constrained
Processes in the RAD model
Business modeling
Data Modeling
Process Modeling
Application generation
Testing and turnover
Issues of using
Sufficient human resources
System modularity is a must
Not applicable when
technical risks are high
Evolutionary Models
Prototyping
Throw-away Prototyping
suitable if the requirements
are vague but
stable
Executable prototype +
System specification
objective is to understand
system requirements clearly
Issues
Other features leftout>Non-functional requirements
An implementation has no legal standing as a contract between
customer and contractor
Evolutionary Prototyping
Delivered system
Effort of prototype is not wasted
suitable for projects with vague and
unstable
requirements
The Spiral
Each loop in the spiral represents a phase in the
process
No fixed phases such as specification or design
Loops in the spiral are chosen depending on what is
required
Spiral Rounds
Planning
Estimation
Scheduling
Risk analysis
Modelling
Analysis
Design
Construction
Code
Test
Deployment
Delivery
Feedback
Communication
Combination of waterfall & incremental
Each phase in spiral model begins
with a design goal and ends with
the client reviewing the progress
starts with a small set of requirement and
goes through each development phase
for those set of requirements
Unified Process
What?
Use-case Driven
Each iteration takes a set of use cases/scenarios
from requirements all the way through
implementation, test and deployment.
Architecture-Centric
Understandability
Reliance to future changes
Reuse
executable architecture baseline
which is created during the Elaboration phase
Process
Iterative
and Incremental
Incremental
Scheduling and staging strategy
Various parts of system are developed at different times
Then integrated
Output
> Released to customers
Iterative
Rework scheduling strategy
Time is set aside to revise and
improve parts
Output
>examined for modification
Risk focused
greatest risks are
addressed first
Object-Oriented Approach
UML and UP are used together
Not
a process framework to guide the project
team
to apply OO practices
Provide Necessary technology to
support
OO
4 phases
Inception
Work Products
Vision document
Initial use-case model
Initial project glossary
Initial business case
Initial risk assessment .
Project plan>
phases and iterations.
Business model
One or more prototypes
key difference with other phases>
no time-box iterations unless its a
large project
elaboration
Work Products
Use-case model
Supplementary requirements
including non-functional
Analysis model
Software architecture
description
Executable architectural
prototype
Preliminary design model
Revised risk list
Project plan including>
Iteration plan
Adapted workflows
Milestones
Technical work products
Preliminary user manual
Implementation Model
Deployment Model
Construction
Work Products
Design model
Software components
Integrated software
Increment
Test plan and
procedure
Test cases
Support documentation>
User manuals
Installation manuals
Description of
current increment
largest phase
short, time-boxed iterations
Each increment>
All increments started in
elaboration phase to be
completed
Transition
Work Products
Delivered software
increment
Beta test reports
General user feedback
6 Disciplines/workflows
Business Modeling
Requirements
Analysis and design
Implementation
Testing & Deployment
Workflows (process areas)
Distributed over all UP phases
Workflow includes several
Tasks
>
results
Work Products
Different refinements
Agile Unified Process (AUP)
Basic Unified Process (BUP)
Enterprise Unified Process (EUP)
Essential Unified Process (EssUP)
Open Unified Process (OpenUP)
Rational Unified Process (RUP)
Oracle Unified Method (OUM)
Rational Unified Process-System Engineering (RUP-SE)
Best Practices
• Manage risk
• Execute your project in iterations
• Embrace and manage change
• Measure progress objectively
• Test your own code
• Leverage test automation appropriately
• Everyone owns the product
• Understand the domain
• Describe requirements from user perspective
• Prioritize requirements for implementation
• Leverage legacy systems
• Build high-performance teams
• Organize around the architecture
• Manage versions
• Leverage patterns
• Architect with components and services
• Actively promote reuse
• Model key perspectives
• Right size your process
• Continuously reevaluate what you do
