AspectJ-TM is a simple and practical aspect-oriented extension to Java-TM. With just a few new constructs, AspectJ provides support for modular implementation of a range of crosscutting concerns. In AspectJ's dynamic join point model, join points are well-defined points in the execution of the program

Aspect-Oriented Programming (AOP) promises separation of concerns at the implementation level. However, aspects are not always orthogonal and aspect interaction is an important problem. Currently there is almost no support for the detection and resolution of suchinteractions. The programmer is responsible for identifying interactions between con#icting aspects and implementing conflict resolution code. In this paper

Behavioral reflection is a powerful approach for adapting the behavior of running applications. In this paper we present and motivate partial behavioral reflection, an approach to more e#cient and flexible behavioral reflection. We expose the spatial and temporal dimensions of such reflection, and propose a model of partial behavioral reflection based on the notion of hooksets. In the context of Java, we describe a reflective architecture o#ering appropriate interfaces for static and dynamic configuration of partial behavioral reflection at various levels, as well as Reflex, an open reflective extension for Java implementing this architecture. Reflex is the first extension that fully supports partial behavioral reflection in a portable manner, and that seamlessly integrates load-time and runtime behavioral reflection. The paper shows preliminary benchmarks and examples supporting the approach. The examples, dealing with the observer pattern and asynchronous communication via transparent futures, also show the interest of partial behavioral reflection as a tool for open dynamic Aspect-Oriented Programming.

Aspect-Oriented Programming (AOP) promises the modularization of so-called crosscutting functionalities in large applications. Currently, almost all approaches to AOP provide means for the description of sequential aspects that are to be applied to a sequential base program. In particular, there is no formally-defined concurrent approach to AOP, with the result that coordination issues between aspects and base programs as well as between aspects cannot precisely be investigated. This paper presents Concurrent Event-based AOP (CEAOP), which addresses this issue. Our contribution can be detailed as follows. First, we formally define a model for concurrent aspects which extends the sequential Event-based AOP approach. The definition is given as a translation into concurrent specifications using Finite Sequential Processes (FSP), thus enabling use of the Labelled Transition System Analyzer (LTSA) for formal property verification. Further, we show how to compose concurrent aspects using a set of general composition operators. Finally, we sketch a Java prototype implementation for concurrent aspects, which generates coordination specific code from the FSP model

The goal of aspect-oriented programming is to modularize crosscutting concerns (or aspects) at the code level. These aspects can be defined in either a general-purpose language or in a language that is fine-tuned to a specific aspect in consideration. Aspect-specific languages provide more concise and more readable aspect declarations but are limited to a specific domain. Moreover, multiple aspects may be needed in a single application and combining aspects written in different aspect languages is not an easy task.

assertions over programs that otherwise are not annotated to receive these assertions. Varieties of AOP systems are characterized by which quantified assertions they allow, what they permit in the actions of the assertions (including how the actions interact with the base code), and what mechanisms they use to achieve the overall eftct. Here, we argue that all quantification is over dynamic events, and describe our preliminary work in developing a system that maps dynamic events to transformations over source code. We discuss possible applications of this system, particularly with respect to debugging concurrent systems.

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

AOSD improves separation of concerns in software development by enabling the modular expression of crosscutting aspects. However, modular implementation of an aspect requires techniques for “weaving ” the aspect into the code of all classes that require it. Often, weaving is complicated by the unavailability or dynamic creation of source code. We present JMangler, a freely available framework for load-time transformation of compiled Java programs. We introduce the notions of generic class file interception and order-independent composition and explain JMangler’s contribution in these areas. Then we show how JMangler can be used for load-time weaving and for injecting hooks that enable run-time weaving. JMangler enables behaviors beyond the ability of current high-level AOSD languages and systems. AOSD improves separation of concerns by enabling the modular expression of crosscutting concerns. Modular implementation of a concern as one aspect 1 requires techniques to “weave” this implementation back into the code of all classes which require the concern. For instance, logging behavior expressed in one aspect must be “woven ” into all the classes of a

Software classifications are mainly considered as a means for helping the programmer in navigating and exploring the code. This paper illustrates by means of examples that software classification is also useful for code generation. This requires a highly flexible and expressive classification mechanism. We propose to use a logic programming language for this purpose.

We review the state-of-the-art of reflection and metaprogramming, prior to our work on partial behavioral reflection and Reflex, and open implementations. The first four sections are dedicated to reflection. Section 1 introduces the concept of reflection and its application to programming languages. Section 2 discusses reflection in the particular context of object-oriented programming languages. Then, since we are interested in addressing issues in the concrete applicability of reflection, we dedicate Section 3 to the structuring and engineering of metalevel architectures, while implementation considerations are dealt with in Section 4. After this comprehensive review of reflection, the last section discusses the related area of open implementations (Section 5).