Awais Rashid

On the impact of aspectual decompositions on design stability: an empirical study

Although one of the main promises of aspect-oriented (AO) programming techniques is to promote better software changeability than objectoriented (OO) techniques, there is no empirical evidence on their efficacy to prolong design stability in realistic development scenarios. For instance, no investigation has been performed on the effectiveness of AO decompositions to sustain overall system modularity and minimize manifestation of ripple-effects in the presence of heterogeneous changes. This paper reports a quantitative case study that evolves a real-life application to assess various facets of design stability of OO and AO implementations. Our evaluation focused upon a number of system changes that are typically performed during software maintenance tasks. They ranged from successive re-factorings to more broadly-scoped software increments relative to both crosscutting and non-crosscutting concerns. The study included an analysis of the application in terms of modularity, change propagation, concern interaction, identification of ripple-effects and adherence to well-known design principles.

Multi-dimensional separation of concerns in requirements engineering

Existing requirements engineering approaches manage broadly scoped requirements and constraints in a fashion that is largely two-dimensional, where functional requirements serve as the base decomposition with non-functional requirements cutting across them. Therefore, crosscutting functional requirements are not effectively handled. This in turn leads to architecture trade-offs being mainly guided by the non-functional requirements, so that the system quality attributes can be satisfied. In this paper, we propose a uniform treatment of concerns at the requirements engineering level, regardless of their functional, non-functional or crosscutting nature. Our approach is based on the observation that concerns in a system are, in fact, a subset, and concrete realisations, of abstract concerns in a meta concern space. One can delineate requirements according to these abstract concerns to derive more system-specific, concrete concerns. We introduce the notion of a compositional intersection, which allows us to choose appropriate sets of concerns in our multi-dimensional separation as a basis to observe trade-offs among other concerns. This provides a rigorous analysis of requirements-level trade-offs as well as important insights into various architectural choices available to satisfy a particular functional or non-functional concern.

Persistence as an aspect

Persistence - the storage and retrieval of application data from secondary storage media - is often used as a classical example of a crosscutting concern. It is widely assumed that an application can be developed without taking persistence requirements into consideration and a persistence aspect plugged in at a later stage. However, there are no real world examples showing whether persistence can in fact be aspectised and, if so, can this be done in a manner that promotes reuse and is oblivious to the application. In this paper, we provide an insight into these issues drawing upon our experience with a classical database application: a bibliography system. We argue that it is possible to aspectise persistence in a highly reusable fashion, which can be developed into a general aspect-based persistence framework. Nevertheless, application developers can only be partially oblivious to the persistent nature of the data. This is because persistence has to be accounted for as an architectural decision during the design of data-consumer components. Furthermore, designers of such components also need to consider the declarative nature of retrieval mechanisms supported by most database systems. Similarly, deletion requires explicit attention during application design as mostly applications trigger such an operation.

Transactions on Aspect-Oriented Software Development II

Submission information at the series homepage and springer.com/authors Order online at springer.com ▶ or for the Americas call (toll free) 1-800-SPRINGER ▶ or email us at: customerservice@springer.com. ▶ For outside the Americas call +49 (0) 6221-345-4301 ▶ or email us at: customerservice@springer.com. Transactions on Aspect-Oriented Software Development Subseries of Lecture Notes in Computer Science Editor-in-chief: M. Südholt Series Editors: D. Hutchison (et al.)

Semantics-based composition for aspect-oriented requirements engineering

In this paper, we discuss the limitations of the current syntactic composition mechanisms in aspect-oriented requirements engineering (AORE). We highlight that such composition mechanisms not only increase coupling between aspects and base concerns but are also insufficient to capture the intentionality of the aspect composition. Furthermore, they force the requirements engineer to reason about semantic influences and trade-offs among aspects from a syntactic perspective. We present a requirements description language (RDL) that enriches the existing natural language requirements specification with semantic information derived from the semantics of the natural language itself. Composition specifications are written based on these semantics rather than requirements syntax hence providing improved means for expressing the intentionality of the composition, in turn facilitating semantics-based reasoning about aspect influences and trade-offs. We also discuss the practicality of the use of this RDL by outlining the automation support for requirements annotation (realized as an extension of the Wmatrix natural language processing tool suite) to expose the semantics which are in turn utilized to facilitate composition and analysis (supported by the MRAT tool).

EA-Miner: a tool for automating aspect-oriented requirements identification

Aspect-Oriented requirements engineering helps to achieve early separation of concerns by supporting systematic analysis of broadly-scoped properties such as security, real-time constraints, etc. The early identification and separation of aspects and base abstractions crosscut by them helps to avoid costly refactorings at later stages such as design and code. However, if not handled effectively, the aspect identification task can become a bottleneck requiring a significant effort due to the large amount of, often poorly structured or imprecise, information available to a requirements engineer. In this paper, we describe a tool, EA-Miner, that provides effective automated support for identifying and separating aspectual and non-aspectual concerns as well as their crosscutting relationships at the requirements level. The tool utilises natural language processing techniques to reason about the properties of the concerns and model their structure and relationships.

Mutation Testing for Aspect-Oriented Programs

Mutation testing has been shown to be one of the strongest testing criteria for the evaluation of both programs and test suites. Comprehensive sets of mutants require strong test sets to achieve acceptable testing coverage. Moreover, mutation operators are valuable for the evaluation of other testing approaches. Although its importance has been highlighted for aspect-oriented (AO) programs, there is still a need for a suitable set of mutation operators for AO languages. The quality of the mutation testing itself relies on the quality of such operators. This paper presents the design of a set of mutation operators for AspectJ-based programs. These operators model instances of fault types identified in an extensive survey. The fault types and respective operators are grouped according to the related language features. We also discuss the generalisation of the fault types to AO approaches other than AspectJ and the coverage that may be achieved with the application of the proposed operators. In addition, a cost analysis based on two case studies involving real-world applications has provided us feedback on the most expensive operators, which will support the definition of further testing strategies.

On the modular representation of architectural aspects

An architectural aspect is a concern that cuts across architecture modularity units and cannot be effectively modularized using the given abstractions of conventional Architecture Description Languages (ADLs). Dealing with crosscutting concerns is not a trivial task since they affect each other and the base architectural decomposition in multiple heterogeneous ways. The lack of ADL support for modularly representing such aspectual heterogeneous influences leads to a number of architectural breakdowns, such as increased maintenance overhead, reduced reuse capability, and architectural erosion over the lifetime of a system. On the other hand, software architects should not be burdened with a plethora of new ADL abstractions directly derived from aspect-oriented implementation techniques. However, most aspect-oriented ADLs rely on a heavyweight approach that mirrors programming languages concepts at the architectural level. In addition, they do not naturally support heterogeneous architectural aspects and proper resolution of aspect interactions. This paper presents AspectualACME, a simple and seamless extension of the ACME ADL to support the modular representation of architectural aspects and their multiple composition forms. AspectualACME promotes a natural blending of aspects and architectural abstractions by employing a special kind of architectural connector, called Aspectual Connector, to encapsulate aspect-component connection details. We have evaluated the applicability and scalability of the AspectualACME features in the context of three case studies from different application domains.

Framed Aspects: Supporting Variability and Configurability for AOP

Aspect oriented programming (AOP) seeks to decompose concerns which crosscut system structure into more manageable modules. However, current AOP techniques alone lack the configuration mechanisms and generalisation capabilities that are required to realise variability (through clear reuse specifications). Conversely, frame technology provides extensive mechanisms for providing reuse and configuration yet cannot effectively modularise crosscutting concerns. This paper proposes ’framed aspects’ a technique and methodology which combines the respective strengths of AOP, frame technology and Feature-Oriented Domain Analysis (FODA). We argue that framed aspects can alleviate many of the problems the technologies have when used in isolation and also provide a framework for implementing fine-grained variability. The approach is demonstrated with the design and implementation of a generic caching component.

A concern-oriented requirements engineering model

Traditional requirements engineering approaches suffer from the tyranny of the dominant decomposition, with functional requirements serving as the base decomposition and non-functional requirements cutting across them. In this paper, we propose a model that decomposes requirements in a uniform fashion regardless of their functional or non-functional nature. This makes it possible to project any particular set of requirements on a range of other requirements, hence supporting a multi-dimensional separation. The projections are achieved through composition rules employing informal, often concern-specific, actions and operators. The approach supports establishment of early trade-offs among crosscutting and overlapping requirements. This, in turn, facilitates negotiation and decision-making among stakeholders.