A software system's structure degrades over time, a phenomenon that is known as software decay or design drift. Since the quality of the structure has major impact on the maintainability of a system, the structure has to be reconditioned from time to time. Even if recent advances in the fields of automated detection of bad smells and refactorings have made life easier for software engineers, this is still a very complex and resource consuming task.Search-based approaches have turned out to be helpful in aiding a software engineer to improve the subsystem structure of a software system. In this paper we show that such techniques are also applicable when reconditioning the class structure of a system. We describe a novel search-based approach that assists a software engineer who has to perform this task by suggesting a list of refactorings. Our approach uses an evolutionary algorithm and simulated refactorings that do not change the system's externally visible behavior. The approach is evaluated using the open-source case study JHotDraw.

The subsystem decomposition of a software system degrades gradually during its lifetime and therefore it gets harder and harder to maintain. As a result this decomposition needs to be reconditioned from time to time. The problem is to determine a suitable subsystem decomposition that can be used as a basis for future maintenance tasks. This paper describes a new methodology that computes such a subsystem decomposition by optimizing metrics and heuristics of good subsystem design. The main idea is to treat this task as a search problem and to solve it using a genetic algorithm.

Software inevitably changes. As a consequence, we observe the phenomenon referred to as "Software Entropy" or "Software Decay": the software design continually degrades making maintenance and functional extensions overly costly if not impossible. There exist a number of approaches to identify design flaws (problem detection) and to remedy them (refactoring). There is, however, a conceptual gap between these two stages: There is no appropriate support for the automated mapping of design flaws to possible solutions. In this paper we propose an integrated, quality-driven and tool-supported methodology to support object-oriented software evolution. Our approach is based on the novel concept of "correction strategies". Correction strategies serve as reference descriptions that enable a humanassisted tool to plan and perform all necessary steps for the safe removal of detected design flaws, with special concern towards the targeted quality goals of the restructuring process. We briefly sketch our tool chain and illustrate our approach with the help of a medium-sized real-world case-study

In order to satisfy the changing needs of customers and clients, software systems have to be adapted during their whole lifetime. One frequently occurring task is adding a new function to the interface of a (sub-) system. To implement the new functionality, not only the interface has to be extended but several other classes of the (sub-) system. Performing this task manually is tedious and error-prone. In this paper a method is described that simplifies implementing extensions of the above kind. The basic idea is using adaptive programming (AP) , so that new functionality can be described with the help of paths in the class structure and source code transformations.

No abstract