 |
| Go back to
Demonstrations Home |
|
From
Aspect-Oriented Design with Concepts to Aspect-Oriented
Programming with Composition
Filters |
Dates:
- Thu March 20, 16:00 -
17:30
- Fri March 21, 09:00 -
10:30
Presenters:
- 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.
|
|
Contact |
| For additional information,
clarifications, questions, or special requirements, please
contact the AOSD 2003 Demonstrations Chair: Mik Kersten (demos@aosd.net). |
| |
|
