COSE - Controlling Software Evolution
In an information technology society that is increasingly relying on software, software productivity and quality continue to fall short of expectations: software systems suffer from signs of aging as they are adapted to changing requirements. The main reason for this problem is that software maintenance and software change is still undervalued in traditional software development processes. The only way to overcome or avoid the negative effects of software aging is by placing change in the center of the software development process. Without explicit and immediate support for change and evolution, software systems become more and more complex, fragile and unreliable. This negative spiral is rapidly shortening due to hardware and business innovations, changes in legislation and continuing internationalisation. We must therefore advance beyond the engineering metaphor of current software development, and provide more and better support for software change and evolution. The goal of this project is to investigate means to analyze and control the evolution of a software system at various levels. Specifically, it aims to answer the following questions:
- How does the architecture of a software system evolve over time? What are signs of architectural decay and how can they be tracked down?
- How can hidden dependencies in a system that complicate and hinder its evolution be discovered? How can existing analysis methods be adapted, revised, or enhanced to enable that?
- How can the plethora of software data (source code, change and bug history, release data) be filtered and visualized? What are effective visualization models and techniques for that?
We propose to tackle these questions by exploiting and understanding the huge amounts of information which reside in versioning and bug tracking systems, but which seem to be largely ignored by software industry. We focus on large-scale software systems both from the open source and the industrial area. The project consists of the following tracks:
Architecture Recovery and ControlA software system is often designed with a specific type of architecture (e.g., layered, event-based, shared memory, etc.) in mind. However as the system evolves, the introduction of new dependencies may corrupt the original architecture, thus having a negative effect on the maintainability of the system. We plan to reconstruct the architectural history of software systems and to infer when and how the architecture decayed.
Change Dependency ControlWhen a software system changes, it seldom does so only in one specific part, but changes tend to be scattered all over the system. While some of these changes happen together by pure accident, other changes happen due to dependencies in the source code that generate expensive avalanches of changes, also called shotgun surgery patterns. We plan to model all structural dependencies in a system and then see whether certain artifacts are located in the wrong part of the system, or whether they should be assigned to other developers.
Evolution VisualizationOur previous research in this area has clearly shown that handling such large amounts of data is not possible without adequate means to understand it. Visualization has proven itself to be the most effective way of breaking down the data complexity. We plan to use existing tools written by us and extend the great body of knowledge in visualization that we have built up during the past few years.