Section 17.6. ASPECT INTERACTION

17.6. ASPECT INTERACTION

An important area that has not yet been widely targeted by the research community is the (formal) analysis of undesirable interactions between aspects, sometimes referred to as aspect interference. Aspects are, by definition, intended to cut across program code and can be seen as being orthogonal to the underlying base code. However, the aspects themselves need not be orthogonal to one another, and this leads to the potential for aspect interactions (interference), where aspects may cooperate or interact with each other or the base program in unexpected ways.

This problem is not unique to aspect-oriented programming and is well-understood within the domain of telecommunication systems (see [15] and the series of Feature Interaction Workshops [16, 31]). Borrowing the definition of feature interactions from [52], we can say that an aspect interaction occurs if the behavior of one aspect is affected by the behavior of another aspect.

Given the inevitability of aspect interactions, three angles can be considered with respect to providing a solution: avoidance, detection, and resolution, all of which are currently under-researched areas.

One means to address the first of these, avoidance, is the application of the "design by contract" principle, as proposed by Klaeren and colleagues in [53]. This work addresses the issue of whether a particular composition of aspects is valid by using assertions, thus avoiding faulty aspect configurations.

Regarding the second and third categories, interaction detection and resolution, the most significant work has been undertaken in [28], which describes an automatic conflict analysis tool, detecting interactions between aspects. This is based on definitions of two aspect independence properties, where sufficient (but not necessary) conditions are defined to ensure independence. The resolution of detected interactions is achieved manually by using a dedicated composition language that contains linguistic support for conflict resolution.

Work is also underway at Lancaster investigating the detection of aspect interactions by utilizing program slicing techniques [10]. A further intended outcome of this work is identifying a categorization of types of aspect interactions, such as along the lines of those identified for feature interactions in [38]. Also related is work on the resolution of feature interactions, where "feature resolution modules" are implemented as aspects [63].

Issues associated with aspect interactions are also discussed briefly in [27], where a logic meta-programming approach can be used to describe either domain-independent combination rules (based on prioritization) or more specialized domain-specific rules.

The immaturity of this area of work makes it difficult, at this stage, to draw guidelines for the software developer. However, the core observation from this section and from the limited work that has been carried out is the very real problem posed by aspect interactions. While the introduction of aspects helps in the structuring and maintainability of software systems, it does bring with it another challenge, that of dealing with aspects that interact in unexpected ways. As has been stated before, this is not a new problem, having been widely studied within the telecommunications industry. It is also an area about which the AO software developer should be aware. In summary, it is clear that the issue of aspect interaction is an important consideration within the development of aspect-oriented systems; yet, to date, this is an area that is under-researched in the AOSD community.