Aspect-Oriented Software Development

 Aspect-Oriented Software Development (AOSD) has recently been proposed as a new paradigm for software development, and it becomes more and more accepted in the research community. It's about developing complex software systems, which usually requires simultaneously manipulating multiple "concerns". Examples of concerns are not only the functionality of a system but also non-functional issues such as failure handling, communication, coordination strategy, memory reference locality, etc.

Object-Oriented Software Development (OOSE) technologies handle separation of concerns issues with mechanisms like delegation and inheritance. In actual programming practice, however, these techniques are inadequate to handle concerns whose behavior "crosscuts" the program structure. Instead, the programmer is required to explicitly mix commands into the primary application functionality. This produces tangled code and, as a consequence, software systems that are difficult to maintain. 

Aspect-Oriented Software Development makes use of a set of technologies that allow the separate expression of all (multiple) concerns involved in a software system, along with a set of "weaving" technologies for knitting together such separate expressions into coherent systems. This is mainly achieved by handling the tangled-code phenomenon which is a result of the above mentioned so-called tyranny of dominant decomposition.

Foci of Research

  • Aspect-Oriented Programming (AOP)
    Aspect-Oriented Modeling (AOP) focuses on new ways to modularize code of crosscutting concerns in most reusable ways.
  • Aspect-Oriented Modeling (AOM)
    Aspect-Oriented Modeling (AOM) deals with the abstraction of aspect-oriented program concepts and constructs on the modeling level. It is supposed to assist the development of aspect-oriented software by providing a graphical notation for the visualization of aspect-oriented software solutions, and thus to facilitate communication among aspect-oriented software developers and end users.
  • Application of AO to Persistent Objects resp. Aspects in OO-Databases


  • PurityA is a Smalltalk-based general-purpose aspect language.
  • Sally is a so-called general-purpose aspect language.
  • The Aspect-Oriented Design Model (AODM) is a UML-based modeling approach for AspectJ which attempts not to break the original UML semantics.
  • AspectJRB is an aspect-aware refactoring tool which is realized as Eclipse 2.0 fragment plug-in. The current version is based on AspectJ 1.0.6 and has to be used in conjunction with the AspectJ development tools 0.5.2 for Eclipse.
  • AspectJST is an extension to the AspectJ compiler to support the structural conformance in such a way that one can specify a single common supertype for different unrelated types that share common structure. This extension is applied for the AspectJ_1.1.1 compiler.
  • Join Point Designation Diagrams (or JPDDs in short) are a visual means to render join point selections (such as pointcuts, traversal strategies, match or type patterns, logic queries, applicability constraints, etc.) in AOSD.
  • AO with Path Expressions (to appear soon): Utilizing the Path Expression technique to support exposing type information that are "non-local" to the join points. This mechanism relies on the object relationships in the full object graph to match a given PathExpressionPattern against all possible paths in the graph.
  • Prolog+list Bugfix: Bugfix for a Prolog implementation for Squeak
  • FreeAnnotations for Squeak: Permits to Annotate the your Squeak-code


  • The key starting point to learn more about Aspect-Oriented Software Development and to meet other people working with or on Aspect-Orientation is
  • At, for example, you will find comprehensive link collections on both practitioners tools as well as other research projects handling Aspect-Orientation.
  • For oncoming events concerned with Aspect-Oriented Software Development (conferences, workshops, tutorials, etc.) have a look at