This chapter is from the book

This chapter is from the book

Software, Software Engineering, and the Software Engineering Process

The profession of software engineering, like any other engineering
profession, is concerned with building of artifacts; in this case, of software.
When professionals build things they usually aim to produce the highest quality
artifact possible utilizing the minimal amount of resources necessary to achieve
this aim; anything else would be wasteful. Paying attention to what is done, how
it is done, who does it, under what conditions, and what tools are utilized
becomes paramount. In other words, process becomes important and its quality
underpins the quality of the product being produced.

Software engineering is therefore the collective term applied to
attempts to produce the highest quality product possible, of often complex and
large software systems, on a reasonably sustainable and repeatable basis with
minimal resource expenditure. To do so, software engineering has relied and
continues to rely on three principal approaches and a number of other
disciplines. The three principal approaches are:

Improving the management of the software development process;

Establishing a rigorous foundation for software development; and

Technology support.

In discussing the relationship between the quality of a product and the
process that yields such a product, it is possible to postulate that the
external quality attributes of a product can be deemed as functions of process
attributes. This, in turn, implies that a software process must have a
methodological dimension and a technological aspect (Haas et al., 1994).
Furthermore, there is also an undeniable organizational dimension (Humphrey,
1989) that pervades any actual instantiation of a specified software process.
Therefore, for our purposes, I define a software process as the organization of
technologies and methods utilized within a particular context by an entity to
produce a software product.

This definition captures the most current understanding of the term and
differs from those that equate a software process and a development methodology,
in that the latter implies that the mere adoption of a software development
methodology is sufficient for ensuring increased software quality (Sauer &
Lau, 1994). Such a definition fails to explain, for example, why a given formal
methodology succeeds in one situation or organization and not in another.

Although I believe the stated definition is workable, I recognize that the
dimensions cited may not be exhaustive or entirely orthogonal.

In fact, most current definitions for process, if not explicitly, at least
implicitly recognize the existence of all the three dimensions mentioned in this
definition. It has been asserted (Humphrey, 1989; Younessi &
Henderson-Sellers, 1997) that the three major areas of concern enumerated
earlier support the notion that the process of software development relies on
these three major elements:

People and organizational influences (hence the need for improved
management);

Methodology (hence the need for rigor and formality); and

Technology (hence the need for tool and technological support).

Hence, I present the preceding definition. In the same article Younessi and
Henderson-Sellers (1997) further asserted that it is the balance of elements
from these three dimensions that defines a process and leads to the recognition
of a specific level of process quality.

A Constructive1 Approach to Software Engineering

The process of constructing software is not monolithic, nor should it be
considered as such. Building of software can be thought of as assembling of a
group of carefully selected techniques that together produce the software
artifact being built and any intermediate products required. This
"Lego™"2 approach to software construction allows us to
concentrate on specific techniques, maybe even a variety of techniques, that are
suitable for achievement of a particular task. We can then define what that
technique is, how it is applied, what products it generates, what resources are
required, how it interfaces with other techniques and even sometimes how
effective it is and under what conditions. This approach allows a degree of
comparative analysis between individual techniques and is the one I use in this
book.

In fact we can take this approach one step further and envisage the software
engineering process as a collection of activities, the end result of which
yields the software product. Activities can therefore be considered as being
composed of a collection of tasks. A task can be thought of as a unit of work
for the conduct of which we might have one or several techniques, yielding one
or several work products. This constructive approach is, incidentally, the
essence of a number of the modern software processes such as the Object-Oriented
Process Environments and Notation (OPEN; Graham et al., 1997), as shown in
Figure 1.1.

Figure 1.1
OPEN's core relationships as an example of a constructive
approach.

The Process of Constructing Software

It seems that there is in any construction project, whether it is a quilt, a
fighter jet, a house, or a piece of software, a number of activities that have
to be performed. These are, at a minimum, the following:

Finding out about the problem that this construction needs to
solve.

Coming up with one or several alternate solutions to this
problem.

Actual construction of the solution artifact.

Evaluation of the suitability of the artifact and its ability to solve
the problem.

Current software process frameworks such as OPEN (Graham et al., 1997) and
the Rational Unified Process (RUP; Jacobson et al., 1999) recognize this fact
and thus allow for planning a software process instance that contains tasks to
realize each and every one of these activities. As mentioned before, however,
there are a variety of tasks that can be attributed to each of these activities.
For example, testing may be a task selected as part of the verification and
validation activity for a particular project. Mutation testing (Budd,
1980) might be the technique used to accomplish this task. Alternatively (or in
conjunction), we might select inspection as another task within the verification
and validation activity. The technique of Strauss and Ebenau (1995) might be
used for accomplishing this inspection task.

In a later discussion, we shall see that looking at the software engineering
process from this perspective has a distinct advantage in terms of what we
intend to do in this book. It would allow us to look at each activity, task, and
specifically each technique as a means of managing defects, defined as
any shortcoming in a software product deliverable.

The definition of a software process is also paradigm-based, meaning that the
choice of tasks and techniques to achieve each software engineering activity
depends on an overall way of thinking, a philosophical perspective, or a
paradigm. For example, choosing a transformationally based paradigm (which
assumes that a problem situation, the solution to the problem, and thus the
software system that delivers that solution can all be adequately modeled in
terms of a series of changes to some inputs by a number of transformations to
generate certain outputs) would require the selection of certain modeling
techniques (e.g., a flowchart) that would be inappropriate if we had taken a
causal paradigm, which assumes that a system can be adequately modeled based on
state transitions. Thus the choice of a paradigm plays a central role in the
selection of the tasks and techniques that are to be completed, which, in turn,
would define our defect management effort with respect to each. Our paradigm in
this book is object-oriented.