On the design of aspect-oriented composition models for software evolution

Aspect-oriented programming is an emerging approach in software development,\ud which provides new possibilities for separation of concerns. Aspectoriented\ud languages offer abstractions for the implementation of concerns\ud whose modularization cannot be achieved by using traditional programming\ud languages. Such concerns are generally termed as crosscutting concerns. It is\ud generally agreed that separating the right concerns from each other enhances\ud software quality factors such as reusability and adaptability. The separated\ud concerns in software must be composed together so that software behaves\ud according to its requirements in a coherent way. We refer to language mechanisms\ud that separate and compose concerns as 'composition mechanisms'. This\ud thesis evaluates the software composition mechanisms of current aspectoriented\ud languages from the perspective of software quality factors such as\ud evolvability, comprehensibility, predictability and adaptability. Based on this\ud study, the thesis proposes novel extensions to current aspect-oriented\ud languages so that programs written in these languages exhibit better quality.\ud A considerable number of aspect-oriented languages has been introduced for\ud modularizing crosscutting concerns. Naturally, these languages share a number\ud of common concepts and have distinctive features as well. For this reason, we\ud propose a reference model that aims to capture the common and distinctive\ud concepts of aspect-oriented languages. This reference model provides a basis\ud to understand the important characteristics of the state-of-the-art AOP\ud languages and helps us to compare the AOP languages with each other.\ud Furthermore, it exposes the issues that have to be considered when a new\ud aspect-oriented language needs to be developed.\ud In this thesis, we analyse the four main aspect-oriented concepts of the reference\ud model, namely join point, pointcut, advice and aspect, and identify problems\ud related to their use in various AOP languages. Based on this analysis, we\ud propose extensions of the existing concepts and/or design new ones to address\ud the identified problems.\ud In current aspect-oriented languages, pointcuts select join points of a program\ud based on lexical information such as explicit names of program elements.\ud However, this reduces the adaptability of software, since it involves too much\ud information that is hard-coded, and often implementation-specific. We claim\ud that this problem can be reduced by referring to program elements through their\ud semantic properties. A semantic property describes for example the behavior\ud of a program element or its intended meaning. We formulate requirements for\ud the proper application of semantic properties in aspect-oriented programming.\ud We discuss how to use semantic properties for the superimposition of aspects,\ud and how to apply superimposition to bind semantic properties to program\ud elements. To achieve this, we propose language constructs that support semantic\ud composition: the ability to compose aspects with the elements of the base\ud program that satisfy certain semantic properties.\ud The current advice-pointcut binding constructs of AOP languages maintain\ud explicit dependencies to advices and aspects. This results in weaving specifications\ud that are less evolvable and need more maintenance during the development\ud of a system. We show that this issue can be addressed by providing associative\ud access to advices and aspects instead of using explicit dependencies in\ud the weaving specification. To this aim, we propose to use a designating (query)\ud language in advice-pointcut bindings that allows for referring aspect/advices\ud through their (syntactic and semantic) properties. We also present how semantic\ud properties can be applied to provide reusable (adaptable) aspect abstractions.\ud Aspect-oriented languages provide means to superimpose aspectual behavior –\ud in terms of advices - on a given set of join points. It is possible that not just a\ud single, but several advices need to execute at the same join point. Such "shared"\ud join points may give rise to issues such as determining the exact execution\ud order and the other possible dependencies among the aspects. We present a\ud detailed analysis of the problem, and identify a set of requirements upon mechanisms\ud for composing aspects at shared join points. To address the identified\ud issues, we propose a general and declarative model for defining constraints\ud upon the possible compositions of aspects at a shared join point. By using an\ud extended notion of join points, we show how concrete aspect-oriented\ud programming languages can adopt the proposed model.\ud The thesis also presents how the proposed extensions and new constructs are\ud adopted by the aspect-oriented language Compose*. To evaluate the proposed\ud constructs, we provide qualitative analyses with respect to various software\ud engineering properties, such as evolvability, modularity, predictability and\ud adaptability