SOFTWARE ENGINEERING
SOFTWARE ENGINEERING---LAYERED TECHNOLOGY
Although hundreds of authors have developed personal definitions of software engineering,
a definition proposed by Fritz Bauer [NAU69] at the seminal conference on
the subject still serves as a basis for discussion:
[Software engineering is] the establishment and use of sound engineering principles in
order to obtain economically software that is reliable and works efficiently on real machines.
Almost every reader will be tempted to add to this definition. It says little about the
technical aspects of software quality; it does not directly address the need for customer
satisfaction or timely product delivery; it omits mention of the importance of
measurement and metrics; it does not state the importance of a mature process. And
yet, Bauer’s definition provides us with a baseline. What “sound engineering principles”
can be applied to computer software development? How do we “economically”
build software so that it is “reliable”? What is required to create computer programs
that work “efficiently” on not one but many different “real machines”? These are the
questions that continue to challenge software engineers.
The IEEE [IEE93] has developed a more comprehensive definition when it states:
Software Engineering: (1) The application of a systematic, disciplined, quantifiable approach
to the development, operation, and maintenance of software; that is, the application of
engineering to software. (2) The study of approaches as in (1).
2.1.1 Process, Methods, and Tools
Software engineering is a layered technology. Referring to Figure 2.1, any engineering
approach (including software engineering) must rest on an organizational commitment
to quality. Total quality management and similar philosophies foster a
continuous process improvement culture, and this culture ultimately leads to the
How do we
define
software
engineering?
?
“More than a
discipline or a body
of knowledge,
engineering is a
verb, an action
word, a way of
approaching a
problem.”
Scott Whitmire
CHAPTER 2 THE PROCESS
development of increasingly more mature approaches to software engineering. The
bedrock that supports software engineering is a quality focus.
The foundation for software engineering is the process layer. Software engineering
process is the glue that holds the technology layers together and enables rational
and timely development of computer software. Process defines a framework for a set
of key process areas (KPAs) [PAU93] that must be established for effective delivery of
software engineering technology. The key process areas form the basis for management
control of software projects and establish the context in which technical methods
are applied, work products (models, documents, data, reports, forms, etc.) are
produced, milestones are established, quality is ensured, and change is properly managed.
Software engineering methods provide the technical how-to's for building software.
Methods encompass a broad array of tasks that include requirements analysis,
design, program construction, testing, and support. Software engineering methods
rely on a set of basic principles that govern each area of the technology and include
modeling activities and other descriptive techniques.
Software engineering tools provide automated or semi-automated support for the
process and the methods. When tools are integrated so that information created by
one tool can be used by another, a system for the support of software development,
called computer-aided software engineering, is established. CASE combines software,
hardware, and a software engineering database (a repository containing important
information about analysis, design, program construction, and testing) to create a
software engineering environment analogous to CAD/CAE (computer-aided
design/engineering) for hardware.
2.1.2 A Generic View of Software Engineering
Engineering is the analysis, design, construction, verification, and management of
technical (or social) entities. Regardless of the entity to be engineered, the following
questions must be asked and answered:
• What is the problem to be solved?
• What characteristics of the entity are used to solve the problem?
21
Tools
A quality focus
Methods
Process
FIGURE 2.1
Software
engineering
layers
Software engineering
encompasses a
process, management
and technical methods,
and tools.
22 PART ONE THE PRODUCT AND THE PROCESS
• How will the entity (and the solution) be realized?
• How will the entity be constructed?
• What approach will be used to uncover errors that were made in the design
and construction of the entity?
• How will the entity be supported over the long term, when corrections, adaptations,
and enhancements are requested by users of the entity.
Throughout this book, we focus on a single entity—computer software. To engineer
software adequately, a software engineering process must be defined. In this section,
the generic characteristics of the software process are considered. Later in this chapter,
specific process models are addressed.
The work associated with software engineering can be categorized into three
generic phases, regardless of application area, project size, or complexity. Each phase
addresses one or more of the questions noted previously.
The definition phase focuses on what. That is, during definition, the software engineer
attempts to identify what information is to be processed, what function and performance
are desired, what system behavior can be expected, what interfaces are to
be established, what design constraints exist, and what validation criteria are required
to define a successful system. The key requirements of the system and the software
are identified. Although the methods applied during the definition phase will vary
depending on the software engineering paradigm (or combination of paradigms) that
is applied, three major tasks will occur in some form: system or information engineering
(Chapter 10), software project planning (Chapters 3, 5, 6, and 7), and requirements
analysis (Chapters 11, 12, and 21).
The development phase focuses on how. That is, during development a software
engineer attempts to define how data are to be structured, how function is to be implemented
within a software architecture, how procedural details are to be implemented,
how interfaces are to be characterized, how the design will be translated into a programming
language (or nonprocedural language), and how testing will be performed.
The methods applied during the development phase will vary, but three specific technical
tasks should always occur: software design (Chapters 13–16, and 22), code generation,
and software testing (Chapters 17, 18, and 23).
The support phase focuses on change associated with error correction, adaptations
required as the software's environment evolves, and changes due to enhancements
brought about by changing customer requirements. The support phase reapplies the
steps of the definition and development phases but does so in the context of existing
software. Four types of change are encountered during the support phase:
Correction. Even with the best quality assurance activities, it is likely that the
customer will uncover defects in the software. Corrective maintenance changes
the software to correct defects.
Adaptation. Over time, the original environment (e.g., CPU, operating system,
business rules, external product characteristics) for which the software was
Software is engineered
by applying three
distinct phases that
focus on definition,
development, and
support.
“Einstein argued that
there must be a
simplified
explanation of
nature, because God
is not capricious or
arbitrary. No such
faith comforts the
software engineer.
Much of the
complexity that he
must master is
arbitrary
complexity.”
Fred Brooks
WebRef
Crosstalk is a journal that
provides pragmatic
software engineering
advice and comment. Online
issues are available at
www.stsc.hill.af.mil
CHAPTER 2 THE PROCESS
developed is likely to change. Adaptive maintenance results in modification to
the software to accommodate changes to its external environment.
Enhancement. As software is used, the customer/user will recognize additional
functions that will provide benefit. Perfective maintenance extends the
software beyond its original functional requirements.
Prevention. Computer software deteriorates due to change, and because of
this, preventive maintenance, often called software reengineering, must be conducted
to enable the software to serve the needs of its end users. In essence,
preventive maintenance makes changes to computer programs so that they can
be more easily corrected, adapted, and enhanced.
In addition to these support activities, the users of software require continuing support.
In-house technical assistants, telephone-help desks, and application-specific
Web sites are often implemented as part of the support phase.
Today, a growing population of legacy programs1 is forcing many companies to
pursue software reengineering strategies (Chapter 30). In a global sense, software
reengineering is often considered as part of business process reengineering.
The phases and related steps described in our generic view of software engineering
are complemented by a number of umbrella activities. Typical activities in this category
include:
• Software project tracking and control
• Formal technical reviews
• Software quality assurance
• Software configuration management
• Document preparation and production
• Reusability management
• Measurement
• Risk management
Umbrella activities are applied throughout the software process and are discussed in
Parts Two and Five of this book.
