AORTA (Aspect-Oriented Run-Time Architecture)

This page is maintained by Michael Haupt.

Overview

AORTA: an overview of the purpose of AORTA
Downloads related to AORTA
People involved in AORTA development
Publications related to AORTA
References to related work in the field of run-time AOP

AORTA
[Top] [AORTA] [Downloads] [People] [Publications] [References]

Motivation

Imagine you are a programmer and work with an object-oriented language that incorporates all the bells and whistles that make up the power of object orientation: polymorphism, late binding and so forth. Moreover, imagine...

...you had to run your source code through a preprocessor that weaves in behaviour necessary for late binding to work...
...you had to recompile your whole project whenever you had added a single class...

Doesn't that sound awkward?

The point here is: aspect orientation does not get the same support as object orientation, although it should - a growing number of systems aims at allowing for dynamic weaving, and features like aspectual polymorphism that can be found in Caesar yearn for run-time support. However, AOP today means, in spite of the dynamic join point model that most AOP languages and tools claim to support, using preprocessors or load-time instrumentation and, in almost any case, resigning from true dynamics. In a nutshell, a dynamic join point model is implemented through static means. A clear contradictoin.

We believe that the cause for this must be sought in the lack of existing support for AOP in run-time environments. Existing run-time environments very well support object orientation in that they offer, for example, virtual method tables for late binding, but they do not offer capabilities for dynamic aspect weaving.

Project Goals and Subprojects

The central thesis of the AORTA project is as follows:

To gain efficient and flexible implementations of dynamic join points, support for them needs to be integrated with the respective run-time environments.

The AORTA project aims at providing a general architecture for aspect-aware execution environments.

To the end of providing such support, the AORTA project has a branch that aims at implementing virtual machines with tightly integrated mechanisms for (dynamic) aspects. Another branch cares for measuring the performance of aspect-oriented software in general. In the course of working in those two branches, the following subprojects have been established:

Run-Time Environments
- Axon is a JVM plugin for dynamic aspects based on the JVM debugger infrastructure.
- RuByCom is another JVM extension for dynamic aspects, but it is based on the HotSwap technology.
- Steamloom is the first JVM ever to natively support dynamic aspects. It also is the main outcome of the AORTA project.
Performance
- Micro-measurements for dynamic aspect-oriented systems form a basis for providing a widely applicable suite of benchmarks for dynamic AOP implementations.
- Profiling support for dynamic aspect-oriented systems is intended to provide a further means to reason about performance details in such systems.

Downloads
[Top] [AORTA] [Downloads] [People] [Publications] [References]

Steamloom 0.5 is released! It can be downloaded from the Steamloom page.

People
[Top] [AORTA] [Downloads] [People] [Publications] [References]

Swen Aussmann
Swen has implemented the Axon VM plugin that enables run-time aspect weaving for the HotSpot JVM. This work is part of his diploma thesis.
[Axon home page]

Christoph Bockisch
As part of his diploma thesis, Christoph has implemented the first version of theSteamloom VM, an extension to IBM's Jikes Research Virtual Machine. Steamloom allows for run-time weaving and avoids the need for modifying code.
[Christoph Bockisch's home page] [Email]

Jens Danker
Jens has implemented RuByCoM, an approach to dynamic AOP using the HotSwap run-time evolution capabilities of the Sun HotSpot Virtual Machine (since JDK 1.4.0).
[RuByCoM home page]

Tom Dinkelaker
In his student research project, Tom has extended the Steamloom VM with the BAT framework for easy bytecode modification. In his diploma thesis, he is currently improving Steamloom's dynamic weaving capabilities and implementing advanced dynamic AOP concepts.
[BAT home page]

Marc Eckart
In his student research project, Marc has designed WeaveL, an XML based language for aspect weaving, and implemented a parser for it.

Dirk Fellenstein
Dirk's diploma thesis is about extending the Jikes RVM with profiling support targeting advanced profiling analysis tools like *J.
[Profiling home page]

Michael Haupt (Project Supervisor)
The AORTA project is part of Michael Haupt's doctoral research concerning AOP-enabling run-time environments.
[Michael Haupt's home page] [Email]

Michael Krebs
As part of his diploma thesis, Michael is extending Steamloom's API to add support for multiple kinds of join points. His work also encompasses the integration of BAT's powerful pointcut framework.
[BAT home page]

Publications
[Top] [AORTA] [Downloads] [People] [Publications] [References]

Foundations

[2002] Mira Mezini and Klaus Ostermann
Integrating Independent Components with On-Demand Remodularisation
Proceedings of the 17th ACM Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOSPLA), Seattle, Washington, USA, November 4-8, 2002, Sigplan Notices, 37 (11), pp. 52 - 67
[oopsla02.pdf] [BibTeX]

[2002] Michael Haupt, Mira Mezini, Marianno Cilia and Alejandro Buchmann
Towards Event-Based Aspect-Oriented Runtime Environments
Technical Report TUD-ST-2002-01
[TR-TUD-ST-2002-01.pdf] [BibTeX]

[2003] Mariano Cilia, Michael Haupt, Mira Mezini and Alejandro Buchmann
The Convergence of AOP and Active Databases: Towards Reactive Middleware
in Proceedings of 2nd International Conference on Generative Programming and Component Engineering (GPCE), LNCS 2830, pp. 169-188
[gpce03.pdf] [BibTeX]

[2003] Michael Haupt, Christoph Bockisch, Mira Mezini and Klaus Ostermann
Towards Aspect-Aware Execution Models
Technical Report TUD-ST-2003-01
[ObjectModel-TR.pdf] [BibTeX]

Approaches

[2003] Michael Haupt, Christoph Bockisch, Mira Mezini and Klaus Ostermann
Towards Aspect-Aware Execution Models
Technical Report TUD-ST-2003-01
[ObjectModel-TR.pdf] [BibTeX]

[2004] Christoph Bockisch, Michael Haupt, Mira Mezini and Klaus Ostermann
Virtual Machine Support for Dynamic Join Points
in Proceedings of International Conference on Aspect-Oriented Software Development (AOSD'04)
[Steamloom.pdf] [BibTeX]

Performance

[2004] Michael Haupt and Mira Mezini
Micro-Measurements for Dynamic Aspect-Oriented Systems
Proc. of Net.ObjectDays 2004 (NODe), LNCS 3263
[NODe-2004.pdf] [BibTeX]

References
[Top] [AORTA] [Downloads] [People] [Publications] [References]

These are references to other projects dealing with run-time AOP. If you know any more, please tell us.

AspectWerkz is a powerful dynamic AOP implementation based on load-time weaving through the standard JVM's HotSwap API.
[AspectWerkz home page]

DAOP (Dynamic Aspect-Oriented Platform) is a distributed platform where aspects and components are composed at run-time using a middleware layer. It comes from the University of Málaga, Spain.
[DAOP home page]

EAOP (Event-Based Aspect-Oriented Programming) is being developed at Ecole des Mines de Nantes, France. The notion of event-based AOP was first introduced by this group.
[EAOP home page]

JAC is, like many other dynamic AOP systems, based on load-time weaving. It aims at providing a middleware platform for Java objects through aspects.
[JAC home page]

The JBoss AOP project is a subproject of the JBoss J2EE container. Based on load-time weaving, it is used to implement JBoss' interceptor infrastructure.
[JBoss AOP home page]

.NET-based AOP is being developed at Potsdam University.
[projects home page]

PROSE and MIDAS: PROSE is a dynamic weaving tool, MIDAS is an architecture for spontaneously reconfiguring applications. Both projects are developed at ETH Zürich, Switzerland.
PROSE, like Axon, utilised the JVM debugger for event generation in its first implementation. Axon was developed independently.
[PROSE home page]

The following references are pointers to tools and systems that are used in the development of the various parts of AORTA.

IBM's Jikes Research Virtual Machine (RVM) is the VM upon which Steamloom is built. It is a JVM that is entirely implemented in Java itself. The openness of its design allows for easily applying modifications.
[Jikes RVM home page]

The JavaGrande Benchmark Framework framework provides a good basis for developing benchmark applications of three kinds: micro-measurements, standard algorithms, and complex applications. We use the framework to implement our dynamic AOP benchmarks.
[JavaGrande home page]

*J is an advanced profiling analysis tool from the Sable Group at McGill University. We use it to better reason about performance details of dynamic aspect-oriented software.
[*J home page]