Modular Aspect-oriented Programming

Overview

The goal of aspect-oriented programming is to provide a cleaner separation of concerns, enabling programmers to reason about and evolve programs more effectively. Many language constructs have been proposed to enable better separation of concerns, and a number seem to be promising ways to improve the way software development is done. However, a number of open problems remain, including understanding the formal foundations of aspects, supporting aspect encapsulation, automated and human reasoning about aspect-oriented programs, and studying the practical consequences of the technology.

The goal of the modular aspect-oriented programming project is to move aspect-oriented programming towards the mainstream of both language design and engineering practice. Our work focuses on a number of research questions:

How can we formally model aspect-oriented programming constructs, so that we can guarantee properties like type safety and reason about aspect-oriented programs?
How can we design a module system (possibly involving tool support) so that engineers can reason about and evolve different parts of an aspect-oriented program separately?
Can we design new language features that provide a better separation of concerns for programming issues like object initialization or error handling?
What are the practical benefits and drawbacks of proposed aspect-oriented language features? How do different language designs compare when applied to similar problems?
How can we effectively analyze aspect-oriented programs?

So far, we have built TinyAspect, a formal model of aspect-oriented programming. We have used this model to study Open Modules, a new module system that preserves the extensibility of aspects along with a strong encapsulation property, and can be used to benefit the reasoning benefits of aspect-oriented programming tools. Finally we have studied aspect-oriented error-handling techniques.
In the future, we hope to build on this work, further investigating modularity but also exploring the other questions described above. Eventually, we hope to design and implement a concrete aspect-oriented programming language based on insights from current research in AOSD.

Papers

Jonathan Aldrich. Open Modules: Modular Reasoning about Advice. Submitted for publication. An earlier version appeared in Foundations of Aspect Languages, March 2004. The full proofs for the theorems in the paper are published as Carnegie Mellon Technical Report CMU-ISRI-04-141, December 2004 (which supercedes an earlier technical report, CMU-ISRI-04-108).
Jonathan Aldrich. Open Modules: Reconciling Extensibility and Information Hiding. Proc. AOSD 2004 Workshop on Software Engineering Properties of Languages for Aspect Technologies, March 2004. A file describing the raw, detailed results of our micro-experiment with the SpaceWar program is available.
Neel Krishnaswami and Jonathan Aldrich. Statically-Scoped Exceptions: a Typed Foundation for Aspect-Oriented Error Handling. Carnegie Mellon Technical Report CMU-ISRI-05-102. Published on the web J anuary 2004, as a tech report January 2005.

People

Jonathan Aldrich
Neel Krisnaswami

Contact Jonathan Aldrich (jonathan.aldrich@cs.cmu.edu)