Pure Aspects
Author: Elcin Recebli (Oxford University)
Date: September 2005
MSc dissertation, September 2005
Abstract
In this dissertation the notion of aspect purity is proposed.
Informally, a pure aspect is one that promises not to alter the behaviour of
a specified set of classes, only possibly adding something new. For example,
a graphical viewer aspect is a good candidate to be pure: it merely observes
the model class.
Our design provides a seamless extension to the most popular
aspect-oriented programming language --- AspectJ. Our
implementation makes essential use of the Soot program
analysis framework.
(PDF)
An Implementation of Open Modules in AspectJ
Author: Neil Ongkingco (Oxford University)
Date: September 2005
MSc dissertation, September 2005
Abstract
Aspect-oriented programming languages provide advice to modify
the behavior of programs. Some current languages, notably AspectJ, provide
few limitations on advice, so new advice can change the behavior of existing
programs without restrictions. Changes to the base code can also affect the
behavior of existing advice in an unexpected manner. Open Modules is one
proposal to solve the problems above. It is defined for a small functional
aspect-oriented language, and has the benefit of a formal definition of
its behavior. There is, however, no implementation for Open Modules in
an existing aspect-oriented programming language.
AspectJ is an aspect-oriented programming language based on java. This dissertation presents an implementation of Open Modules in AspectJ, using the AspectBench compiler. The implementation also allows a module to be included in another module, and defines the effect of the inclusion of the properties of the modules.
(PDF)
Efficient Implementation of Around-Advice for the AspectBench Compiler
Author: Sascha Kuzins (Oxford University)
Date: September 2004
MSc dissertation, September 2004
Abstract
In Aspect Oriented Programming, aspects observe a base program and
execute extra code - the advice - when certain patterns of events occur.
Advice
can be executed before, after of instead of the original event.
Around-advice
executes instead of the original code of the base program, but is allowed to
explicitly invoke the original code.
The most popular implementation language for aspects is AspectJ, an
extension of Java.
This dissertation presents an efficient and complete code generation
strategy for around advice as part of the AspectBench Compiler abc. Mea-
surements are presented which show that the strategy can yield perfomance
gains of 200% or more when compared to the official AspectJ compiler ajc.
(PDF)