Designating join points in Compose * - a predicate - based superimposition selector language for

Aspect Oriented Programming is an increasingly popular approach used to increase the modu-larity of applications. The Compose* project implements an aspect oriented programming language based on the .NET platform. By using the Common Language Infrastructure defined by .NET it is independent of a particular implementation language. Using Compose*, it is possible to define concerns that superimpose filtermodules on existing base classes. Filtermodules can intercept and modify message calls, thus enabling concerns to change the existing behaviour of an application. To define where filtermodules should be superimposed, Compose* uses a superimposition selector language. Problems with the current selector language are its limited expressiveness and the tight coupling between selector expressions and base classes, thus impeding the maintainability and evolvability of applications. This thesis describes a new superimposition selector language based on predicate logic. Selectors written in this language specify where filtermodules have to be superimposed based on the static structure of an application. The selector language is independent of any implementation language because it uses an abstract language model to represent the language model used in Compose*. Additionally, the selector language implements support for metadata annotations, a feature found in recent programming languages such as Java and C#. Annotations can be attached in the source of base classes and used as a selection criterion in selector expressions, allowing for selection based on design information rather than application structure or syntax. This also removes the tight coupling between selector expressions and base classes and addresses the scattering of annotations over reusable base classes. The combination of selection based on annotations and the superimposition of annotations allows for the derivation of annotations, a mechanism that removes the need to manually enumerate where annotations should be superimposed. However, it also introduces the possibility of dependencies between selectors. This can lead to conflicts, as different orders of evaluating the selectors and superimposing annotations can lead to different results. In addition, circular dependencies could potentially lead to non-termination of the selector evaluation mechanism. An algorithm is presented to handle the superimposition of annotations and evaluation of selectors in a correct order. The algorithm also detects dependency conflicts.