SBSE Meets Software Maintenance: Achievements and Open Problems

Abstract

Software maintenance is, together with testing, one of the most critical and effort-prone activities in software development. Surveys conducted in the past [4] have estimated that up to 80% of the overall software development cost is due to maintenance activities. For such a reason, automated techniques aimed at supporting developers in their daunting tasks are highly appealing. Problems developers often face off include understanding undocumented software, improving the software design and source code structure to ease future maintenance tasks, and producing patches to fix bugs. Finding a solution for the aforementioned problems is intrinsically NP-Hard, and therefore such problems are not tractable with conventional algorithmic techniques; this is particularly true in presence of very complex and large software systems. For this reason, search-based optimization techniques have been--and currently are--successfully applied to deal with all the aforementioned problems. Noticeable examples of successful applications of search-based software engineering (SBSE) to software maintenance include software modularization [2], software refactoring [3], or automated bug fixing [1]. Despite the noticeable achievements, there are still crucial challenges researchers have to face-off. First, software development is still an extremely human-centric activity, in which many decisions concerning design or implementation are really triggered by personal experience, that is unlikely to be encoded in heuristics of automated tools. Automatically-generated solutions to maintenance problems tend very often to be meaningless and difficult to be applied in practice. For this reason, researchers should focus their effort in developing optimization algorithms--for example Interactive Genetic Algorithms [5]--where human evaluations (partially) drive the production of problem solutions. This, however, requires to deal with difficulties occurring when involving humans in the optimization process: human decisions may be inconsistent and, in general, the process tend to be fairly expensive in terms of required effort. A further challenge where SBSE meets software maintenance concerns systems which necessitate rapid reconfigurations at run-time, e.g., highly dynamic service-oriented architectures, or autonomic systems. If, on the one hand, such reconfigurations imply complex decisions where the space of possible choices is high, on the other hand such decisions have to be taken in a very short time. This implies a careful choice and performance assessment of the search-based optimization techniques adopted, aspect that is often not particularly considered when search-based optimization techniques are applied offline, e.g. for test data generation or for software modularization. Last, but not least, many modern software systems--open source and not only--are part of large and complex software ecosystems where the evolution of a component might impact others, e.g., by creating incompatibilities from a technical or even legal point of view. Also in this case, SBSE has a great potential to support the explore such large spaces of software configurations.