program       registration       lodging       call for contributions       organization       [aosd home]

overview       technical papers       practitioner reports       workshops       tutorials       demos       exhibits      
Go back to Demonstrations Home

From Aspect-Oriented Design with Concepts to Aspect-Oriented Programming with Composition Filters

  - T
hu March 20, 16:00 - 17:30
  - Fri March 21, 09:00 - 10:30

  - Lodewijk Bergmans (University of Twente)
  - Dennis Wagelaar (Vrije Universiteit Brussel)

Composition Filters are an extension to the object-oriented model that address a number of modeling obstacles that conventional object-oriented techniques cannot address or can only solve with poorly maintainable designs. The Composition Filters approach can be classified as an aspect-oriented approach, which integrates aspects and classes, retains strong encapsulation, and supports composability. ComposeJ is a tool that takes Java classes and (separate) composition filters specifications, and transforms the Java classes so that they implement the behavior as specified in the composition filters specification.

Like OOP, the benefits of Aspect-Oriented Programming can only be exploited through appropriate design methods & tool support; CoCompose is a design tool that addresses this. The main characteristic of CoCompose is that it is visual, concern-oriented (i.e. supports the modeling of software as independent, possibly crosscutting, concerns) tool that allows for recursive definition and reuse of concerns. Concerns in the design phase may be similar to entities or classes, or to single operations, or even to complete design pattern templates. A single concern may in fact have several implementation forms; during code generation, the best possible (interoperating) combination of forms is selected. Thus, CoCompose works as a design tool that can generate the 'best' possible program from a concern-based design (if the concerns include one or more implementations).

During the demonstration, we will show how the design of a particular example problem can be approached in a concern-oriented manner and modeled with CoCompose. We will demonstrate how CoCompose can generate implementations in several programming languages (esp. Java and composition filters). One of the important points of this demonstration is to argue that, even with the ability ot generate code, the composability of the target language is important in order to retain the structure of the design, and hence the ability to revise and extend the design in an incremental manner.

In particular, we will look at generated Composition Filters code, illustrate that it is structurally close(r) to the design, and explain the basic Composition Filter mechanism. We will demonstrate our tool Compose/J that translates combined Composition Filters/Java code into pure Java code. One of the interesting features of Compose/J that we will highlight (and show) is the ability of generating optimized (i.e. inlined) code from a declarative specification.


For additional information, clarifications, questions, or special requirements, please contact the AOSD 2003 Demonstrations Chair: Mik Kersten (

 Send comments to: