26. – 29. Juli 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)

Auskunft zu diesem Dagstuhl-Seminar erteilt

Dagstuhl Service Team


Dagstuhl Seminar Proceedings DROPS


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


Bücher der Teilnehmer 

Buchausstellung im Erdgeschoss der Bibliothek

(nur in der Veranstaltungswoche).


In der Reihe Dagstuhl Reports werden alle Dagstuhl-Seminare und Dagstuhl-Perspektiven-Workshops dokumentiert. Die Organisatoren stellen zusammen mit dem Collector des Seminars einen Bericht zusammen, der die Beiträge der Autoren zusammenfasst und um eine Zusammenfassung ergänzt.


Download Übersichtsflyer (PDF).


Es besteht weiterhin die Möglichkeit, eine umfassende Kollektion begutachteter Arbeiten in der Reihe Dagstuhl Follow-Ups zu publizieren.

Dagstuhl's Impact

Bitte informieren Sie uns, wenn eine Veröffentlichung ausgehend von
Ihrem Seminar entsteht. Derartige Veröffentlichungen werden von uns in der Rubrik Dagstuhl's Impact separat aufgelistet  und im Erdgeschoss der Bibliothek präsentiert.