Programming languages and programming technologies have continued to evolve since the birth of computing, bringing significant improvements to programmer productivity and addressing software engineering issues and concerns that have become apparent over time. Unfortunately, the vast majority of the applications in use today have not benefitted from many of these advances. For example, large-scale legacy applications written in Cobol still constitute the computing backbone of many large businesses. Such applications are notoriously difficult and time-consuming to update in response to changing business requirements. Similarly, a large body of technical software and system software is written in C. Maintaining and evolving such software is even harder.
One of the fundamental reasons that such legacy applications are hard to understand, maintain, evolve, or reuse, is the scattering and tangling of code fragments addressing many different concerns. While this problem can show up even in applications written in modern languages, this is an even bigger issue with applications written in legacy languages such as Cobol and C.
Aspect-oriented software development (AOSD) has emerged over the last decade as a paradigm for separation of concerns: avoiding the aforementioned problem of code scattering and tangling. It seeks to achieve a separation of concerns even for those cross cutting concerns that are difficult to decompose and isolate with earlier programming methodologies. Aspect-oriented programming permits programmers to organize code, design and other artifacts together in a more logical, natural, way according to the concern they address. A complete application is produced by composing, or weaving, separate concerns together.
Aspect-oriented software development promises significant benefits in the areas of software comprehension, maintenance and evolution and could therefore play an important role in the revitalization of aforementioned legacy systems. However, most of existing AOSD approaches seem to have focused primarily on identifying, specifying and implementing aspects for systems that are developed from scratch. Fully exploiting AOSD in the context of legacy software systems imposes different requirements and constraints and has it's own set of challenges and open problems that need to be solved.
The seminar focused on the following question: how can aspects help us to understand, maintain, and transform legacy systems? The term “legacy systems”, in this context, includes both “classic legacy” (applications written in languages such as Cobol and C) as well as “modern legacy” (applications written in object-oriented languages such as C++ and Java) and “future legacy” (applications that were developed using AOSD and need evolution).
The goal of the seminar was to bring together researchers from the domains of aspect oriented software development, software reengineering (with a focus on reverse engineering, program comprehension, software evolution and software maintenance) and program analysis to investigate how legacy systems can benefit from aspect oriented software development techniques, discuss the state of the art in aspect identification and refactoring, identify open research questions and establish a roadmap for joint research in this area.
The following topics and problems were considered relevant to the topic, though not all of these were addressed in the seminar due to time limitations::
- Idioms and design patterns in (different kinds of) legacy systems, which serve to identify common concerns/aspects in legacy systems.
- Use of aspects as views of a legacy system to improve ones understanding of that system.
- Recovering aspects (i.e., identifying the lines of code that implement a particular concern) from legacy systems.
- Aspect languages and weavers for legacy languages (especially non-object-oriented languages).
- Using aspects to guide reimplementation of a legacy system (also known as 'early aspects').
- Supporting migration from legacy implementation to an aspect-based implementation (either in the same or different base programming language).
- Evolution of systems that were developed using aspect oriented software development techniques (the legacy systems of the future).
- Bram Adams (Ghent University, BE) [dblp]
- Sue Black (London South Bank Univ. - London, GB)
- Silvia Breu (Cambridge, GB)
- Magiel Bruntink (CWI - Amsterdam, NL)
- Mariano Ceccato (Centro Ricerche FIAT - Trento, IT) [dblp]
- Siobhán Clarke (Trinity College Dublin, IE) [dblp]
- James R. Cordy (Queen's University - Kingston, CA) [dblp]
- Rui Correia (University of Leicester, GB)
- Maja D'Hondt (University of Lille I, FR)
- Oege de Moor (University of Oxford, GB)
- Kris De Schutter (Ghent University, BE)
- Mohammad El-Ramly (University of Leicester, GB)
- Jean-Marie Favre (LSR - IMAG, FR) [dblp]
- John H. Field (IBM TJ Watson Research Center - Hawthorne, US) [dblp]
- Michael W. Godfrey (University of Waterloo, CA) [dblp]
- Ahmed E. Hassan (University of Waterloo, CA) [dblp]
- Andy Kellens (Free University of Brussels, BE)
- Raghavan Komondoor (IBM India Research Lab. - New Delhi, IN)
- Kostas Kontogiannis (University of Waterloo, CA)
- Rainer Koschke (Universität Bremen, DE) [dblp]
- Jens Krinke (FernUniversität in Hagen, DE) [dblp]
- Kiarash Mahdavi (King's College London, GB)
- Marius Marin (TU Delft, NL) [dblp]
- Kim Mens (University of Louvain, BE) [dblp]
- Tom Mens (University of Mons, BE) [dblp]
- Leon Moonen (CWI - Amsterdam, NL) [dblp]
- Hausi A. Müller (University of Victoria, CA) [dblp]
- Ganesan Ramalingam (IBM India Research Lab, IN) [dblp]
- Martin Robillard (McGill University - Montreal, CA) [dblp]
- Atanas Rountev (Ohio State University - Columbus, US)
- Americo Sampaio (Lancaster University, GB)
- Tom Tourwé (CWI - Amsterdam, NL)
- Andrew Walenstein (University of Louisiana - Lafayette, US)
- Andy Zaidman (University of Antwerp, BE) [dblp]
- programming languages / compiler
- software evolution
- aspect identification (aspect mining)
- program understanding
- program transformation
- program analysis