Results and Summary from the FOAL workshop at AOSD (types and AOP)

Readers of the types mailing list may be interested in thinking about
semantics and type systems for aspect-oriented languages.
Aspect-oriented programming (AOP) is a potential successor to OO
programming that builds on the strengths of OO, but tries to make it
possible to better separate concerns.  This area is potentially
interesting because it involves language extensions, and because there
is considerable (early) industrial interest.  The most prominent of
the AOP languages are AspectJ and Hyper/J, which are both based on
Java, but there are many other languages being floated in academic and
industrial circles.  AspectJ can be seen as a way to transform an
existing program, something like a way to record edits to a base
program in code, some of the edits happening dynamically.  If you have
seen the CLOS system from Common Lisp and things like it's "around",
"before", and "after" wrappers, that will give you some idea of the kind
of thing AspectJ can do.  Aspects also may remind you a bit of

You can learn more about AOP from http://aosd.net or
http://aspectj.org/.  AOP is also discussed in a recent special issue of
CACM and there is a paper on AspectJ in the last ECOOP.  There were a
few papers presented at the main AOSD conference that will be of
interest for the semantics of AOP, and the proceedings are available
from ACM press.

In the rest of this note, I'd like to summarize the results and future
work of the first "Foundations of Aspect-Oriented Languages" (FOAL)
workshop (see http://www.cs.wustl.edu/~cytron/FOAL/) held at the 1st
International Conference on Aspect-Oriented Software Development.  The
workshop was held on Monday (April 22, 2002).  25 people attended the

The main result of the FOAL workshop is that the field of semantics, types
and formal methods for AOP is wide open.  Only a few studies, such as
the Aspect SandBox work presented at the FOAL (and FOOL) workshops and
Ralf Lammel's paper at the AOSD conference have studied the semantics
of AOP so far.  There has been little or no work on type systems.
There are many different languages and different kinds of aspects to
sort out, and semantics might be very helpful in helping the community
understand what is going on in these languages.

In terms of future work, the most prominent things the FOAL workshop
participants identified were the following:

 - Type systems for aspect-oriented languages (soundness, detection
   of ambiguity of advice, problems with invariance of "around"
 - Static analysis for AOP
 - What kinds of join points, point cuts, etc. should be in an AOP
   language?  (A language design issue.)
 - What kinds of encapsulation constructs should be in such languages?
   (But note that AspectJ at least has many encapsulation constructs).
 - Composition strategies.  Composing aspects seems to have some of
   the same problems as composing monads, and perhaps there may be
   similar technical ideas.
 - Incremental compilation, separate compilation and analysis.
   (Many current AOP approaches are whole-program based).
 - Behavioral specification and reasoning.  Not much has happened here
   yet, but there were some papers at FOAL and the AOSD conference on
   this.  There may be some analogy to "superposition" from
   concurrency theory.  Here there are subtopics such as model
   checking and trying to prevent interference between aspects.

I encourage those of you who have been working in OO semantics and
typing, or formal methods, and those just starting out in research in
semantics especially, to look into whatever strikes your interest
here.  I'd be happy to answer questions to the best of my ability
about such research directions.

        Gary T. Leavens
        Department of Computer Science, Iowa State University
        229 Atanasoff Hall, Ames, Iowa 50011-1040 USA
        http://www.cs.iastate.edu/~leavens  phone: +1-515-294-1580