Transactions on Aspect-Oriented Software Development V

Achieving sufficient execution performance is a challenging goal of software development. Unfortunately, violating performance requirements is often revealed at a late stage of the development. Fixing a performance problem at such a late stage is difficult in terms of cost and time. To solve this problem, this paper presents QoSWeaver, which is a tool suite for developing application-level scheduling using aspects. QoSWeaver weaves scheduling code written in an aspect into web application code. The scheduling code gets an application thread to voluntarily yield its execution to implement a custom scheduling policy. The idea of scheduling at the application level is not new, but aspect-oriented programming (AOP) makes it more realistic by separation of scheduling code. For fine-grained scheduling, QoSWeaver provides a profile-based pointcut generator, which automatically generates appropriate pointcuts. To investigate the ability of QoSWeaver for implementing practical scheduling policies, we used QoSWeaver for tuning the performance of a river monitoring system named Kasendas, which is a web application system. For reliable examination, Kasendas was originally developed by an outside corporation and then it was tuned by the authors with QoSWeaver. The authors could successfully improve the performance of Kasendas under heavy workload. The cost of the performance tuning was reasonably small. Furthermore, our approach achieved better performance than other techniques such as admission control and priority scheduling provided by the JVM or Linux. We could implement various policies such as deadlock-aware or adaptive scheduling.

In this paper, we analyze the suitability of refactoring the integer programming algorithms Branch and Bound and Branch and Cut with aspects implemented in Computational Infrastructure for Operations Research (COIN-OR), an open source library for Operations Research. For identifying the concerns in the code, we propose a classification of concerns in terms of requirements. We transformed the rules of an existing Aspect-Oriented Programming (AOP) refactoring catalog for Java to a corresponding catalog for AspectC++ and developed a refactored version of the implemented algorithms using our transformed rules. The execution time of Branch and Bound and Branch and Cut was measured and the impact of using AOP was analyzed. The results are very encouraging and we assess that besides a customizable code, the execution time did not degrade with AOP.

We define bisimilarity for an aspect extension of the untyped lambda calculus and prove that it is sound and complete for contextual reasoning about programs. The language we study is very small, yet powerful enough to encode mutable references and a range of temporal pointcuts. We extend formal studies of Open Modules to this more general setting. Examples suggest that aspects are amenable to techniques developed for stateful higher-order programs. To our knowledge, this is the first study of coinductive reasoning principles for aspect programs.

As the use of aspects spreads, it is becoming common to weave multiple aspects into a system, treating different concerns. In this special section, we present three papers that deal with the issue of how aspects may interact, and in particular how they may interfere with each other. Aspect interactions can arise at all stages of software development, including requirements, design, and implementation. The issues somewhat differ at each stage, and in fact for interference itself several definitions are in use.

Jointly deployed aspects may interact with each other. While some interactions might be intended, unintended interactions (interferences) can break a program. Detecting and resolving interferences is particularly hard if aspects are developed independently, without knowledge of each other.

For certain types of interactions automatic resolution is possible. In this case, our algorithm computes a “weaving schedule” that ensures correctness and completeness of the weaving process. This is possible without special purpose program annotations or formal specifications of aspect semantics. Our technique can check weaving interferences independently of any base program and is applicable to aspects that contain implicit mutual dependencies in their implementation.

This paper presents AspectOptima, a language independent, aspect-oriented framework consisting of a set of ten base aspects—each one providing a well-defined reusable functionality—that can be configured to ensure the ACID properties (Atomicity, Consistency, Isolation, and Durability) for transactional objects. The overall goal of AspectOptima is to serve as a case study for aspect-oriented software development, particularly for evaluating the expressivity of AOP languages and how they address complex aspect interactions and dependencies. The ten base aspects of AspectOptima are simple, yet have complex dependencies and interactions among each other. To implement different concurrency control and recovery strategies, these aspects can be composed and assembled into different configurations; some aspects conflict with each other, others have to adapt their run time behavior according to the presence or absence of other aspects. The design of AspectOptima highlights the need for a set of key language features required for implementing reusable aspect-oriented frameworks. To illustrate the usefulness of AspectOptima as a means for evaluating programming language features, an implementation of AspectOptima in AspectJ is presented. The experiment reveals that AspectJ’s language features do not directly support implementation of reusable aspect-oriented frameworks with complex dependencies and interactions. The encountered AspectJ language limitations are discussed, workaround solutions are shown, potential language improvements are proposed where appropriate, and some preliminary measurements are presented that highlight the performance impact of certain language features.

Aspect-oriented concepts are currently exploited to model systems from the beginning of their development. Aspects capture potentially crosscutting concerns and make it easier to formulate desirable properties and to understand analysis results than in a tangled system. However, the complexity of interactions among different aspectualized entities may reduce the benefit of aspect-oriented separation of crosscutting concerns. Some interactions may be intended or may be emerging behavior, while others are the source of unexpected inconsistencies. It is therefore desirable to detect inconsistencies as early as possible, preferably at the modeling level.

We propose an approach for analyzing interactions and potential inconsistencies at the level of requirements modeling. We use a variant of UML to model requirements in a use case driven approach. Activities that are used to refine use cases are the joinpoints to compose crosscutting concerns. The activities and their composition are formalized using the theory of graph transformation systems, which provides analysis support for detecting potential conflicts and dependencies between rule-based transformations. This theory is used to effectively reason about potential interactions and inconsistencies caused by aspect-oriented composition. The analysis is performed with the graph transformation tool AGG in order to get a better understanding of the potential behavior of the composed system. In addition, the activity control flow of the aspect/base specification and the composition operators are taken into account to identify the relevant interactions.