Overview

A Methodology for Software Construction

Definition of the Software Life Cycle

Life Cycle Models
Software Engineering – Build-and-Fix
– Waterfall
– Rapid Prototype
Lecture 3 – Incremental
So in what order should things be done? – Spiral
– Fountain
Software Life-Cycle Models

Language Paradigms

Software Engineering Problems The Software Life-Cycle

Complexity The series of phases through which a
– Most complex human construct software product passes from initial

Conformity conception through to its final retirement
– Often must fit into existing system from use

Changeability
Phases will differ depending on the design
– Requirements change over time (c.f. not often
strategy employed
asked to move a bridge 300 miles or rotate 90
Each product spends a varying amount of time
degrees) in each phase, for example because:-

Invisibility – not currently deemed feasible to implement
– Difficult to visualise what is happening – many revisions required to address varying needs
 Build-And-Fix Model Waterfall Model
Requirements Changed
Build First phase requirements
Version Originally proposed in 1970 Verify Verify

‘Traditional’ way people
Attempted to separate design and
often write programs Specification
phase

Modify until client is

implementation Verify

No formal specification or satisfied

development plan Formalise process of design Design

phase

Code written and re- Faults in previous phase often Verify

written until it Operations mode

become apparent during subsequent Implementation
phase
approximates what is phase. e.g. Test

required incompleteness
Development Integration
Retirement
Maintenance phase
ambiguities Development
Test
Maintenance
 Severe problems encountered for anything but very small contradictions Operations
programs: difficult to amend program to accommodate changing
Revisions of previous phase
requirements Retirement

Problems with Waterfall Model Rapid Prototype Model

The various design documents produced are
Similar to Waterfall but Rapid
Prototype
Changed
requirements

only useful if comprehensible to the clients and prototype produced initially Verify Verify

developers
Rapid Prototype is a working Specification

phase

model representing subset of Verify

Many unskilled or untrained Software Engineers finished product Design

work within the industry
Concentrates on user interface

phase
Verify

Clients / Users will generally not be able to design to demonstrate to

Implementation
clients
determine if design reflects their requirements phase
Test

Prototype used to guide design

Software designed in isolation: no account of specification documents and Integration
phase

taken of changing technology or competing give insights to problems in Development

Maintenance
Test

products implementation Operations

Fewer faults often found with

Retirement
this model
 Incremental Model
Incremental Model (Alternative View)

Decompose product into a
Requirements
phase
Problems
Verify
number of components each – Need to integrate each new build with previous builds and any existing
designed and built separately Specification
systems
phase

(termed builds) Verify

– Decomposing product into builds not trivial
– too few builds and each build degenerates into Build-And-Fix

Each component delivered to Architectural
design – too many builds leads to little added utility from each build
client when complete Verify

– allows partial utilisation of

product and avoiding long For each build:
Perform detailed
development time design,
implementation
and integration.
– large initial capital outlay with Test. Deliver

subsequent long wait avoided Development

Operations
– traumatic effect of introducing Maintenance

completely new system all at Retirement

once removed

Spiral Model Risk Analysis

To read diagram:
Most Significant Addition to Spiral Model
– Software
Many problems may affect product
development – Hardware manufacturers / Sub-contractors may go bankrupt
proceeds from
centre outwards
– Key personnel may leave company
in a spiral – Key groups / personnel not competent to design product
– Current cost of – Better competing product released
project – Technological Breakthroughs make product redundant
proportional to
straight line – Product may not integrate properly despite design
distance from – Constraints on product performance (e.g. speed) not met by
current point to product
centre – Client rejects product or changes requirements during
– Each cycle development
represents a
phase
 Analysis of Spiral Model Fountain Model
Maintenance Further
Development

Prototypes produced at each stage help allieviate some
Many advantages over Waterfall
Operations mode
risks for Object-Oriented
Development
– Timing constraints (especially for real time systems) Implementation and
– Circles represent each phase Integration phase
– Client acceptance of design – Arrows represent iteration of phase
Implementation
– Integration problems
Phases overlap more than phase

Disadvantages of Spiral Model Waterfall Object-Oriented

Design phase
– Some risks easier to evaluate than others
‘Natural Gravity’ of Diagram
– When external companies are involved, contracts often infers repeated re-analysis of
signed at outset. Value of subsequent risk analysis thus earlier phases Object-Oriented
Analysis phase
compromised unless contracts may be re-negotiated.
Care required with overlapping Requirements

– Cost of Risk Analysis prohibitive except for large (ususlly phases or model will de- phase

entirely in-house) products generate into Build-And-Fix

Programming Language
Paradigms Summary

Imperative
– Sequence of instructions indicating how to complete a task
Variations of Software Life-Cycle Presented
– ‘Traditional Languages’: Fortran / Algol / Pascal / C /
Variations offer differing views as to the
Ada

Declarative roles of each phase of the Life Cycle
– Definitions of what a solution should consist of
Each Model has its own set of advantages
– Lisp, Prolog, Haskell and disadvantages

Object-Oriented

The role of each phase is critical to
– encapsulation of properties and methods
– inheritance of classes successful completion of a Software
– Smalltalk / C++ / Java development project