ECOOP 2006 - Aspects, Dependencies, and Interactions Workshop

Aspects, Dependencies, and Interactions Workshop,

July 3

With Keynote Speech by Don Batory

This workshop is organised on behalf of and supported by the European Network of Excellence on AOSD (AOSD-Europe)

Early Development Stages

The aspectual dependencies and interactions at early stages of development often manifest as conflicts and inconsistencies between requirements or possible architectural/design choices. Up till now a number of approaches have been developed for tackling these issues, e.g., use of goal graphs for contribution analysis, stake-holder negotiation for conflict resolution, architecture evaluation methods for alternative evaluation, etc. While all this work bears a relevance to the issue of aspectual dependencies, the more holistic view of its relation to aspects is missing. It is such positioning of aspectual dependencies and interactions within the related work, as well as specific issues related to such dependencies and interactions, that we would like to investigate. Some example topics of interest are:

Identification of aspectual dependencies and interactions in various kinds of requirements documents (e.g. interview transcripts, manuals, etc.);
Techniques for dependency and interaction analysis;
Conflict resolution techniques for broadly scoped concerns (i.e., aspects) in requirements, architecture, and design;
Tool support for the above;
Etc.

Formal Methods

The ideal goal of formal analysis and verification for aspects is to prove once and for all that for every possible underlying system to which an instance of the aspect can be woven, and for every possible weaving, the aspect will always add the new properties given in its specification. Moreover, the aspect will not make any desired properties that were true for the underlying system invalid for the augmented one. There are no existing methods or tools capable of such proofs for systems of any practical size with real aspect notations. Among the correctness issues for aspects we can list:

Ways of expressing a specification of an aspect, independently of a specific weaving;
Ways to determine that the aspect itself is correct;
Ways to establish that desired new properties are added to a system by an aspect;
Ways to establish that desired properties of the underlying system are maintained in the augmented one?
Ways to establish whether aspects interfere with each other when both are applied to the same underlying system?

Language Design Issues

The design of the aspect language may take into account interactions of aspects, or feature interactions. In general-purpose aspect languages a generic mechanism may be in place to order execution of aspect code, such as the 'dominates' mechanism of AspectJ. The properties of this mechanism determines the flexibility of the aspect programmer and therefore a discussion of such mechanisms is of interest. Possible topics include mechanisms which differ significantly, or extensions of the AspectJ mechanism. Examples include, but are not limited to:

interaction detection;
ordering and nesting of aspects;
mutual exclusion;
visibility of inter-type declarations;
offering the possibility to determine the order of execution of sub-sections of different advices.

Alternatively, aspect-languages which are domain-specific may allow the use of domain information to assist in resolving interactions. Such assistance may range from providing simple predefined interaction schemes for domain-level operations to a full-blown automatic conflict resolution at the domain level. Examples of such domain-specific aspect languages, what kind of assistance and how they provide it are welcomed. Also, as we cannot ensure that all aspects will be covered by such domain- specific aspect languages, the combination of domain-specific aspect language and general-purpose aspect language in one software entity cannot be ruled out. Therefore, ways in which domain-specific languages can be made to correctly interact with aspects and features written in a general-purpose aspect language are of interest.

Interactions in Applications

Aspect interactions arise in any modern application of sufficient complexity. The breakdown, classification and evaluation of such interactions can provide valuable insight into the development and further maintenance of complex software systems. This analysis can in turn feed into the formalisation and early identification of interactions during the requirements or design phase. Some example applications for which interesting aspect interactions can arise include but are not limited to:

Middleware for pervasive and mobile systems;
Security applications;
Persistence management

Updated May, 24th, 2006