Object-Oriented Defect Management of Software: the Basics
- Software, Software Engineering, and the Software Engineering Process
- Object Orientation
- Defect Management
- Specifying Quality
- Views of Quality
- Internal Quality and External Quality: Form Complements Function
- Software Product Quality Attributes
- Assessing Product Quality
- Achieving Quality Goals
- Conclusion
This chapter is from the book
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.
Delivery for use in the field.
Continuous assessment of suitability and artifact maintenance.
In our discipline we refer to these activities as follows:
Requirements elicitation, analysis, and specification (sometimes called requirements engineering).
Design and design specification.
Implementation.
Verification and validation.
Delivery and installation.
Maintenance.
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.