For a variety of reasons, software must evolve to cope with change. Unfortunately, evolution and maintenance is an expensive, time-consuming, and error-prone task, especially when the system in question is large and complex. Typically, a change to a single program element requires changes to related, and often seemingly unrelated, elements scattered throughout the source code.
To address this problem, approaches have emerged to mechanically assist developers with a wide range of software evolution and maintenance tasks. This assistance is typically provided in the form of extensions (plug-ins) to integrated development environments (IDEs) that afford (semi-) automated aid in carrying out these tasks, thus easing the burden associated with evolution and maintenance.
Although existing approaches are useful in alleviating some of the burden associated with software evolution and maintenance, there are a number of situations where developers are still required to complete evolution and maintenance tasks manually. Automated approaches to assist developers with such cumbersome and error-prone tasks would be extremely useful in evolving and maintaining large, complex systems.
In this thesis, I develop several new techniques that can be of great value to software developers in evolving code to accommodate change. The first is an automated refactoring that upgrades legacy Java code to use proper language enumeration (enum) types, a feature of the modern Java language. I have developed an approach that preserves semantics and that allows us to migrate legacy applications by automatically replacing a predominantly used pattern with suitable use of enums.
The second technique is an automated approach to assist developers in maintaining pointcuts in evolving Aspect-Oriented (AO) programs. AO languages enable developers to better encapsulate crosscutting concern (CCC) implementations by allowing them to create an expression (a pointcut) which specifies well-defined points (join points) in a program's execution where code corresponding to a CCC (an aspect) should apply. However, changes to the underlying program (base-code) may invalidate pointcuts, leaving developers to manually update pointcuts to capture the intended join points. My approach mechanically aids developers in suitably updating pointcuts upon changes to the base-code by analyzing arbitrarily deep structural commonalities between program elements associated with pointcuts in a particular software version. The extracted patterns are then applied to later versions to suggest additional join points that may require inclusion.
The third technique pertains to reasoning about the behavior of AO programs. AOP facilitates localized implementations of CCCs by allowing developers to encapsulate code realizing a CCC that would otherwise be scattered and tangled. Therefore, AOP allows developers to think about “one concern at a time.” However, reasoning about AOP presents unique challenges, particularly as such programs evolve. I have developed an approach to specify the behavior of aspects in such a way that they can be combined with the behavior of the base-code to arrive at the overall system behavior without invalidation. Although the technique is not currently automated and planned future work does not involve fully automating this technique, I nevertheless explore ways to assist developers by mechanizing portions of the associated reasoning activities.