In an information technology society that is increasingly relying on software, the productivity and quality of software 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 is still undervalued in traditional software development processes, despite recent estimates saying that maintenance makes up to 90% of the cost of a software system. The only way to avoid the negative effects of software aging is to place 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.
In recent years, in an attempt to increase evolvability, agile development has gained increased attention in the context of object-oriented programming, together with a major technological innovation, namely refactorings: They promote a development methodology in which a software system is regarded as a complex entity which is continuously restructured by means of behavior-preserving code transformations (e.g., extract method, rename class, move method, privatize attribute, etc.). Another factor which is changing the established view that writing software is equivalent to writing text into an editor is the advent of modern integrated development environments (IDEs, such as Eclipse) which offer incremental compilation support together with a more structured system view by means of class browsers instead of the classical view offered by text editors. Indeed, software is constructed or built, not written. While incremental compilation and refactorings are already focusing on changes as first-level entities, this had a minimal impact on the versioning systems from the software configuration management field. They use the checkin/checkout model with text files (software is versioned at explicit requests by a developer, not automatically), introducing thus a mismatch with modern IDE-driven development which promotes a more structural and logical view by hiding the physical structure. Moreover, the information they record is purely structural and all the semantic information of the changes (the types of the code transformations) is lost.
Software evolution, a recognized research field (that is concerned with issues such as reverse engineering, finding historical trends, etc.) still suffers from this fundamental problem: The history of software systems is recorded with file-based versioning systems such as CVS. This has a negative impact on the research field, because all fine-grained changes (and their semantics) are lost and cannot be recovered at all or only partially.
The goal of this project is to provide the technology to record all changes, including refactorings performed on object-oriented systems by leveraging the information produced by modern development environments, and to develop a methodology to exploit the recorded data to enable a finer-grained analysis of the evolution. It aims to answer the following questions:
1. Can we model object-oriented software evolution by treating semantic change as a first-class entity? Is there a language-independent subset of this model for object-oriented languages?
2. Can we improve software change and evolution support in day-to-day tasks, if we provide tools integrated with development environments?
We propose to answer these questions by modeling the change process using first-class change operations with object-oriented semantics such as refactoring operations.