Abstract: AspectJ was designed as a seamless aspect-oriented extension of the Java programming language. However, unlike Java, AspectJ does not have a safe type system: an accepted binding between a pointcut and an advice can give rise to type errors at runtime. In addition, AspectJ's typing rules severely restrict the definition of certain generic advice behavior.In this paper, we analyze the roots of these type errors, and describe measures to recover type safety for both generic and non-generic pointcut/advice declarations. Pointcuts quantify over heterogeneous sets of join points and are hence typed using type ranges in our approach, while type variables and a dual advice signature allow to express the generic and invasive nature of advices. Using these mechanisms, we can express advice that augments, narrows or replaces base functionality in possibly generic contexts. As a language engineering contribution, we integrate our proposal with the AspectJ language, and we provide a prototype implementation as a plugin for the AspectBench Compiler (abc). On a theoretical level, we present a formal definition of the proposed constructs and typing rules, and develop proofs for their type safety properties.

Abstract: Many aspect-oriented middleware platforms support run-time aspect weaving, but do not support coordinating distributed changes to a set of aspects at run-time. A distributed change entails weaving or unweaving multiple inter-dependent aspects that are logically or physically distributed. Coordinating such multiple weavings inside the application layer is a complex and difficult task for the application developer, because global state consistency, structural integrity and other safety properties have to be preserved. In this paper, we present the DyReS framework that offers the required coordination support on top of existing aspect-oriented middleware platforms. The framework is customizable towards application-specific requirements to achieve improved performance and reconfiguration semantics. We have validated our approach by delivering and examining two implementations of the DyReS framework: one on top of JBoss AOP and a second one for Spring AOP.

Abstract: 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 fine-grained 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.

Abstract: We have reimplemented the frontend of the extensible AspectBench Compiler for AspectJ, using the aspect-oriented meta-compiler JastAdd. The original frontend was purely object-oriented. Each frontend extends Java with AspectJ and an additional set of pointcuts in a modular fashion. In this paper we give a detailed comparison of both approaches and show a number of advantages of using JastAdd: the implementation is half the size, twice as fast, concerns are better localised, extensions are composable, and computations are automatically scheduled.JastAdd provides a very constrained form of static AOP where only inter-type declarations and method execution interception are supported. However, additional modularisation mechanisms from the compiler construction community are supported in the form of demand-driven evaluation and attribute grammars. Our implementation would not have benefited from a richer pointcut language, while both demand-drive evaluation and declarative attributes were essential in enabling composable extensions and flexible modularisation.We believe that the AOP community at large can benefit from acknowledging demand-driven evaluation as an important modularisation mechanism. Also, reference attribute grammars enhance the extensible implementation of graphbased computations that rely on context-sensitive information.

Abstract: In a software product line, the binding time of a feature is the time at which one decides to include or exclude a feature from a product. Typical binding site implementations are intended to support a single binding time only, e.g., compile time or run time. Sometimes, however, a product line must support features with variable binding times. For instance, a product line may need to include both embedded system configurations, in which features are selected and optimized early, and desktop configurations, in which client programs choose features on demand.We present a new technique for implementing the binding sites of features that require flexible binding times. Our technique combines design patterns and aspect-oriented programming: a pattern encapsulates the variation point, and targeted aspects---called edicts---set the binding times of the pattern participants. We describe our approach and demonstrate its usefulness by creating a middleware product line capable of serving the desktop and embedded domains. Our product line is based on JacORB, a middleware platform with many dynamically configurable features. By using edicts to select features at compile time, we create a version of JacORB more suited to resource-constrained environments. By configuring four JacORB subsystems via edicts, we achieve a 32.2% reduction in code size. Our examples show that our technique effectively modularizes binding-time concerns, supporting both compile-time optimization and run-time flexibility as needed.

Abstract: In previous work, we presented a domain-specific version of C, called C4, which was used for capturing extensions to the Linux 2.6 kernel using AOSD techniques as an alternative to the conventional patching approach [10, 19]. The focus of that work was on introducing new extensions represented as aspects in system software such as the Linux kernel with a focus on readablility, compatibility, performance, and the preservation of existing development workflows. However, other AOSD researchers (e.g. Lohmann et al. [8]) state that "... Linux, as a monolithic system, provides a low number of join-points for aspects and that those available were semantically ambiguous." This worrisome statement motivated us to study the feasibility of applying AOSD techniques to refactor existing Linux kernel extensions. To gain insight we analyzed the AOSD-ness of a large number of configurable options available in the Linux kernel and evaluated whether they could be converted into aspects---and for the AOSD fan the preliminary results are promising.

Abstract: In this paper, we present algorithms that compute two kinds of information that can help AspectJ developers diagnose and fix potential problems with their pointcuts. First, we present an algorithm to compute almost matched joinpoints. Second, we present algorithms to compute explanations of why a pointcut does not match (or does match) a specific joinpoint. We implemented two tools using these algorithms. The first is an offline tool that analyzes a code base and produces a comprehensive report about the pointcuts in the code. Using this tool, we were able to find several real problems in existing, medium-sized AspectJ code bases. The second tool is an Eclipse plug-in called PointcutDoctor. PointcutDoctor is a natural extension of AJDT that provides developers easy access to the same information from within their already familiar development environment.

Abstract: One difficulty in software maintenance is that the relationship between observed program behavior and source code is not always clear. In this paper we are concerned specifically with the maintenance of graphical user interfaces (GUIs). User interface code can crosscut the decomposition of applications making GUIs hard to maintain. A popular approach to develop and maintain GUIs is to use "What you see is what you get" editors. They allow developers to work directly with a graphical design view instead of scattered source elements. Unfortunately GUI editors are limited by their ability to statically reconstruct dynamic collaborations between objects. In this paper we investigate the combination of a hybrid dynamic and static approach to allow for view-based maintenance of GUIs. Dynamic analysis reconstructs object relationships, providing a concrete context in which maintenance can be performed. Static checking restricts that only changes in the design view which can meaningfully be translated back to source are allowed. We implemented a prototype IDE plug-in and evaluate our approach by applying it to five open source projects.

Abstract: Aspect-oriented programming languages provide new composition mechanisms for improving the modularity of crosscutting concerns. Implementations of such language support use advanced program representations, like abstract syntax trees or stack traces, to enable an indirect specification (pointcut) of executions of program elements at which aspect code (advice) is invoked. During the evolution of a program, this representations will change and, hence, advice may not be executed as intended by the developer.In this paper we present a tool-supported refactoring approach that addresses this evolution problem by automating the detection of change effects on pointcuts and the generation of pointcut updates. A new model for decomposing pointcuts into simpler expressions is used as the base for deriving the change impact on pointcuts. Based on this model, we show how program analysis can detect affected or even broken pointcuts, how suitable pointcut adjustments can be derived, and when developer feedback is unavoidable.

Abstract: We propose test-based pointcuts, a novel pointcut mechanism for AspectJ-like aspect-oriented programming languages. The idea behind the test-based pointcuts is to specify join points through unit test cases associated with the target program. The test-based pointcuts improve robustness and precision of pointcut languages. The test-based pointcuts are more robust against software evolution because they do not directly rely on identifier names in a target program. The test-based pointcuts are more precise because they can distinguish fine grained execution histories including conditional branches by comparing the runtime execution histories with recorded for ones of the unit test cases. This paper presents design and implementation of the test-based pointcuts as an extension of an AspectJ compiler. We evaluated robustness and runtime efficiency of test-based pointcuts through case studies that applied test-based pointcuts to several versions of practical application programs.

Abstract: The relationships between objects in an object-oriented program are an essential property of the program's design and implementation. Two previous approaches to implement relationships with aspects were association aspects, an AspectJ-based language extension, and the relationship aspects library. While those approaches greatly ease software development, we believe that they are not general enough. For instance, the library approach only works for binary relationships, while the language extension does not allow for the association of primitive values or values from non-weavable classes. Hence, in this work we propose a generalized alternative implementation via a direct reduction to tracematches, a language feature for executing an advice after having matched a sequence of events. This new implementation scheme yields multiple benefits. Firstly, our implementation is more general than existing ones, avoiding most previous limitations. It also yields a new language construct, relational tracematches. We provide an efficient implementation based on the AspectBench Compiler, along with test cases and microbenchmarks. Our empirical studies showed that our implementation, when compared to previous approaches, uses a similar memory footprint with no leaking, but the generality of our approach does lead to some runtime overhead. We believe that our implementation can provide a solid foundation for future research.

Abstract: There has been a lot of debate about the modularity of aspect-oriented programs, and in particular the ability to reason about such programs in a modular way, although it has never been defined precisely what modular reasoning means. This work analyzes what it means to reason about a program, and separates "modular reasoning" into several well-defined properties of a reasoning model.A comparison of an OO language semantics with an AO language semantics with respect to these properties reveals that explanations of AOP that are based on weaving are a major obstacle to reasoning about AO programs in a modular way. We argue that a more modular semantics that is easier to reason about can be given to AO programs if we renounce the monotonicity of the corresponding reasoning system - a sacrifice that is well-known in artificial intelligence to model "common sense" reasoning. More generally, we claim that AOP should be understood as a form of nonmonotonic knowledge representation.

Abstract: Program enhancement refers to adding new functionality to an existing program. We argue that repetitive program enhancement tasks can be expressed as patterns, and that the application of such enhancement patterns can be automated. This paper presents a novel approach to pattern-oriented automated enhancement of object-oriented programs. Our approach augments the capabilities of an aspect compiler to capture the programmer's intent to enhance a program. In response to the programmer referencing a piece of functionality that is non-existent, our approach automatically synthesizes aspect code to supply the required functionality transparently. To improve flexibility and facilitate reuse, the synthesis and application of the new functionality is guided by declarative whenthen rules, concisely expressed using a rule base.Our extensible automated program enhancement system, called DRIVEL1, extends the AspectJ compiler with aspect generating capabilities. The generation is controlled using the DROOLS rules engine. To validate our approach and automated tool, we have created a collection of enhancement libraries and used DRIVEL to apply them to the LibX Edition Builder, a large-scale, widely-used Web application. DRIVEL automatically enhanced the LibX Edition Builder's XML processing modules with structural navigation capabilities and caching, eliminating the need to implement this functionality by hand.

Abstract: Test case instantiation is the transformation of abstract test cases into executable test scripts. Abstract test cases are either created during model based test case generation or are manually defined in a suitable modeling notation. The transformation varies depending on different testing concerns, such as test goal, test setup and test phase. Thus, for each testing concern a new transformation must be defined. This paper introduces AspectT, an aspect-oriented language for the instantiation of abstract test cases. We reduce the effort of test case instantiation by modularizing testing concerns in the form of aspects to enable their reuse in different testing contexts. The approach is implemented and integrated in an existing testing framework and has been successfully applied to test an electronic control unit of an automotive infotainment system at BMW Group.

Abstract: Advice weaving can be efficiently supported with only lightweight enhancements to existing Virtual Machines. Performing weaving at the Java bytecode (JBC) level while preserving appropriate metadata enables the VM to understand the AspectJ-specific semantics of the code and optimize it. This allows the overhead of advice weaving and performing non-local advice dispatch optimization to occur prior to runtime. It also allows the VM to perform optimizations that are unavailable to a bytecode level weaver.An experimental implementation shows that this approach can take advantage of previously known macro optimizations of expensive constructs, including cflow, as well as micro optimizations including those based on improved type analysis unavailable to JBC-based advice dispatch. A thorough benchmark evaluation confirms that the use of this architecture does not result in runtime performance overhead and benefits from the implemented optimizations.

Abstract: Aspect-orientation is a rapidly advancing technology. New and powerful aspect-oriented programming techniques are presented at many international venues every year. However, it is not clear what features of such techniques are "common aspect-oriented concepts" and what features are rather language-specific specialties. Research in aspectoriented modeling has the potential to help find such common characteristics from a perspective that is at a more abstract level (i.e., programming language-independent). The Aspect-Oriented Modeling (AOM) Workshops bring together researchers and practitioners from two communities, aspect-oriented software development (AOSD) and software model engineering. The workshops provide a forum for presenting new ideas and discussing the state of research and practice in modeling various kinds of crosscutting concerns at different levels of abstraction. The goals of the workshops are to identify and discuss the impacts of aspect-oriented technologies on model engineering to provide aspect-oriented software developers with general modeling means to express aspects and their crosscutting relationships onto other software artifacts.

Abstract: Framework-based application development requires applications to be implemented according to rules, recipes and conventions that are documented or assumed by the framework's Application Programming Interface (API), thereby giving rise to systematic usage patterns. While such usage patterns can be captured cleanly using conventional aspects, their variations, which arise in exceptional conditions, typically cannot be. In this position paper, we propose materializable aspects as a solution to this problem. A materializable aspect behaves as a normal aspect for default joinpoints, but for exceptional joinpoints, it turns into a program transformation and analysis mechanism, with the IDE transforming the advice in-place and allowing the application developer to modify the materialized advice within the semantics of the aspect. We demonstrate the need for materializable aspects through a preliminary study of open-source SWT-based applications and describe our initial implementation of materializable aspects in Eclipse.

Abstract: Nowadays context-aware adaptation is becoming an important feature for pervasive computing applications. In this paper we present JCOOL, a COntext Oriented Language tailored to handle context awareness in Java applications. JCOOL exploits Aspect Oriented techniques so that context changes detection and related adaptations can be considered as two separated crosscutting concerns with respect to the core "business logic" of new or legacy Java applications. Moreover, mobile and pervasive applications generally rely on middlewares that hide the complexity of the underlying environment. In order to show how JCOOL support can be introduced into middleware based application, in the second part of the paper we also describe JCOOL integration in SMILE [1], a Middleware Independent Layer developed in the scope of the SMS project [2].

Abstract: Practical middleware platforms nowadays are highly complex. This complexity surfaces internally in middleware construction, and externally in the programming models supported and features/services offered. There is a need to reduce this complexity both internally and externally: internally through enhanced modularity, and externally through the use of contemporary composition paradigms. Furthermore, middleware platforms need to be configurable, reconfigurable, customisable and extensible to reflect the specific needs of applications, the heterogeneity of involved systems and the multiple distributed deployment contexts. Aspect-Oriented Software Development (AOSD) has been put forward as a promising and successful paradigm to improve the reusability, extensibility, modularity and customization capabilities of middleware platforms. Moreover, most non-trivial applications of AO have emerged from the middleware domain, also a number of AO-frameworks (e.g. JBoss and Spring) specifically target the AO-middleware application domain. The goal of this workshop is to bring together and extend the AOSD and middleware research communities. This hybrid AO-middleware community is a cross-fertilization of 1) the AOSD community which has a plethora of promising technologies for further research on middleware development and middleware application composition and 2) the middleware community which has challenging applications for the validation and enhancement of AO-technologies

Abstract: AOSD is the premier conference on software modularity, with an emphasis on novel notions of modularity that crosscut traditional abstraction boundaries. The AOSD research track brings together leading researchers and practitioners working in the fields of software engineering, programming languages, and software systems. This volume consists of the papers to be presented as part of the research track at the 7th edition of AOSD, in 2008. A total of 79 papers were submitted, and 340 in-depth technical reviews were produced to rank the papers according to quality; the majority of papers received four reviews, many of the strong contenders received five reviews or more. Authors had an opportunity to respond to reviews, which helped clear up some misunderstandings. The research program committee met in Darmstadt, Germany to make the final selection of 17 papers. The program reflects how AOSD brings together different communities around the theme of crosscutting concerns: • Several papers investigate the benefits of combining aspects and generative programming for test case instantiation, program evolution, and modular compiler design. • Another group of papers is about using static analysis and knowledge representation techniques for reasoning about aspects and aspect-based modularity. • AOSD always has strong input from the programming language community; this year two sessions are dedicated to this theme, with contributions ranging from addressing static typing issues, to design of new language features, to implementation platforms for aspect-oriented languages. • Tool support is also a continuous theme of AOSD; this years research track includes three papers in this category. • Finally, the program includes presentations of interesting applications of aspect techniques to support adaptation and variability.

Abstract: As Aspect-Oriented Programming (AOP) wins more and more popularity, there is increasing interest in using aspects to implement crosscutting concerns in object-oriented software. During software evolution, source code editing and testing are interleaved activities to assure code quality. If regression tests fail unexpectedly after a long session of editing, it may be difficult for programmers to find out the failure causes. In this paper, we present Flota, a fault localization tool for AspectJ programs. When a regression test fails unexpectedly after a session of source changes, Flota first decomposes the differences between two program versions into a set of atomic changes, and then identifies a subset of affecting changes which is responsible for the failure. Programmers are allowed to select (and apply) suspected changes to the original program, constructing compliable intermediate versions. Thus, programmers can re-execute the failed test against these intermediate program versions to locate the exact faulty changes by iteratively selecting, applying and narrowing down the set of affecting changes. Flota is implemented on top of the ajc compiler and designed as an eclipse plugin. Our preliminary empirical study shows that Flota can assist programmers effectively to find a small set of faulty changes and provide valuable debugging support.

Abstract: Aspect-oriented software presents new challenges for the designers of static analyses. Our work aims to establish systematic foundations for dataflow analysis of AspectJ software. We propose a control- and data-flow program representation for AspectJ programs, as basis for subsequent interprocedural dataflow analyses. The representation is built at the source code level and captures the semantic intricacies of various pointcut designators, multiple applicable advices per joint point, dynamic advices, and general flow of data to, from, and between advices. We also propose two dataflow analyses for AspectJ software: (1) a novel object effect analysis based on a flow- and context-sensitive must-alias analysis, and (2) a dependence analysis used for constructing the system dependence graph for slicing, refactoring, change impact analysis, etc. Both analyses are representative of a general category of dataflow analyses referred to as interprocedural distributed environment (IDE) problems. The two analyses are built on top of the proposed representation, and take into account the complex flow of control and data due to aspect-oriented features. We present a study of the proposed techniques on 37 program versions, using our Ajana analysis framework which is based on the abc AspectJ compiler. The results show that the representation can be built efficiently, that it is superior to an approach based on the woven bytecode, and that it enables analyses that are both faster and more precise. These findings strongly indicate that the proposed approach is a promising candidate for a foundation upon which various inter-procedural analyses for AspectJ can be designed and built.

Abstract: Several aspect languages and frameworks have recognized the need for dynamic deployment of aspects. However, they do not provide sufficiently expressive means to precisely specify the scope of deployed aspects. As a result, programmers have to resort to unnecessarily complex pointcut definitions that hinder the reuse potential of aspects. To address the issue of precise and expressive scoping of aspects at deployment time, we propose deployment strategies for parameterized dynamic aspect deployment. This novel mechanism gives full control over the propagation of the aspect on the call stack and within created objects or functions, and permits a deployment-specific refinement of its pointcuts. We discuss and illustrate the gain in expressiveness, and provide the operational semantics of deployment strategies with Scheme interpreters, for both functional and object-oriented based aspect languages.