You are on page 1of 93

Software Processes

Objectives
To introduce software process models To describe generic process models and when

they may be used To describe outline process models for requirements engineering, software development, testing and evolution To explain the Rational Unified Process (RUP) model To introduce CASE technology to support software process activities

Topics Covered
Software process models Process iteration

Process activities
The Rational Unified Process Computer-Aided Software Engineering

Generic Process Framework


Communication heavy communication and collaboration with customers and stakeholders requirements gathering and other related activities Planning plan for SE work that follows technical tasks to be conducted risk analysis and management resources required work products to be produced work schedule

Generic Process Framework


Modeling creation of models for better understanding of software requirements design that will achieve those requirements Construction Code generation (either manual or automated) Testing to uncover errors in code Deployment detail of software process will be quite

different in each case, but framework activities remain the same

The Software Process


Software development: involves activities

related to each other Software process: structured set of activities required to develop a software system Activities vary depending on the organization and the type of system being developed Must be explicitly modeled if it is to be managed

The Software Process


A structured set of activities required to develop a

software system Specification; Design; Validation; Evolution. A software process model is an abstract representation of a process. It presents a description of a process from some particular perspective.

Process Characteristics
Understandability

is the process defined and understandable? is the process progress visible?

Visibility

Supportability

can the process be supported by CASE tools?


is the process acceptable to those involved in it?

Acceptability

Process Characteristics
Reliability are process errors discovered before they result in product errors Robustness can the process continue in spite of unexpected problems? Maintainability can the process evolve to meet changing needs? Rapidity how fast can the system be produced?

Engineering Process Model


Specification: set out the requirements and

constraints on the system Design: produce a paper model of the system Manufacture: build the system Test: check the system meets the required specifications Install: deliver the system to the customer and ensure it is operational Maintain: repair faults in the system as they are discovered

Software Process Model


Normally, specifications are incomplete/not

clear No clear distinction between specification, design and manufacture No physical realization of the system for testing Software does not wear out

maintenance does not mean component replacement

Generic Software Process Models


The Waterfall Model Evolutionary development Incremental Model Spiral Model Component-based software engineering Rapid Application Development Model (RAD) Aspect Oriented Software Development Formal Transformation

Waterfall Model
Separate

and distinct phases of specification and development.

Waterfall Model
Com m unic a t ion
proje c t init ia t ion re quire m e nt ga t he ring

Planning
es timating sc heduling tra cking

Mode ling
analysis design

Const r uc t ion
code t est

De ploy m e nt
de liv e ry s upport f e e dba c k

Waterfall Model Phases


Requirements analysis and definition System and software design Implementation and unit testing Integration and system testing Operation and maintenance Drawback

The main drawback of the waterfall model is the difficulty of accommodating change after the process is underway. One phase has to be complete before moving onto the next phase.

Waterfall Model Problems


Inflexible partitioning of the project into distinct

stages makes it difficult to respond to changing customer requirements. Therefore, this model is only appropriate when the requirements are well-understood and changes will be fairly limited during the design process. Few business systems have stable requirements. The waterfall model is mostly used for large systems engineering projects where a system is developed at several sites. Product is delivered at a later stage

Generic Software Process Models


The Waterfall Model

Evolutionary Development
Incremental Model Spiral Model Component-based Software Engineering Rapid Application Development Model (RAD)

Aspect Oriented Software Development Formal Transformation

Evolutionary Development Model


Specification, development and validation are

interleaved. Exploratory development

Objective is to work with customers and to evolve a final system from an initial outline specification. Should start with well-understood requirements and add new features as proposed by the customer.

Throw-away prototyping Objective is to understand the system requirements. Should start with poorly understood requirements to clarify what is really needed.

Evolutionary Development

Evolutionary Models - Prototyping


Q u i ck p l an

Co m m u n icat io n

Mo d e l i n g Q u i ck d e si g n

Deployment De live r y & Fe e d b ack

Co n st r u ct io n of p r o t o t yp e

Evolutionary Development Model

Evolutionary Development - Concurrent


none Modeling act ivit y

Under development

represents the state of a software engineering activity or task

A wait ing changes

Under review Under revision Baselined

Done

Evolutionary Development
Problems

Lack of process visibility; Systems are often poorly structured; Special skills (e.g. in languages for rapid prototyping) may be required.

Applicability

For small or medium-size interactive systems; For parts of large systems (e.g. the user interface); For short-lifetime systems.

Process Iteration
System requirements ALWAYS evolve in the

course of a project so process iteration where earlier stages are reworked is always part of the process for large systems. Iteration can be applied to any of the generic process models. Two (related) approaches
Incremental delivery; Spiral development.

Generic Software Process Models


The Waterfall Model

Evolutionary Development
Incremental Model Spiral Model Component-based Software Engineering Rapid Application Development Model (RAD)

Aspect Oriented Software Development Formal Transformation

Incremental Process Model


Combines elements of Waterfall model in an

iterative fashion. Applies linear sequences in a staggered fashion as calendar time progresses Each linear sequence produces deliverable increments of the software. Process flow for any increment may incorporate prototyping. First increment is often a core product.

Incremental Delivery
Rather than deliver the system as a single delivery,

the development and delivery is broken down into increments with each increment delivering part of the required functionality. User requirements are prioritised and the highest priority requirements are included in early increments. Once the development of an increment is started, the requirements are frozen though requirements for later increments can continue to evolve.

Incremental Development

Iterative in nature unlike prototyping, it focuses on the delivery

of operational product with each increment

Incremental Development Model

increment # n
Co m m u n i c a t i o n Pla nning M ode ling ana ly s i s des ig n

Co n s t ru c t i o n c od e t es t De p l o y m e n t d e l i v e ry fe e dba c k

increment # 2
Co m m u n i c a t i o n Pla nning M ode ling a nal y s i s d es i gn

deliv ery of nt h increment

Co n s t ru c t i o n c o de t es t De p l o y m e n t d e l i v e ry fe e dba c k

increment # 1
Co m m u n i c a t i o n Pla nning M ode ling anal y s is des i gn Co n s t ru c t i o n c ode t es t De p l o y m e n t d e l i v e ry fe e dba c k

deliv ery of 2nd increment

deliv ery of 1st increment

project calendar t ime

Incremental Development - Advantages


Customer value can be delivered with each

increment so system functionality is available earlier. Early increments act as a prototype to help elicit requirements for later increments. Lower risk of overall project failure. The highest priority system services tend to receive the most testing.

Generic Software Process Models


The Waterfall Model

Evolutionary Development
Incremental Model Spiral Model Component-based Software Engineering Rapid Application Development Model (RAD)

Aspect Oriented Software Development Formal Transformation

Spiral Development Model


Process is represented as a spiral rather than

as a sequence of activities with backtracking. 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. Risks are explicitly assessed and resolved throughout the process.

Spiral Model
planning
estimation sch eduling risk analysis

communication modeling
analysis design start

deployment
delivery feedback

construction
code test

Spiral Model

Spiral Model Sectors


Objective setting

Specific objectives for the phase are identified. Risk assessment and reduction Risks are assessed and activities put in place to reduce the key risks. Development and validation A development model for the system is chosen which can be any of the generic models. Planning The project is reviewed and the next phase of the spiral is planned.

Spiral Model Flexibility


Well-understood systems: waterfall model Stable requirements and formal specification:

formal transformation model High risk, incomplete specification: prototyping model


Hybrid models chosen for different parts of

the project

Spiral Model Advantages


Focuses attention on reuse very important! Focuses attention on early error elimination

Integrates development and maintenance


Provides a framework for hardware/software

development

Spiral Model Problems


Contracts often specify process model in

advance Requires risk assessment expertise Needs refinement for general use

Generic Software Process Models


The Waterfall Model

Evolutionary Development
Incremental Model Spiral Model Component-Based Software Engineering Rapid Application Development Model (RAD)

Aspect Oriented Software Development Formal Transformation

Component-Based Software Engineering


The system is assembled from existing

components (Reuse-based development)


Based on systematic reuse where systems are

integrated from existing components or COTS (Commercial-off-the-shelf) systems. Process stages


Component analysis; Requirements modification; System design with reuse; Development and integration.

This approach is becoming increasingly used as

component standards have emerged.

COTS
Commercial Off-The-Shelf software Build-vs.-buy decision Advantages Available immediately Potentially lower cost Disadvantages Not as tailored to your requirements Remember: custom software rarely meets its

ideal
41

Reuse-Oriented Development

Generic Software Process Models


The Waterfall Model

Evolutionary Development
Incremental Model Spiral Model Component-based Software Engineering Rapid Application Development Model (RAD)

Aspect Oriented Software Development Formal Transformation

Rapid Application Development (RAD)


Incremental software process model Focuses on short development cycle

High-speed adaptation of the waterfall model


Rapid development is achieved by using a

component based construction approach If requirements are fully understood and project scope is constrained, a fully functional system can be developed within a short period of time (e.g. 60-90 days)

RAD Model
Team # n
M o d e lin g
business m odeling dat a m odeling process m odeling

C o n s t r u c t io n

Com m unicat ion

Team # 2
Mo d eling
b u si n e ss m o d e l i n g dat a m odeling p ro ce ss m o d e l i n g

com ponent reuse aut om at ic code generat ion t est ing

Planning
Co nst r uct io n

De ploym e nt
int egrat ion deliv ery feedback

Team # 1 Mode ling


business modeling dat a modeling process modeling

co m p o n e n t re u se a u t o m a t i c co d e g e n e ra t i o n t e st i n g

Const r uct ion


component reuse aut omat ic code generat ion t est ing

6 0 - 9 0 days

RAD Activities
Communication

understand the business problem and information characteristics that software must understand essential as multiple software teams works in parallel on different system functions business modeling, data modeling and process modeling and establishes design representations

Planning

Modeling

RAD Activities
Construction

use of pre-existing software components and the application of automatic code generation establishes a basis for subsequent iterations, if required

Deployment

RAD Drawbacks
For large, but scalable projects, RAD requires

sufficient human resources to create right number of RAD teams If developers and customers are not committed to rapid-fire activities in the stipulated time frame, RAD projects will fail If system cannot be modularized, building the components necessary for RAD will be problematic Not appropriate when technical risks are high

Generic Software Process Models


The Waterfall Model

Evolutionary Development
Incremental Model Spiral Model Component-based Software Engineering Rapid Application Development Model (RAD)

Aspect Oriented Software Development Formal Transformation

Aspect Oriented Software Development


Aspect-oriented development addresses a major

software engineering problem - the separation of concerns. Concerns are often not simply associated with application functionality but are cross-cutting - e.g. all components may monitor their own operation, all components may have to maintain security, etc. Cross-cutting concerns are implemented as aspects and are dynamically woven into a program. The concern code is reuse and the new system is generated by the aspect weaver.

Aspect Oriented Software Development

Crosscutting Concerns
Concern = system property Functional property Constraint of system behavior

Constraints on a system refer to conditions that need to be satisfied when the system runs
Logging of read/write operations on all pumps Authorization Synchronization

Are those system concerns which take effect

over multiple artifacts within a design or program. Artifact = any tangible object at any level of the software development process.

Aspects
In the context of AOSD, are a new modularity

mechanism with which crosscutting concerns can be expressed. An aspect holds all the information (operations and data) that a crosscutting concern uses/manipulates. An aspect is bound to a context. Better modularity. Crosscutting concerns are now localized in an aspect. Easier understanding. The information about a concern is localized. It is less scattered and tangled with other information. Easier modifiability. Look at one aspect and its binding.

Binding Model
Separating the operations and data which a

crosscutting concern deals with is the first step: aspectual data type. One needs to define at which points within your design implementation an aspect gets to execute its code. Binding of an aspect. A join point model provides the glue between aspectual data types and the binding of them.

Generic Software Process Models


The Waterfall Model

Evolutionary Development
Incremental Model Spiral Model Component-based Software Engineering Rapid Application Development Model (RAD)

Aspect Oriented Software Development Formal Transformation

Formal Methods Model


set of activities that lead to formal mathematical

specification of computer software enable a s/w engineer to specify, develop and verify a computer-based system by applying a rigorous mathematical notation Correctness is proven, not observed

Automatic Proof

Provides a neutral description Good for documentation Good for standardization Legal guarantees

Formal Methods Model


Build a model using a Modeling Language

Algebra Theorem Provers exist (Boyer-Moore)

Verify the correctness of the model

Translate the model to implementation

Again, tools exist

Formal Methods Model


Disadvantages

Time-consuming and expensive Extensive training is requires Communication problems with technically unsophisticated customers Idealized models Design vs. Implementation Learning curve How do you prove a prover? Cant apply models to existing systems

Rational Unified Process


RUP From Rational Corporation Generic version is the Unified Process Commercial Extensive tool support (expensive) Object-oriented Incremental Early Risk Dealing

59

Rational Unified Process

60

Rational Unified Process


Develop Iteratively Manage Requirements Uses UML (Unified Modeling Language) Produces artifacts Use component-based architecture Visually model software Complex process A framework Suitable for large scale systems
61

Process Activities
Software specification Software design and implementation

Software validation
Software evolution

Software Specification
The process of establishing what services are

required and the constraints on the systems operation and development. Requirements engineering process
Feasibility study; Requirements elicitation and analysis; Requirements specification; Requirements validation.

Requirements Engineering Process

Process Activities
Software specification Software design and implementation

Software validation
Software evolution

Software Design and Implementation


The process of converting the system

specification into an executable system. Software design

Design a software structure that realises the specification;

Implementation Translate this structure into an executable program; The activities of design and implementation

are closely related and may be inter-leaved.

Design process activities


Architectural design Abstract specification

Interface design
Component design Data structure design

Algorithm design

The Software Design Process

Structured Methods
Systematic approaches to developing a

software design. The design is usually documented as a set of graphical models. Possible models
Object model; Sequence model; State transition model; Structural model; Data-flow model.

Programming and Debugging


Translating a design into a program and

removing errors from that program. Programming is a personal activity - there is no generic programming process. Programmers carry out some program testing to discover faults in the program and remove these faults in the debugging process.

The Debugging Process

Process Activities
Software specification Software design and implementation

Software validation
Software evolution

Software Validation
Verification and validation (V & V) is intended

to show that a system conforms to its specification and meets the requirements of the system customer. Involves checking and review processes and system testing. System testing involves executing the system with test cases that are derived from the specification of the real data to be processed by the system.

The Testing Process

Testing Stages
Component or unit testing Individual components are tested independently; Components may be functions or objects or coherent groupings of these entities. System testing Testing of the system as a whole. Testing of emergent properties is particularly important. Acceptance testing Testing with customer data to check that the system meets the customers needs.

Testing Phases

Process Activities
Software specification Software design and implementation

Software validation
Software evolution

Software Evolution
Software is inherently flexible and can

change. As requirements change through changing business circumstances, the software that supports the business must also evolve and change. Although there has been a demarcation between development and evolution (maintenance) this is increasingly irrelevant as fewer and fewer systems are completely new.

System Evolution

Rational Unified Process (RUP)


A modern process model derived from the

work on the UML and associated process. Normally described from 3 perspectives
A dynamic perspective that shows phases over time; A static perspective that shows process activities; A practice perspective that suggests good practice.

RUP Phase Model

Phase it erat ion

Incept ion

Elaborat ion

Const ruct ion

Transit ion

RUP Phases
Inception

Establish the business case for the system. Develop an understanding of the problem domain and the system architecture. System design, programming and testing. Deploy the system in its operating environment.

Elaboration

Construction

Transition

RUP Good Practice


Develop software iteratively Manage requirements

Use component-based architectures


Visually model software Verify software quality

Control changes to software

Static Workflows
Work flow Business modelli ng Requirements Analysis and design Implementation Description The business processes are modelled using business use cases. Actors who interact with the system are identified and use cases are developed to model the system requirements. A design model is created and documented using architectural models, component models, object models and sequence models. The components in the system are implemented and structured into implementation sub-systems. Automatic code generation from design models helps accelerate this process. Testing is an iterative process that is carried out in conjunction with implementation. System testing follows the completion of the implementation. A product release is created, distributed to users and installed in their workplace. This supporting workflow managed changes to the system (see Chapter 29). This supporting workflow manages the system development (see Chapter 5). This workflow is concerned with making appropriate software tools available to the software development team.

Test

Deployment Configuration and change management Project management Environment

Computer-Aided Software Engineering


Computer-aided software engineering (CASE) is

software to support software development and evolution processes. Activity automation Graphical editors for system model development; Data dictionary to manage design entities; Graphical UI builder for user interface construction; Debuggers to support program fault finding; Automated translators to generate new versions of a program.

CASE Technology
Case technology has led to significant

improvements in the software process. However, these are not the order of magnitude improvements that were once predicted
Software engineering requires creative thought - this is not readily automated; Software engineering is a team activity and, for large projects, much time is spent in team interactions. CASE technology does not really support these.

CASE Classification
Classification helps us understand the different

types of CASE tools and their support for process activities. Functional perspective Tools are classified according to their specific function. Process perspective Tools are classified according to process activities that are supported. Integration perspective Tools are classified according to their organisation into integrated units.

Functional Tool Classification


Tool type Planning tools Editing tools Change management tools Configuration management tools Prototyping tools Method-support tools Language-processing tools Program analysis tools T esting tools Debugging tools Documentation tools Re-engineering tools Examples PERT tools, estimation tools, spreadsheets T ext editors, diagram editors, word processors Requirements traceability tools, change control systems Version management systems, system building tools Very high-level languages, user interface generators Design editors, data dictionaries, code generators Compilers, interpreters Cross reference generators, static analysers, dynamic analysers T est data generators, file comparators Interactive debugging systems Page layout programs, image editors Cross-reference systems, program re-structuring systems

Activity-Based Tool Classification


Re-en g ineering tools Testin g too ls Debu gg ing too ls Prog ram analy sis to ols Lang uage-p ro ces sing too ls Meth od s up po r t to ols Proto ty ping too ls Co nfiguration management to ols Ch an ge man ag emen t too ls Do cu men tatio n too ls Ed iting too ls Planning to ols

Sp ecif icatio n

Design

Implemen tatio n

V erification and V alidatio n

CASE Integration
Tools Support individual process tasks such as design consistency checking, text editing, etc. Workbenches Support a process phase such as specification or design, Normally include a number of integrated tools. Environments Support all or a substantial part of an entire software process. Normally include several integrated workbenches.

Tools, Workbenches, Environments


CASE techn olo g y

T ls oo

Wor kb en ch es

Envir ments on

Ed ito rs

Co mp ilers

File comp ar ators

Integ rated en vir ments on

Process -cen tr ed en vir ments on

An alys is and des ig n

Pro gramming

T estin g

Mu lti-metho d workb en ch es

Sin gle-meth od workb en ch es

General-pu rp os e workb en ch es

Lang uage-sp ecific workb en ch es

Key points
Software processes are the activities involved in

producing and evolving a software system. Software process models are abstract representations of these processes. General activities are specification, design and implementation, validation and evolution. Generic process models describe the organisation of software processes. Examples include the waterfall model, evolutionary development and component-based software engineering. Iterative process models describe the software process as a cycle of activities.

Key points
Requirements engineering is the process of

developing a software specification. Design and implementation processes transform the specification to an executable program. Validation involves checking that the system meets to its specification and user needs. Evolution is concerned with modifying the system after it is in use. The Rational Unified Process is a generic process model that separates activities from phases. CASE technology supports software process activities.