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.

No abstract

Software architecture reflects important decisions on structure, used technology and resources. Architecture decisions influence to a large extent requirements on software quality.

Integrating 3rd party components in software systems provides promising advantages but also risks due to disconnected evolution cycles. Deciding whether to migrate to a newer version of a 3rd party component integrated into selfimplemented code or to switch to a different one is challenging. Dedicated evolution support for 3rd party component scenarios is hence required. Existing approaches do not account for open source components which allow accessing and analyzing their source code and project information. The approach presented in this paper combines analyses for code dependency, code quality, and bug tracker information for a holistic view on the evolution with 3rd party components. We applied the approach in a case study on a communication middleware component for industrial devices used at ABB. We identified 7 methods potentially impacted by changes of 3rd party components despite the absence of interface changes. We further identified selfimplemented code that does not need any manual investigation after the 3rd party component evolution as well as a positive trend of code and bug tracker issues.

Software evolution is omnipresent and only with adequate flexibility it can be mastered in time and budget. Flexibility is supported by many architectural mechanisms, but more methodological support for a life-cycle-phases bridging approach of flexibility is still desirable. Therefore, in this paper we contribute a life-cycle-phases bridging approach for flexibility. Our approach supports architects during system design to achieve flexibility and during system evolution to exploit flexibility. We build on existing flexibility analysis techniques and extend them to give architects specific guidance and tool-support. For architecture design, we introduce an automated flexibility analysis with real-time feedback in architecture tools. For software evolution we provide a flexibility exploitation analysis which builds up on the results of the design time analysis and enables effective utilization of provided flexibility by deriving flexibility-aware work-plans. We demonstrate our approach by applying it to a checkin system, report first validation results from an empirical study and propose further validation activities.