Information Technology Reference
In-Depth Information
Fig. 4.7. The waterfall model is one of the earliest methods used to systematize software development.
In principle, the model consists of several independent stages with each stage feeding to a subsequent
stage. This approach is sometimes referred to as “Big Design Up Front” - because a new stage can only
start if the preceding one has been fully completed. This is the strength of the method - but also its
weakness. In reality, software development is not a linear process and many issues cannot be foreseen
until later stages in the project. So, in practice, the individual stages are not fully isolated from each
other: often we need to backtrack to make revisions and changes in the previous stages.
Requirements
Design
Implementation
requirements at the beginning of a project. To incorporate changes in require-
ments makes a less rigid approach than the formal approach of the waterfall
model essential.
The first stage of the software life cycle is requirements analysis and speci-
fication. One of the earliest tools for documenting computer programs was the
lowchart , a diagram representing the sequence of operations in a program. We
have already seen examples of flowcharts for for loops and if-then-else control
statements (see Fig. 4.4 ). However, in the production of large, complex software
systems, flowcharts have proved to be of limited value. In the 1980s, computer
scientist David Harel was working with avionics engineers trying to specify the
behavior of a software system to control a modern jet aircraft. An avionics sys-
tem is reactive - a term coined by Harel and his colleague the late Amir Pnueli -
in the sense that it has to respond predictably to a wide variety of different types
of events. Harel eventually converged on a diagrammatic way to specify the
responses and transitions of the avionics system, which he called statecharts -
“the only unused combination of 'state' or 'flow' with 'chart' or 'diagram.'” 11
By 1986, Harel and his colleagues had built the Statemate tool, which not only
allowed users to construct statecharts but was also able to automatically gener-
ate code to fully execute them. In the 1990s, they developed an O-O version of
statecharts, which later became the heart of the Unified Modeling Language, or
UML. UML was devised in 1996 by Grady Booch ( B.4.7 ), James Rumbaugh, and
Ivar Jacobson. It is a collection of visual languages for specifying, constructing,
and documenting complex software designs. Booch comments, “If you look
across the whole history of software engineering, it's one of trying to mitigate
complexity by increasing levels of abstraction.” 12 The UML approach ( Fig. 4.8 ) is
yet one more attempt to reduce the complexity of software production.
The final phase of the software life cycle is testing and maintenance. For
complex software systems, it is impossible to test all branches of the code under
all possible combinations of input data and initial states. According to Dijkstra,
“Program testing can be a very effective way to show the presence of bugs, but
is hopelessly inadequate for showing their absence.” 13 A 2002 report from the
National Institute of Standards and Technology, a U.S. government agency that
works to promote innovation and industrial competitiveness, estimated that
inadequate software testing cost the U.S. economy nearly $60 billion per year.
The report also stated, “In fact, the process of identifying and correcting defects
during the software development process represents approximately 80 percent
of development costs.” 14
Testing a modern software system involves the application of a variety of
different tools. Dynamic software testing involves running the code using a set of
Verification
B.4.7. Grady Booch is an evangelist
of the systematic approach to soft-
ware design. In one of the interviews
he referred to his mission with the
following words: “if I had not dis-
covered software I would have been
a musician or a priest.” He is one of
the authors of the UML, which repre-
sents a framework for constructing
and reasoning about the software.
UML is a collection of diagrams and
tools that allows programmers to
cope with complex systems by rais-
ing the level of abstraction.
 
Search WWH ::




Custom Search