| |
“New terms such as techno-stress and
techno-shock have been coined to define the psychological manifestations
of a public
overwhelmed by everything from microwave ovens to home Pac-Man games. Unfortunately,
these terms do not accurately describe progress within the data processing
industry as it pertains to software development. For many data processing
professionals, techno-stress is better defined as frustration with the
slow pace of change in software development methods, in the face of ever-increasing
demand for dp services.
“While there is no question that some progress toward
better
systems development methods has been made during the last 30 years, there
is equally no question that, overall, any process of change is slow and
discontinuous. Speaking from an historical perspective, it seems that for
true progress to be realized, there must be a periodic, collective rethinking
of basic ideas. The periods between each great leap forward can be tens
of years to hundreds of years.”
— F.J. Grant
“Twenty-First Century Software,”
Datamation, April 1, 1985

IN THIS CHAPTER, YOU WILL LEARN:
-
The problem with classical
systems analysis;
-
The changes that have taken place in classical
structured analysis;
-
Why automated tools are important to the future
of systems analysis; and
-
Why problems in classical structured
analysis have led to prototyping and other “evolutionary” approaches.
The
systems analysis methods and tools presented in this
book represent a state of the art approach that will
be used in most systems development organizations
at least throughout the first decade of the 21st century.
Assuming that computer technology continues to advance
at approximately the same rate that we have experienced
for the past 40 years, it is likely that systems analysis
will have evolved substantially by the end of this
decade; Chapter
25 discusses the likely nature of that evolution.
But it is
not enough for you to be aware of today’s systems analysis techniques.
You must also
have an understanding of the changes that have
taken place over the past decade, changes that have led to the tools
and techniques that we will explore in depth in Parts II and III. There
are
three reasons why you should be familiar with the evolution of systems
analysis.
First, you may find
that the systems development organization you work for has not evolved
and that nobody has any intention of making
any
changes.
Though the changes discussed in this chapter have occurred in approximately
80% of the data processing organizations in North America, Europe,
and other parts of the world, there are still those backwater bastions
of
mediocrity that see no reason to change the way they were doing things
20 years ago.
If you find yourself in this situation, the logical thing to do is
to look for another job; or, if you are feeling brave, you might take on
a
leadership
role and help bring your organization into the modern world of systems
analysis.
Second (and more
likely), you may find that your organization has begun to implement some
of the changes discussed in this chapter,
but the
process
of change will continue for another few years. A good example of
this is the deployment of automated tools for requirements management,
or
requirements-based testing. Almost all systems analysts will tell you
that such tools are
a good idea, and some project managers are beginning to support the
concept. But low-cost, powerful tools are relatively new, and organizations
are
slow to change; indeed, historical studies have shown that it often
takes 12-15 years for new tools and techniques to permeate the IT
community,
even after they have been demonstrated to be effective. Thus, even
though you and the other members of your organization may know what
kind of tools
and techniques will be installed three years from now, today’s approach
to systems analysis may be somewhat different. It is important for
you to know the approach that the organization was using previously
and what
kind of transition is underway.
Third, the notion
of transition is important even if you work in one of the “leading edge”
organizations that has completely
implemented
the
systems analysis approaches presented in this book. The field of
systems analysis, like all other aspects of the computer field, is dynamic;
the
way we do systems analysis in the second or third decade of the 21st
century will undoubtedly be different than the way we do it now. But to
see what
changes will take place during the middle and latter part of the
first decade of the 21st century, you need an appreciation of where the
field
came from and the direction it is heading in.

7.1 THE MOVE TOWARD STRUCTURED
ANALYSIS
Until recently,
the overwhelming majority of systems development projects began with the
creation of a “Victorian novel” statement of
user requirements.
That is, the systems analyst documented his or her understanding
of the user’s requirements in a massive document consisting primarily of
narrative
English. Early authors of “structured analysis” textbooks —especially
(DeMarco, 1978), (Gane and Sarson, 1977), and (Weinberg, 1978) —
pointed out that these
ponderous tomes (often known as a functional specification) typically
suffered from several major problems:
-
They were monolithic: you
had to read the functional specification in its entirety, from beginning
to end, in order
to understand it. Like
a Victorian novel, if you didn’t read the last page, you
had little idea of how the story would end. [1] This
is an important flaw, for there are many situations where the systems analyst
or the user wants to read and comprehend one part of the specification
without necessarily reading any other part.
-
They were redundant: the
same information was often repeated in several different parts of the document. [2] The
problem with this is that if any aspect of the user’s requirements
change during the systems analysis phase (or, even worse, after the systems
analysis phase has been declared finished), the change has
to be
reflected in several different parts of the document. This would be
less of a problem
today, since even the most primitive organization has ample
access to word processing facilities; but in the 1960s and 1970s, most
organizations
created
their functional specifications with nothing more sophisticated
than an electric typewriter. [3]
Because it was so difficult to update and revise the document,
the inherent redundancy led to a far worse problem: inconsistency.
Just
as a person
with many watches is unlikely to know what time it really is,
a functional specification with the same information repeated
three or four times
is likely to have the wrong information in several instances.
-
They were ambiguous: the
detailed statement of user requirements could be (and often was) interpreted
differently by
user, systems analyst,
systems designer, and programmer. Studies conducted in the
late 1970s [4] found that 50% of the errors
eventually found in an operational system and 75% of the cost of error
removal could
be traced to misunderstandings
or errors in the functional specification.
-
They were impossible to maintain: for
all the reasons described above, the functional specification was almost
always
obsolete by the end
of the systems development process (i.e., by the time the
system was put into operation), and often obsolete by the end of the systems
analysis
phase. This means that most of the systems developed during
the 1970s and
1980s — systems that are now 20 years old or more — have
no up-to-date statement of the business policy that they supposedly carry
out. And
since the original
systems analysts and the original users have long since vanished,
the awful reality is that nobody knows what most of the major computer
systems are
doing today.
While all these
problems were being debated, a complementary set of ideas was already being
adopted in the area of programming
and design. These
ideas, generally referred to as structured programming (SP) and structured
design (SD), promised great improvements in the organization, coding,
testing, and maintenance of computer programs in the 1970s and 1980s; in
the 1980s
and 1990s, a newer set of ideas, involving object-oriented programming
(OOP) and object-oriented design (OOD), gradually became popular.
And indeed, structured development and object-oriented development techniques
have
generally proved successful; but more and more IT organizations gradually
began to realize that there was no point writing brilliant computer
programs and designing highly modular systems if nobody really knew what
the systems
were supposed to do. Indeed, it could be argued that SD/SP and OOD/OOP
allowed some project teams to arrive at a disaster more quickly than
ever before — building a brilliant solution to the wrong problem!
As a result, there
has been a gradual movement — gradual in the sense that it has
taken the systems development profession nearly ten years to
accept it — toward functional specifications that are:
-
Graphic — composed
of a variety of diagrams, supported by detailed textual material that,
in many cases, serves
as reference
material rather
than the main body of the specification.
-
Partitioned — so
that individual portions of the specification can be read independently
of other pieces.
-
Minimally redundant — so
that changes in the user requirements can usually be incorporated in just
one part of
the specification.
This approach, generally known as structured analysis, is now used in the
majority of business-oriented systems development organizations, as well
as a large number of engineering-oriented organizations. You will still
find some organizations churning out Victorian novel specifications, but
they are in the minority, and, like dinosaurs, they will eventually become
extinct.
7.2 CHANGES IN CLASSICAL STRUCTURED ANALYSIS
As
mentioned above, traditional systems analysis (characterized by Victorian
novel specifications) began to change in the late 1970s. Many of the
organizations now using structured analysis continue to base their
approach on the early
textbooks of DeMarco, Gane and Sarson, and others, as well as the seminars,
videotapes and other training materials based on those books. However,
several years of practical experience with classical structured analysis
have pointed out a number of areas where changes or extensions need
to be made. The major changes are these:
-
The
emphasis on building “current physical”
and “current logical” models of the
user’s system has proven to be politically
dangerous. The project team often spent so much
time (sometimes as much as six months or a year
or more) studying the user’s old system, a
system that everyone knew was to be thrown away
and replaced with a new system, that the project
was canceled by an impatient user before the project
team could get on to the job of studying the proposed
new system. This does not mean that we have decided
to avoid modeling the user’s current system
in all cases, but merely that we recognize
it as a politically dangerous activity, and one
that will probably have to be minimized, if not
eliminated in the real world. We will discuss this
point again in Chapter
17.
-
Classical
structured analysis made a fuzzy, poorly defined
distinction between physical models (models that make assumptions about,
or are biased by, the implementation technology)
and
logical models (those that are entirely
independent of implementation technology); indeed,
even the terms logical and physical are confusing to many. Important
ideas in this area were contributed
by (McMenamin and Palmer, 1984) and even some of
the terminology has changed: we now refer to essential models (models
of the “essence” of a system)
instead of logical models, and implementation models
instead of physical models.
-
More
and more organizations are using structured analysis
techniques to build real-time systems. [5]
However, classical structured analysis has no way
of modeling the time-dependent behavior of a system;
it lacks the notation for showing interrupts and
signals, and to show the synchronization and coordination
of different processing tasks. Additional notation
and a whole new modeling tool — control flows,
control processes, and state-transition diagrams
— have been added to solve this problem. This
is discussed in more detail in Chapters
9 and 13.
-
Classical
structured analysis concentrated almost entirely
on the modeling of the functions to be carried out
in a system; the modeling of data was done in a
primitive way [6]
and often deemphasized or even ignored. Meanwhile,
more and more organizations have found that their
systems involve complex functions and complex data
relationships and complex real-time characteristics.
As we have seen, state-transition diagrams have
been added to structured analysis to permit modeling
of real-time systems; to permit modeling of systems
with complex data relationships, entity-relationship
diagrams have been added to structured analysis.
More important than just the addition of one or
two additional modeling tools is the fact that all
three of the major modeling tools can be integrated,
that is, used together so that each supports the
other. Entity-relationship diagrams are discussed
in Chapter
12, and the concept of integrated models is
discussed in Chapter
14.
-
The
process of structured analysis has changed
dramatically. Classical structured analysis assumed
that the systems analyst would begin by drawing
a context diagram, a dataflow diagram with a single
bubble representing the entire system, and then
partition the system into several functions and
data stores in a strictly top-down fashion. Unfortunately,
this has not worked well, for reasons discussed
in Chapter
20; consequently, a new approach known as event
partitioning has been added. The terminology and
basic concept of event partitioning were introduced
by (McMenamin and Palmer, 1984) and have been extended
by (Ward and Mellor, 1985).
7.3 THE EMERGENCE OF AUTOMATED ANALYSIS TOOLS
As the graphical modeling
techniques of structured analysis began to spread through systems development
organizations in the
1980s and 1990s, systems
analysts began to realize that there was a major problem: the artwork
required to create dataflow diagrams, entity-relationship diagrams, structure
charts,
state-transition diagrams, and other graphic models was often overwhelming.
The problem, in most cases, was not the initial creation of the
diagrams, but rather their revision and maintenance; creating the initial
diagram
is time-consuming, but at least has the satisfaction of being a
challenging, creative, intellectual activity. In a typical project, the
systems analyst
finds that he must redraw the graphical models several times before
he and the user can reach an agreement on the requirements of the system. [6a]
On a large system, there may be 50 to 100 or more dataflow diagrams,
several entity-relationship diagrams, and potentially several state-transition
diagrams; so the amount of artistic labor involved can be daunting indeed.
The practical consequence of this, in many organizations, is that classical
structured analysis was not as successful as it should have been. The following
problems occurred:
-
After the second or third revision
made to a diagram, the systems analyst would grow increasingly hostile
and reluctant to make
any further changes. Thus, it was possible to find “frozen” diagrams
that didn’t truly reflect
the user’s system requirements.
-
Because of the amount
of work involved, the systems analyst would sometimes stop partitioning
the system model into lower-level models — i.e., instead
of developing a model consisting of five levels
of dataflow diagrams, he would stop at the fourth level. The resulting
model
would contain
“primitive”
functions (i.e., the bubbles depicted at the
fourth level) that were not very primitive at all; indeed, they would turn
out to
be so
complex that
the programmer would find it necessary to carry
out additional systems analysis before he could write any programs. [7]
-
Changes to the user requirements after the analysis phase of the project
would often not be incorporated in the system model. Many of these changes
took place during the design, programming, and testing phases of the project;
still others took place after the system had been implemented. The result
was an obsolete specification.
In
addition to the work required to create and maintain
the diagrams, classical structured analysis requires
a great deal of work to verify the diagrams to ensure
that they are complete and consistent; these rules
are discussed in Chapter
14. [7a]
Throughout the 1970s and most of the 1980s, systems
analysts have had to depend on manual verification
techniques (i.e., visually inspecting the diagrams
to spot errors). Because the work is labor intensive
and boring, its tends to be error prone. Consequently,
many of the specification errors that should have
been found were not.
Many
of these problems can be solved with proper automated
support; this was well known even when classical structured
analysis was first introduced, but the cost of automation
was far higher than most organizations could afford.
However, the development of powerful graphics workstations
in the mid-1980s has led to a whole new industry known
as CASE (an acronym meaning Computer-Aided Software
Engineering); several dozen vendors offer products
(usually PC-based) that will draw dataflow diagrams,
and the like, as well as perform a variety of error-checking
tasks. Features and examples of these tools are discussed
in Appendix
A.
Only
a small percentage of the systems analysts in the
United States had access to such tools in the 1990s;
and the CASE industry unfortunately suffered a backlash
by promising miracles it could never deliver. [8]
However, it still appears to be essential to successful
practice of structured analysis, and we can expect
that most professional systems analysts will eventually
have access to such tools. This will lead, primarily,
to a higher level of quality in the systems models
produced; secondarily, it will lead to more visually
pleasing graphic models of the system. To the extent
that the error-checking concepts discussed in Chapter
14 are automated, it may eliminate the need for
systems analysts to learn the material in Chapter
14! And to the extent that the CASE tools eventually
begin generating programs (in COBOL, C, Visual Basic,
etc.) directly from the specifications, it will even
reduce the need for programmers!
7.4 THE USE OF PROTOTYPING
As
we pointed out in Chapter
3, some users have a difficult time working with
the graphic models of structured analysis; they prefer
some other way of modeling the requirements and behavior
of the system. Prototyping tools, which began to be
widely available in the mid-1980s, have been seen
by some as an alternative to structured analysis for
such users.
There
is another reason for the popularity of prototyping:
as we discussed briefly in Chapter
6, classical structured analysis is regarded in
some organizations as too time consuming; by the time
the analysis phase is finished, the user will have
forgotten why he wanted the system in the first place.
This is usually the result of one of the following
problems:
-
The project team spent far too
much time developing models of the user’s current system and then had to
spend even more time
modeling the new system. As mentioned above, we now regard modeling of
the current system as a politically
dangerous activity.
-
The organization previously invested
little or no time doing any systems analysis, preferring to begin coding
as soon as possible. In such an environment,
the lengthy work of systems analysis, which appears
to have no output except lots of pictures with circles and boxes on them,
may appear unproductive.
-
The first few projects using structured analysis
may be more time-consuming than normal, because the systems analysts are
learning new techniques and
arguing with one another as to the best way of applying
the techniques.
Prototyping tools (software tools that allow
the systems analyst to build a “mockup” of the system) are thus seen as
an effective
solution to these
problems. Note also that prototyping tends to concentrate
on the human interface aspect of a systems development project.
Unfortunately, the prototyping
tools are sometimes used to avoid the details of systems
analysis and design altogether; an appropriate use of
prototyping was shown in Section 5.6.
7.5 THE MARRIAGE OF SYSTEMS ANALYSIS AND DESIGN
As
mentioned earlier in this chapter, improvements in the
software engineering field began with structured programming
and structured
design; indeed,
these two topics were the subject of considerable debate
in systems development organizations throughout the early
and mid-1970s.
It was also during this
period that the first textbooks on structured design began
to appear (see (Myers, 1975) and (Yourdon and Constantine,
1975));
early books made no
reference to structured analysis (since the concepts had
not yet been developed), while later books such as (Page-Jones,
1980) included a brief overview
of the subject. Work on structured analysis began in the
mid-1970s,
and the first textbooks began to appear in the late 1970s;
but there was little
or no connection between the discussion of structured analysis
and the discussion of structured design. The main problem
was that structured analysis
dealt with the specification of large, complex systems,
while structured design seemed more appropriate for the design
of
individual programs running
on a single computer. The bridge between systems analysis
and program design, that is, systems design, was missing.
This problem
has been addressed by several
consultants, authors, and systems development organizations
in the 1980s. Recent books by (Ward and
Mellor, 1985), as well as new editions of books by (Page-Jones,
1988) and (Yourdon and Constantine, 1989), now deal
with the issues of systems design
as well as program design.
7.6 SUMMARY
Like any field
of science or engineering, systems analysis has undergone
a series
of evolutionary changes during the past
20 years. As indicated
at the beginning of the chapter, it is important for
you to know what those changes have been, because the software
development
industry is large enough
and diverse enough that not everyone is practicing
the same
techniques at the same time. Your organization may be
at the “leading edge”
of technology, or it may be at the “bleeding edge.”
You
can expect the field of systems analysis to continue;
the techniques presented in this book will have evolved
even further within the next five to ten years. Chapter
25 discusses the likely nature of further evolutionary
changes.

REFERENCES
-
Tom DeMarco, Structured Analysis and System Specification.
New
York: YOURDON Press, 1978.
-
Chris Gane and Trish Sarson, Structured Systems Analysis and Design.
New York: Improved Systems Technologies, Inc.,
1977.
-
Paul Ward and Steve Mellor, Structured
Development for Real-Time Systems, Volumes 1-3. New
York: YOURDON Press, 1985.
-
Steve McMenamin and John Palmer, Essential Systems Analysis.
New York: YOURDON Press, 1984.
-
Glen Myers, Reliable Systems through Composite Design.
New
York: Petrocelli/Charter, 1975.
-
Edward
Yourdon and Larry Constantine, Structured Design,
1st
ed. New York: YOURDON Press, 1975.
-
Meilir Page-Jones, The Practical Guide to Structured Systems Design,
1st ed. New York: YOURDON Press, 1980.
-
Meilir Page-Jones, The Practical Guide to Structured Systems Design,
2nd ed. Englewood Cliffs, N.J.: Prentice-Hall,
1988.
-
Edward Yourdon and Larry
Constantine, Structured Design,
Englewood Cliffs, N.J.: Prentice-Hall,
1978.
-
James and Suzanne Robertson, Complete
Systems Analysis,
Volumes
1 and 2. New York: Dorset House,
1994.
-
YOURDON inc., The YOURDON Systems Method: Model-Driven Systems
Development. Upper Saddle
River, NJ: Prentice Hall, 1993.

QUESTIONS AND EXERCISES
-
What are the three major reasons why you
should be familiar with the evolution of systems analysis?
-
What do you think you
should do if the organization you work
for has not made the changes discussed in this
chapter?
-
List four major problems with a classical
narrative specification.
-
Why
is it undesirable to have redundancy
in a system specification? Is it possible
to remove redundancy altogether from a specification?
-
Can
you think of any
reason why redundancy could be useful
in a system
specification?
-
What are the three
common reasons that redundancy gets introduced into a classical
specification?
-
What percentage
of errors in an operational
system can typically
be traced back to errors that occurred
during the systems analysis
phase of the project?
-
Research Project:
What is the percentage of errors
in your organization
that can
be traced back
to errors that occurred during
the
systems analysis phase of the
project?
-
What are the consequences of a specification
that
is impossible
to maintain?
-
Give
a brief description of
structured programming.
-
Give a brief description of structured
design.
-
Why have some organizations
found that they are not successful
when
using structured programming
and structured design?
-
What are the three major characteristics
of a
structured specification?
-
What are the five
major changes
that have taken
place in classical structured analysis?
-
What
problems does
classical structured analysis have when dealing with real-time systems?
-
What
are the
dangers associated
with
modeling the
user’s current information system? How long should
one spend
modeling the user's current
system?
-
What are the three major problems that
the systems analyst is likely to
encounter if he or she
does not
have automated support
for his or
her work?
-
Is it
important
to have automated support for small information systems
development projects?
Why or
why not?
-
What problems
are likely
to be encountered if the systems analyst has to carry out error-checking
activities on a manual basis?
-
Why do you think that only
2%
of the systems analysts
in the United States had automated systems analysis
workstations in 1987?
-
What
additional benefits can we expect to see from the
introduction
of
a network of automated systems analysis tools? (Hint: One
such benefit is electronic
mail.)
-
What are the three common problems that
organizations have encountered
when implementing classical
structured analysis?
-
What interface problems existed between
structured analysis and structured design
in the 1970s and early
1980s?

FOOTNOTE
-
[1]
Or to put it another way, there’s never any sex until the last
page.
-
[2] There
are several theories as to why redundancy was such a common characteristic.
My own experience was that the functional specification served
three different purposes in the organization (and thus the same information
was
presented
in three different ways): first, it was the “official” statement
of the user’s requirements; second, it was an unofficial training
manual, meant
to explain how those “dumb” users would operate
the system; and third, it was a politically oriented sales
tool, meant to impress
management
that the system would be so glorious that it would be well worth
the cost to
build it.
-
[3] Perhaps
one of the best examples of this problem occurred in a
major New York City bank’s IT organization in the mid-1970s. Embarked
upon a typical “Mongolian
horde” systems development project, the systems analysis
group interviewed dozens of users throughout the bank and gradually
developed a Victorian
novel specification of mind-numbing size. Typing the document
occupied the typing pool for two weeks, and all available Xerox machines
were commandeered
for several days in order to make enough copies to distribute
to the users. The user community was given a week to read through the
entire functional
specification and indicate any desired changes or corrections;
somewhat to their surprise (but to their immense relief!) the systems
analysts received
no comments from the users by the appointed deadline. So
the functional specification was declared “frozen” and work commenced
on design and programming.
Three weeks later, six members of the user community announced
that they had finally managed to read the entire specification — and,
yes, they did
have a few small changes. A small panic ensued: what should
be done to the specification? After two angry meetings at which users
and systems
analysts insulted each other’s heritage and intelligence
in terms that cannot be repeated in a book like this, a decision was
reached: the changes
were not put into the typewritten specification (for that
would be too difficult), but they would be incorporated into the system
itself. Or,
to put it another way: the project team found that it was
easier to change COBOL than it was to change English.
-
[4]
See James Martin, An Information Systems Manifesto (Englewood
Cliffs, NJ: Prentice-Hall, 1984).
-
[5]
Recall the definition and examples of real-time
systems in Chapter
2.
-
[6]
This is perhaps a bit unfair, as (DeMarco, 1978)
and (Gane and Sarson, 1977) devote a chapter
or more to the subject of data structures.
But their
notation (“data structure diagrams”) is now
generally considered obsolete; also, much
of the emphasis in the early textbooks was
on the conversion
of an arbitrary set of data structures into
third normal form, which is (1) simple enough
that the process has been mechanized, and
(2) more an
issue of implementation, or design, rather
than systems analysis.
-
[6a].
This may not be evident to you yet, for we have
seen only a few structured analysis diagrams in
Chapter 4.
However, by the end of Part II it should be abundantly
evident; if not, wait until the end of your first
“real” structured analysis project!
-
[7]
As we will see in Chapter
11, there should be one process specification
(usually written as a decision table, flowchart,
or in a structured English format) for each bottom-level
primitive bubble in the dataflow diagram. If the
system has been properly partitioned, most process
specifications should be less than a page long.
-
7a.
Examples of verification rules:
all the dataflows in a DFD must be named, and the names must be
defined in the data dictionary. All
the entries in the data dictionary
must correspond to dataflows or
stores
on the DFD. Each bubble in the
DFD must have at least one incoming
dataflow and at least one
outgoing dataflow. And so on.
-
[8] It
was common, for example, in
the mid-1990s, to see trade-magazine advertisements from CASE vendors
that promised “system development without programming”
or “from ‘bubbles’ to code, automatically!” In
addition, most of the early CASE tools were designed
for mainframe-based
COBOL application development,
and proved highly unsuitable
for developing client-server applications in newer
languages like Visual Basic.
|
|
|
|