A software development process model (SDPM), a.k.a., a software life-cycle model, is the process by which an organization develops software.
Different SDPMs will divide these activities among phases in different ways.
Examine existing system.
Propose a new system
We’ll look at requirements in more detail in a later section.
Derive
a solution which satisfies the software requirements.
Commonly recognized subproblems include
architectural design,
high-level design,
low-level design
A possible breakdown of design activities
Maintenence can have a number of forms:
fixing problems
The best known process model
Defining characteristic: movement from phase to phase is always forward (downhill), irreversible
Verification & Validation: assuring that a software system meets the users’ needs.
The principle objectives are:
Verification:
Validation:
Testing
usually conducted by the programmer.
Although the waterfall model shows V&V as a separate phase near the end, we know that some forms of V&V occur much earlier.
So this phase of the waterfall model really describes system and acceptance testing.
A Still-broader View
Even the “V&V V” does not capture the full context of V&V:
Iterative versus Incremental Models
Iterative – we do some set of process steps repeatedly.
To use a programming analogy, this is iterative:
while (!done) {
⋮
}
Incremental – we accumulate value in small steps.
To use a programming analogy, this is incremental:
total += x;
Incremental development is almost always iterative, but you can be iterative without being incremental.
Variations
Some projects employ throw-away prototyping, versions whose code is only used to demonstrate and evaluate possibilities.
Evolutionary prototyping keeps the prototypes, gradually evolving them into the final deliverable
Some waterfall projects may employ incremental schemes for parts of large systems (e.g., the user interface).
Poor process visibility (e.g., are we on schedule?),
Continual small drifts from the main architecture leading to poorly structured systems.
Dead-ends (the local optimization problem)
1986, Boehm
An iterative approach with a focus on risk management
Each iteration builds on the earlier ones
risk: an uncertain outcome with a potential for loss
Examples:
Spiral Phases
1997, Jacobsen, Booch, and Rumbaugh,
Best Practices
Inception: initial concept
Elaboration: exploring requirements
Construction: building the software
Transition: final packaging
Releases
One task during Elaboration is to plan releases:
Major phases are divided into increments, each of which ends with a release.
A release is some kind of product that implements some part of the required functionality
The release plan records decisions about
Analysis: what do we need the (currently considered part of the) system to do?
Design: how do we get it to do that?
ADIV
In the RUP, all progress is made as continual ADIV cycles
RUP supports development via a series of models.
The most important of these are
Domain Model
Analysis Model
Design Model
Models Evolved
RUP embraces the
Object-Oriented philosophy
- Every program is a simulation
- The quality of a program’s design is proportional to how faithfully the objects and interactions in the program reflect those in the real world
Domain, analysis, and design models all focus on how classes of objects interact with one another
Most of the classes in the design are presumed to have already been described as part of the analysis model,
A modern variant of incremental development.
Agile development is
Emphasis Areas
Emphasis is on
We’ll look at Agile in more detail later in the semester, after we have learned more about these “best practices” that lie at the heart of the process.