July 26 – 29 , 2006, Dagstuhl Seminar 06302

Aspects For Legacy Applications


Siobhán Clarke (Trinity College Dublin, IE)
Leon Moonen (CWI – Amsterdam, NL)
Ganesan Ramalingam (IBM India Research Lab, IN)

For support, please contact

Dagstuhl Service Team


Dagstuhl Seminar Proceedings DROPS
List of Participants


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).


  • Programming Languages / Compiler


  • AOSD
  • Software evolution
  • Aspect identification (aspect mining)
  • Refactoring
  • Program understanding
  • Program transformation
  • Program analysis


In the series Dagstuhl Reports each Dagstuhl Seminar and Dagstuhl Perspectives Workshop is documented. The seminar organizers, in cooperation with the collector, prepare a report that includes contributions from the participants' talks together with a summary of the seminar.


Download overview leaflet (PDF).

Dagstuhl's Impact

Please inform us when a publication was published as a result from your seminar. These publications are listed in the category Dagstuhl's Impact and are presented on a special shelf on the ground floor of the library.


Furthermore, a comprehensive peer-reviewed collection of research papers can be published in the series Dagstuhl Follow-Ups.