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