Aspect-Oriented Programming promises separation of concerns at the implementation level. However, aspects are not always orthogonal and aspect interaction is a fundamental problem. In this paper, we extend previous work on a generic framework for the formal definition and interaction analysis of stateful aspects. We propose three important extensions which enhance expressivity while preserving static analyzability of interactions. First, we provide support for variables in aspects in order to share information between different execution points. This allows the definition of more precise aspects and to avoid detection of spurious conflicts. Second, we introduce generic composition operators for aspects. This enables us to provide expressive support for the resolution of conflicts among interacting aspects. Finally, we o#er a means to define applicability conditions for aspects. This makes interaction analysis more precise and paves the way for reuse of aspects by making explicit requirements on contexts in which aspects must be used.

Abstract. Aspects have been successfully promoted as a means to improve the modularization of software in the presence of crosscutting concerns. The socalled aspect interference problem is considered to be one of the remaining challenges of aspect-oriented software development: when multiple aspects share the same join point, undesired behavior may emerge. Such behavior is not necessarily caused by a wrong implementation of the individual aspects, but may be the result of composition of the independently programmed aspects at the shared join point. This paper presents a language-independent technique to detect semantic conflicts among aspects that are superimposed on the same join point. 1

Abstract. A trace monitor observes the sequence of events in a system, and takes appropriate action when a given pattern occurs in that sequence. Aspect-oriented programming provides a convenient framework for writing such trace monitors. We provide a brief introduction to aspect-oriented programming in AspectJ. AspectJ only provides support for triggering extra code with single events, and we present a new language feature (named tracematches) that allows one to directly express patterns that range over the whole current trace. Implementing this feature efficiently is challenging, and we report on our work towards that goal. Another drawback of AspectJ is the highly syntactic nature of the event patterns, often requiring the programmer to list all methods that have a certain property, rather than specifying that property itself. We argue that Datalog provides an appropriate notation for describing such properties. Furthermore, all of the existing patterns in AspectJ can be reduced to Datalog via simple rewrite rules. This research is carried out with abc, an extensible optimising compiler for AspectJ, which is freely available for download. 1

A variety of dynamic aspect-oriented language constructs are proposed in recent literature with corresponding, compelling use cases. Such constructs demonstrate the need to dynamically adapt the set of join points intercepted at a fine-grained level. The notion of morphing aspects and continuous weaving is motivated by this need. We propose an intermediate language model called Nu, that extends object-oriented intermediate language models with two finegrained deployment primitives: bind and remove. These primitives offer a higher level of abstraction as a compilation target for dynamic aspect-oriented language constructs, thereby making it easier to support such constructs. We present the design and implementation of the Nu model in the Sun Hotspot VM, an industrial strength virtual machine, which serves to show the feasibility of the intermediate language design. Our implementation uses dedicated caching mechanisms to significantly reduce the amortized costs of join point dispatch. Our evaluation shows that the cost of supporting a dynamic deployment model can be reduced to as little as ∼1.5%. We demonstrate the potential utility of the intermediate language design by expressing a variety of aspect-oriented source language constructs of dynamic flavor such as CaeserJ’s deploy, history-based pointcuts, and control flow constructs in terms of the Nu model.

Aspect-Oriented Programming is a promising approach to the construction of large-scale software systems. The declarativeness of aspect definitions and support for verification of AO programs crucially depends on the expressiveness of the aspect languages used. Currently, a large spectrum of pointcut languages, i.e., the languages that define where aspects may apply modifications to an application, have been proposed. Their expressiveness ranges from regular expression languages, which, e.g., provide support for static interaction analysis, to context-free or turing complete languages, the latter almost without any support for analysis or verification. In this paper we investigate the use of Visibly Pushdown Automata (VPA) [4] as a basis for an aspect language in order to enable more declarative aspect definitions (compared to regular approaches) for protocollike relationships and static verification of properties, in particular analysis of interactions among aspects. Concretely, we present four contributions: (i) we provide a set of examples motivating the use of VPA-based aspect definitions in the context of P2P systems, (ii) formally define a core aspect language for protocols with a VPA-based pointcut language, (iii) show that this language supports the analysis of interaction properties among aspects, and (iv) briefly present a freely available library implementing basic VPA operations, which we have used to analyze some interaction examples.

Aspect-Oriented Programming (AOP) is a promising approach to modularizing software in presence of crosscutting concerns. Numerous proposals for AOP have been formulated, some of them generic, others specific to particular concerns. There are commonalities and variabilities among these approaches, which are worth exploring. Unfortunately, in practice, these various approaches are hard to combine and to extend. This results from the fact that the corresponding tools, such as aspect weavers, have not been designed to be used along with others, although they usually perform very similar low-level tasks. In this paper, we suggest to include common functionality into a versatile kernel for AOP. Such a kernel alleviates the task of implementing an aspect-oriented approach by taking care of basic program alterations. It also lets several approaches coexist without breaking each other by automatically detecting interactions among aspects and o#ering expressive composition means. From a review of the main features of Aspect-Oriented Programming, we present the main issues that the design of such an AOP kernel should address: open support for aspect languages taking care of both behavior and structure, base language compliance, and aspect composition. An AOP kernel for Java is currently under development.

Modern source-level debuggers support dynamic breakpoints that are guarded by conditions based on program state. Such breakpoints address situations where a static breakpoint is not sufficiently precise to characterise a point of interest in program execution. However, we believe that current IDE support for dynamic breakpoints are cumbersome to use. Firstly, guard conditions formulated in (nonaspect-oriented) source-languages cannot directly express control-flow conditions, forcing developers to seek alternative formulations. Secondly, guard-conditions can be complex expressions and manually typing them is cumbersome. We present the Control-flow Breakpoint Debugger (CBD). CBD uses a dynamic pointcut language to characterise control-flow breakpoints—dynamic breakpoints which are conditional on the control-flow through which they were reached. CBD provides a “point-and-click ” GUI to specify and incrementally refine control-flow breakpoints, thereby avoiding the burden of manually editing the potentially complex expressions that define them. We performed 20 case studies debugging and fixing documented bugs in 3 existing applications. Our results show that dynamic breakpoints in general are useful in practice, and that CBD’s GUI allows specifying them adequately in the majority of cases.

In this position paper, the authors argue that Aspect-Oriented Modeling (AOM) technologies have the potential to simplify the deployment and the ability to reason about a category of crosscutting concerns that have been categorized in the literature as stateful aspects. Stateful aspects trigger on a sequence of join points instead of on a single join point. Their trigger condition is history sensitive. We identify three properties of Aspect-Oriented Modeling languages that enable them to provide more natural solutions to the stateful aspect problem. The first factor is the ability of modeling languages to support different system decompositions paradigms. This ability allows a system to be decomposed according to the paradigm that fits the nature of the problem the best. Second, these decompositions allow AOM languages to capture and reason about pointcut descriptors at a higher level of abstraction. Finally, the system decomposition mechanisms can be exploited to advance the compositional expressiveness of aspects defined in AOM languages. The paper concludes with an invitation to our colleagues in the “general purpose ” programming community to embrace modeling technologies in the context of automatic code generation.

Many crosscutting mechanisms proposed in the literature offer means to restrain aspects to some dynamically-defined scopes. Dynamicallyscoped mechanisms are particularly interesting because of the flexibility, expressiveness, and control they give over structural and behavioral changes made by aspects. Since the nature of dynamic scopes as well as the scoping mechanisms themselves greatly vary among proposals, it is relatively complex to compare them. This paper aims at filling this gap by proposing a first characterization of dynamically-scoped crosscutting mechanisms, hence providing a reference frame for comparing different approaches. As a result, this work clarifies some differences between related approaches, suggests possible tracks for further exploration of the design space of such mechanisms, and discusses some issues raised by dynamically-scoped aspects.

Dynamic aspect-oriented (AO) features have important software engineering benefits such as allowing unanticipated software evolution and maintenance. It is thus important to efficiently support these features in language implementations. Current implementations incur unnecessary design-time and runtime overhead due to the lack of support in underlying intermediate language (IL) models. To address this problem, we present a flexible and dynamic IL model that we call Nu. The Nu model provides a higher level of abstraction compared to traditional object-oriented ILs, making it easier to efficiently support dynamic AO features. We demonstrate these benefits by providing an industrial strength VM implementation for Nu, by showing translation strategies from dynamic source-level constructs to Nu, and by analyzing the performance of the resulting IL code. Nu's VM extends the Sun Hotspot VM interpreter and uses a novel caching mechanism to significantly reduce the amortized costs of join point dispatch. Our evaluation using standard benchmarks shows that the overhead of supporting a dynamic deployment model can be reduced to as little as ∼1.5%. Nu provides an improved compilation target for dynamic deployment features, which makes it easier to support such features with corresponding software engineering benefits in software evolution and maintenance and in runtime verification.