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. In particular, we will look at generated Composition Filters code, illustrate that it is structurally close 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.