CHAPTER 1 Introduction
2.4 Erosion
As pointed out earlier, the improvements in technology make it possible to make larger soft-ware systems. So, increasingly the investment represented by these softsoft-ware products is get-ting larger as well. The consequence of this is that because software represents a significant investment, companies will be reluctant to abandon it when new requirements come along.
Large software systems tend to have long life cycles, sometimes decades, during which new requirements are imposed on the system and adaptive maintenance is performed on the sys-tem. A phenomenon we have observed and report on in this thesis is that of design erosion (see Chapter 9).
The many small adaptations that are made to a software system have a cumulative effect on the system and over time, the changes may be quite dramatic even if all the individual changes are small. At any point during the evolution of a software system, such changes are taken in the context of all previous changes (i.e. the system as it is at that moment in time) and expectations about possible future changes that may need to be made. It is inevitable that errors of judgment are made with respect to future requirements. Consequently, the system may evolve in a direction where it is hard to make necessary adjustments. The larger a system and the longer it lives, the harder it is to detect such eroding changes.
Empirical evidence for this phenomenon is provided in [Eick et al. 2001]. In this work, the authors present a statistical analysis of change management data of a large telecommunica-tion system. One of the important conclusions of the authors is that “code decay is a generic
3 Research Questions
phenomenon“. However, erosion of software was identified much earlier by for instance [Perry
& Wolf 1992] who speak of architectural drift and erosion in their paper on software architec-ture. Later, [Parnas 1994] speaks of software aging and compares software aging to aging of humans. An interesting point that he identifies with this analogy is that, like human aging, software aging cannot be stopped but that we can fight the symptoms to prolong the life.
A few trends can be observed with respect to design erosion:
•
Fixing design erosion can be expensive. So expensive, in fact, that we have been able to find several examples of software or software components that were replaced rather than fixed.•
An eroded software system may become an obstacle for further development.2.5 Summary
In this section, we have outlined a set of trends in the field of software engineering that together form the context for this thesis. Software engineers have to deal with ever-growing amounts of ever more complex software. Doing so requires that they use a growing amount of commoditized software components and focus their development efforts on adding value to those commoditized components. On top of that they need to add variability so that their efforts are not lost for future generations of their software product. Also, they need to keep an eye out for future changes and try to dodge the effects of design erosion.
3 Research Questions
As mentioned before, this thesis consists of a number of articles. Each of these articles of course has its own goals and research questions. The goal of this section is not to merely rephrase these goals and questions but instead to connect the articles by putting these articles in the context of more general research questions.
The overall research question that motivates this thesis is:
Given the fact that new, potentially unexpected requirements will be imposed on a software system in the future, how can we prepare such a system for the neces-sary changes?
In addition to this main research question, three more research questions have been specified as well as a number of more detailed ones.
RQ 1 How can we prepare an object oriented framework for future changes and make it as reusable as possible?
RQ 1.1 What exactly is an OO framework?
RQ 1.2 How can reusability of OO framework classes be improved?
RQ 1.3 What are good practices for creating OO frameworks?
RQ 1.4 How can we assess in an early stage whether a framework is designed well enough for its quality requirements?
RQ 2 Given expected (future) variations in a software system, how can we plan and incorporate the necessary techniques for facilitating these variations
RQ 2.1 What is variability and what kind of terminology can we use to describe variability?
RQ 2.2 How can variation points be identified?
RQ 2.3 What kinds of variability techniques are there and can they be organized in a taxonomy?
RQ 2.4 How can an appropriate variability technique be selected given a taxonomy such as in RQ 2.3?
RQ 3 Can design erosion be avoided or delayed?
RQ 3.1 What is design erosion and why does it occur?
RQ 3.2 Why do so many software projects suffer from the consequences of design erosion?
RQ 3.3 What type of design changes are the most damaging?
RQ 3.4 What can be done to limit the impact of such damaging changes?
The articles included in this thesis are organized into three parts, each bundling articles that are related to one of the three research questions.
4 Research Approach
Research in the field of software engineering is somewhat different from research in other fields of computer science. The main difference is the presence of the human factor. It does not suffice to just consider the technical side of a problem without considering how the prob-lem affects the software engineering process; without considering the issues of how to inte-grate solutions to this problem in the practice of software engineering and without considering how to get people to agree that a particular technical solution is in fact a good solution.
In Figure 2, an overview is provided of our view of how software engineering relates to other fields. First of all, the problem domain is that of improving the practice of software manufac-turing. Problems are identified by observing and analyzing how software is engineered in prac-tice. Solutions to these problems consist of tools, techniques as well as methodology to apply them effectively. In order to provide such solutions, technical solutions from computer science research may be used. However, a mathematical proof of the correctness of these solutions is not enough to convince software practitioners to adopt such solutions. Software practitioners need to be convinced that a particular solution solves their problems, does not create new problems and that the solution is indeed feasible in their context. For this, research methodol-ogies such as case studies, surveys and action research are more appropriate. This way of doing research is more common in empirical sciences such as sociology and psychology than it is in natural sciences such as computer science.
4 Research Approach
The application of empirical research methods is increasingly popular in software engineering.
In his editorial for the journal of empirical software engineering [Basili 1996], Victor Basily makes a plea for the use of empirical studies to validate theories and models that are the result of software engineering research. In a more recent publication [Basili et al. 2002], he gives an overview of how empirical research has benefited NASA’s Software Engineering Lab.
In this thesis, we rely on our experience with several industrial cases for providing us with examples for our theories and for validating our approaches. By working together with indus-trial partners and by conducting surveys and interviews, we have learned a great deal about what problems software developing organizations encounter in practice and how it is affecting them. In the articles that comprise this thesis, we refer to these cases extensively and when-ever possible we use examples from these cases.
When doing empirical research, a distinction can be made between qualitative empirical stud-ies and quantitative studstud-ies. The latter type of studstud-ies is very useful for validating solutions to specific problems. However, when trying to establish what the issues are, such studies are less feasible because of a lack of quantifiable data. The approach, advocated by Basili in [Basili 1996] and [Basili et al. 2002], can be characterized as mostly quantitative. As can be seen in [Basili et al. 2002], collecting quantitative data is a labor intensive process that needs to be tightly integrated with the development process. In a setting like NASA, where reliable, dependable software is required this is feasible. The results of the quantitative empirical research are used to optimize the development processes.
Qualitative data, on the other hand, is relatively easy to obtain and has the advantage of pro-viding more explanatory information [Seaman 1999]. As is noted in [Seaman 1999], neither quantitative nor qualitative empirical research can prove a given hypothesis. Empirical research can only be used to support or refute a hypothesis. A combination of both is the best way of supporting a hypothesis.
Computer Science
Most of our explorative case studies are of a qualitative nature. Over the past few years, we have been in contact with several industrial parthers who have cooperated with us by provid-ing us access to internal documentation and by discussprovid-ing their work with us.
Although industrial validation of new approaches is the best way to demonstrate their suitabil-ity, doing so is easier said than done. Industrial validation requires the cooperation of industrial partners, which poses inherent time and money constraints on a study. Consequently, we sometimes have to resort to the usage of smaller, non industrial cases such as, for instance the framework, described in Chapter 3, which was re-used in Chapter 9.
5 Summary & Remainder of this thesis
In this introduction, we have sketched how the research field of software engineering has developed over the past few decades. In addition, we introduced a number of software engi-neering topics and listed a number of predominant software engiengi-neering trends.
Due to the ever expanding capacity and proliferation of computer hardware, there is a con-stant pressure on the research field of software engineering to enable the creation of more, and larger software systems. Also, because software systems. Increasingly developers are resorting to Commercial Of The Shelf (COTS) hardware and software components to create software systems. Also to be able to reuse existing pieces of software effectively, variability techniques are adopted to make the software more versatile. Finally, due to the increasing economic value of these ever larger software systems represent, companies are increasingly reluctant to replace them with new and improved versions. However, many systems erode and become increasingly harder to maintain due to the cumulative effect of adaptations to new requirements.
We listed a number of research questions that fit in this context and presented a discussion of the research method that is used to answer those questions. The remainder of this thesis con-sists of an overview of the included articles (Chapter 2), eight articles organized into three parts. Finally, the research questions that were formulated in Section 3, are answered and some concluding marks are presented in Chapter 11.