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

Using VCL as an Aspect-Oriented Approach to Requirements Modelling

Software systems are becoming larger and more complex. By tackling the modularisation of crosscutting concerns, aspect-orientation draws attention to modularity as a means to address the problems of scalability, complexity and evolution in software systems development. Aspect-oriented modelling (AOM) applies aspect-orientation to the construction of models. Most existing AOM approaches are designed without a formal semantics, and use multi-view partial descriptions of behaviour. This paper presents an AOM approach based on the Visual Contract Language (VCL): a visual language for abstract and precise modelling, designed with a formal semantics, and comprising a novel approach to visual behavioural modelling based on design by contract where behavioural descriptions are total. By applying VCL to a large case study of a car-crash crisis management system, the paper demonstrates how modularity of VCL's constructs, at different levels of granularity, help to tackle complexity. In particular, it shows how VCL's package construct and its associated composition mechanisms are key in supporting separation of concerns, coarse-grained problem decomposition and aspect-orientation. The case study's modelling solution has a clear and well-defined modular structure; the backbone of this structure is a collection of packages encapsulating local solutions to concerns

A graph-based aspect interference detection approach for UML-based aspect-oriented models

Aspect Oriented Modeling (AOM) techniques facilitate separate modeling of concerns and allow for a more flexible composition of these than traditional modeling technique. While this improves the understandability of each submodel, in order to reason about the behavior of the composed system and to detect conflicts among submodels, automated tool support is required. Current techniques for conflict detection among aspects generally have at least one of the following weaknesses. They require to manually model the abstract semantics for each system; or they derive the system semantics from code assuming one specific aspect-oriented language. Defining an extra semantics model for verification bears the risk of inconsistencies between the actual and the verified design; verifying only at implementation level hinders fixng errors in earlier phases. We propose a technique for fully automatic detection of conflicts between aspects at the model level; more specifically, our approach works on UML models with an extension for modeling pointcuts and advice. As back-end we use a graph-based model checker, for which we have defined an operational semantics of UML diagrams, pointcuts and advice. In order to simulate the system, we automatically derive a graph model from the diagrams. The result is another graph, which represents all possible program executions, and which can be verified against a declarative specification of invariants.\ud To demonstrate our approach, we discuss a UML-based AOM model of the "Crisis Management System" and a possible design and evolution scenario. The complexity of the system makes con°icts among composed aspects hard to detect: already in the case of two simulated aspects, the state space contains 623 di®erent states and 9 different execution paths. Nevertheless, in case the right pruning methods are used, the state-space only grows linearly with the number of aspects; therefore, the automatic analysis scales

Quality-aware model-driven service engineering

Service engineering and service-oriented architecture as an integration and platform technology is a recent approach to software systems integration. Quality aspects ranging from interoperability to maintainability to performance are of central importance for the integration of heterogeneous, distributed service-based systems. Architecture models can substantially influence quality attributes of the implemented software systems. Besides the benefits of explicit architectures on maintainability and reuse, architectural constraints such as styles, reference architectures and architectural patterns can influence observable software properties such as performance. Empirical performance evaluation is a process of measuring and evaluating the performance of implemented software. We present an approach for addressing the quality of services and service-based systems at the model-level in the context of model-driven service engineering. The focus on architecture-level models is a consequence of the black-box character of services

Pattern-based software architecture for service-oriented software systems

Service-oriented architecture is a recent conceptual framework for service-oriented software platforms. Architectures are of great importance for the evolution of software systems. We present a modelling and transformation technique for service-centric distributed software systems. Architectural configurations, expressed through hierarchical architectural patterns, form the core of a specification and transformation technique. Patterns on different levels of abstraction form transformation invariants that structure and constrain the transformation process. We explore the role that patterns can play in architecture transformations in terms of functional properties, but also non-functional quality aspects

Towards an aspect weaving BPEL engine

This position paper proposes the use of dynamic aspects and the visitor design pattern to obtain a highly configurable and extensible BPEL engine. Using these two techniques, the core of this infrastructural software can be customised to meet new requirements and add features such as debugging, execution monitoring, or changing to another Web Service selection policy. Additionally, it can easily be extended to cope with customer-specific BPEL extensions. We propose the use of dynamic aspects not only on the engine itself but also on the workflow in order to tackle the problems of Web Service hot deployment and hot fixes to long running processes. In this way, composing aWeb Service "on-the-fly" means weaving its choreography interface into the workflow

Aspect-oriented interaction in multi-organisational web-based systems

Separation of concerns has been presented as a promising tool to tackle the design of complex systems in which cross-cutting properties that do not fit into the scope of a class must be satisfied. Unfortunately, current proposals assume that objects interact by means of object-oriented method calls, which implies that they embed interactions with others into their functional code. This makes them dependent on this interaction model, and makes it difficult to reuse them in a context in which another interaction model is more suited, e.g., tuple spaces, multiparty meetings, ports, and so forth. In this paper, we show that functionality can be described separately from the interaction model used, which helps enhance reusability of functional code and coordination patterns. Our proposal is innovative in that it is the first that achieves a clear separation between functionality and interaction in an aspect-oriented manner. In order to show that it is feasible, we adapted the multiparty interaction model to the context of multiorganisational web-based systems and developed a class framework to build business objects whose performance rates comparably to handmade implementations; the development time, however, decreases significantly.Comisión Interministerial de Ciencia y Tecnología TIC2000-1106-C02-0

Early aspects: aspect-oriented requirements engineering and architecture design

This paper reports on the third Early Aspects: Aspect-Oriented Requirements Engineering and Architecture Design Workshop, which has been held in Lancaster, UK, on March 21, 2004. The workshop included a presentation session and working sessions in which the particular topics on early aspects were discussed. The primary goal of the workshop was to focus on challenges to defining methodical software development processes for aspects from early on in the software life cycle and explore the potential of proposed methods and techniques to scale up to industrial applications