For a variety of reasons, modern, non-trivial software systems must evolve to cope with change, including alterations in stakeholder requirements, environments in which the software is deployed, and dependent technologies, e.g., frameworks. 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, including migrating code to a new framework version, translating existing code to a new platform, and restructuring code to mirror an improved design. 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. In some approaches, the corresponding plug-in keeps track of the elements relevant to the change being implemented, with the IDE displaying only those elements. Other approaches attempt to automatically restructure code to improve such features as type safety while preserving semantics. 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. These include but are not limited to upgrading legacy Java software to take advantage of many other available features of the modern Java language, replacing certain usages of Java collections with custom type hierarchies, and updating software composition specifications to cope with change. 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 explore and develop a number of new techniques that can be of great value to software developers in evolving code to accommodate change. The first of these is an automated refactoring which 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. For the second technique, I explore and develop 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. I have developed an approach that 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 I explore in this thesis pertains to reasoning about the behavior of AO programs. As previously noted, AOP facilitates localized implementations of CCCs by allowing developers to encapsulate code realizing a CCC that would otherwise be scattered throughout many system modules and/or intertwined with code realizing the primary functionality of a module. Theref

1. Techniques for Automated Software
Evolution
PhD Dissertation by Raffi Khatchadourian
Computer Science & Engineering
Ohio State University
Advisor: Neelam Soundarajan
Committee: Atanas Rountev, Paul Sivilotti, Paul Evans
1

2. Biography
• Born in New York, NY and raised in Edison, NJ.
• First generation American.
• Family immigrated from Sofia, Bulgaria.
• Graduated from Monmouth University in 2004 with a B.S. in Computer
Science.
• Worked as:
• A Software Engineer at State of New Jersey Office of Information
Technology in Trenton, NJ.
• A UNIX Systems Administrator for pharmaceutical website in Toms
River, NJ.
• Entered PhD program at OSU in September, 2005.
• M.S. in Computer Science from OSU in March, 2010.
• Start as an RF (wireless) Systems Integration Engineer on the iPhone
development team at Apple Inc. in Cupertino, CA on Monday (4/4/2011).
2

3. Publication Highlights
• Raffi Khatchadourian, Phil Greenwood, Awais Rashid, and Guoqing Xu.
Pointcut rejuvenation: Recovering pointcut expressions in evolving
aspect-oriented software. IEEE Transactions on Software Engineering,
99(PrePrints), 2011. ISSN 0098-5589.
• Raffi Khatchadourian, Phil Greenwood, Awais Rashid, and Guoqing Xu.
Pointcut rejuvenation: Recovering pointcut expressions in evolving
aspect-oriented software. In Proceedings of the 24th International Conference
on Automated Software Engineering (ASE ’09), pages 575–579, Auckland, New
Zealand, November 2009. IEEE/ACM.
• Raffi Khatchadourian, Johan Dovland, and Neelam Soundarajan. Enforcing
behavioral constraints in evolving aspect-oriented programs. In
Proceedings of the 7th International Workshop on Foundations of Aspect-
Oriented Languages (FOAL ’08) at the 7th International Conference on Aspect-
Oriented Software Development (AOSD ’08), pages 19–28, Brussels, Belgium, April
2008. ACM.
• Raffi Khatchadourian, Jason Sawin, and Atanas Rountev. Automated
refactoring of legacy Java software to enumerated types. In Proceedings
of the 23rd International Conference on Software Maintenance (ICSM ’07),
pages 224–233, Paris, France, October 2007. IEEE.
• Peer-reviewed totals (2005-): 1 paper to appear in a journal, 5 papers appearing in
conference proceedings, and 5 papers appearing in workshop proceedings. 3

4. Activity Highlights
• Helped develop new Applied Software Engineering course ECE/CSE 668
based on Challenge-X hybrid SUV automobile simulation at OSU CAR
in 2006.
• Summer intern at Bell Labs under Rick Hull and Kedar Namjoshi
(program language design for shared-experience, multimedia, multi-
protocol, event-driven applications) in 2007.
• Visiting Graduate Research Associate with the Aspect-Oriented Software
Engineering (AOSE) Group at the Computing Department of Lancaster
University, UK under Awais Rashid in 2008.
• Visiting Researcher with the Programming Principles and Practices
(PPP) Group at the Department of Graphics and Computer Science of the
University of Tokyo under Hidehiko Masuhara in 2010.
• Proposed project mentor for Google Summer of Code (GSoC) in 2009
and 2010. Project based on refactoring to enumerated types in Java.
• Organizing committee member (Web Chair) for the European
Conference on Object-Oriented Programming (ECOOP).
4

5. Award Highlights
• Japan Society for the Promotion of Science
(JSPS) Summer Program Fellowship Recipient in
2010.
• National Science Foundation (NSF) East Asia
and Pacific Summer Institutes (EAPSI) Award
Recipient in 2010.
• Ohio State University Department of Computer
Science & Engineering Graduate Teaching Award
Recipient in 2010.
5

6. Motivation
6

7. Motivation
• Software changes over
time:
6

8. Motivation
• Software changes over
time:
• Requirements evolve
6

9. Motivation
• Software changes over
time:
• Requirements evolve
• New platforms emerge
(e.g., mobile devices)
6

10. Motivation
• Software changes over
time:
• Requirements evolve
• New platforms emerge
(e.g., mobile devices)
• Frameworks change
(e.g., XML vs.
annotation-based)
6

11. Motivation
7

12. Motivation
Changing and/or maintaining large, complex software
systems can be non-trivial:
Tedious: May require changing many lines of
code.
Error-prone: Changes may be implemented
incorrectly.
Omission- May opportunities to produce better
prone: code.
7

13. Motivation
Changing and/or maintaining large, complex software
systems can be non-trivial:
Tedious: May require changing many lines of
code.
Error-prone: Changes may be implemented
incorrectly.
Omission- May opportunities to produce better
prone: code.
7

14. Motivation
Adding a
parameter to a
Changing and/or maintaining large, complex software
systems can be non-trivial: method
Tedious: May require changing many lines of
code.
Error-prone: Changes may be implemented
incorrectly.
Omission- May opportunities to produce better
prone: code.
7

15. Motivation
Changing and/or maintaining large, complex software
systems can be non-trivial:
Tedious: May require changing many lines of
code.
Error-prone: Changes may be implemented
incorrectly.
Omission- May opportunities to produce better
prone: code.
7

16. Motivation
Removing a
Changing and/or maintaining large, complex software
systemsparameter may
method can be non-trivial:
alter overloading to
Tedious: May require changing many lines of
overriding
code.
Error-prone: Changes may be implemented
incorrectly.
Omission- May opportunities to produce better
prone: code.
7

17. Motivation
Changing and/or maintaining large, complex software
systems can be non-trivial:
Tedious: May require changing many lines of
code.
Error-prone: Changes may be implemented
incorrectly.
Omission- May opportunities to produce better
prone: code.
7

18. Motivation
Changing and/or maintaining large, complex software
systems can be non-trivial:
Tedious: May require changing many lines of
code.
HashTable vs.
Error-prone: Changes may be implemented
incorrectly. HashMap
Omission- May opportunities to produce better
prone: code.
7

19. Motivation
Changing and/or maintaining large, complex software
systems can be non-trivial:
Tedious: May require changing many lines of
code.
Error-prone: Changes may be implemented
incorrectly.
Omission- May opportunities to produce better
prone: code.
7

20. Approach
8

21. Approach
• Approaches made to
provide mechanical
assistance in evolution
tasks.
8

22. Approach
• Approaches made to
provide mechanical
assistance in evolution
tasks.
• Typically in the form of
plug-ins to IDEs.
8

23. Approach
• Approaches made to
provide mechanical
assistance in evolution
tasks.
• Typically in the form of
plug-ins to IDEs.
• Ease the burden of
software maintenance
and evolution.
8

24. Approach
Restrict
workspace to only
• Approaches made to displays elements
provide mechanical relevant to the
assistance in evolution task
tasks.
• Typically in the form of
plug-ins to IDEs.
• Ease the burden of
software maintenance
and evolution.
8

25. Approach
Restrict
workspace to only
• Approaches made to displays elements
provide mechanical relevant to the
assistance in evolution task
tasks.
• Typically in the form of
plug-ins to IDEs.
Restructure
•code the burden of
Ease while preserving
semantics (i.e.,
software maintenance
and evolution.
refactoring)
8

26. Thesis Outline
9

27. Thesis Outline
• For my thesis, I have pursed three directions:
9

28. Thesis Outline
• For my thesis, I have pursed three directions:
1. Mechanically alleviate burden of fragile pointcuts in
Aspect-Oriented software.
9

29. Thesis Outline
• For my thesis, I have pursed three directions:
1. Mechanically alleviate burden of fragile pointcuts in
Aspect-Oriented software.
2.Automatically refactor legacy Java software to
language enumerated (enum) types.
9

30. Thesis Outline
• For my thesis, I have pursed three directions:
1. Mechanically alleviate burden of fragile pointcuts in
Aspect-Oriented software.
2.Automatically refactor legacy Java software to
language enumerated (enum) types.
3.Robustly specify evolving Aspect-Oriented software
components.
9