Abstract: Distribution-related concerns, such as data replication, often crosscut the business code of a distributed application. Currently such crosscutting concerns are frequently realized on top of distributed frameworks, such as EJBs, and initial AO support for the modularization of such crosscutting concerns, e.g., JBoss AOP and Spring AOP, has been proposed.Based on an investigation of the implementation of replicated caches using JBoss Cache, we motivate that crosscutting concerns of distributed applications benefit from an aspect language for explicit distributed programming. We propose AWED, a new aspect language with explicit distributed programming mechanisms, which provides three contributions. First, remote pointcut constructors which are more general than those of previous related approaches, in particular, supporting remote sequences. Second, a notion of distributed advice with support for asynchronous and synchronous execution. Third, a notion of distributed aspects including models for the deployment, instantiation and state sharing of aspects. We show several concrete examples how AWED can be used to modularly implement and extend replicated cache implementations. Finally, we present a prototype implementation of AWED, which we have realized by extending JAsCo, a system providing dynamic aspects for Java.

Abstract: The current AspectJ join points represent locations in the code that are the interface of the Java objects. However, not all the "things that happen" happen at the interfaces. In particular, loops are a key place that could be advised for parallelisation. This article presents a loop join point model, which allows AspectJ to intervene directly in loops. More generally, this demonstrates the need for, and provides, a more complex join point in AspectJ.The approach used for recognising loops is based on a control-flow analysis at the bytecode level; this avoids ambiguities due to alternative forms of source-code that would effectively produce identical loops. This model is also enhanced with a mechanism for context exposure, which is pivotal for giving a meaning to the use of this join point, and with additional information through join point reflection. The context exposure is particularly useful for writing pointcuts that select specific loops only, and the problem of loop selection is also presented in the paper.Finally, LoopsAJ, an extension for the abc compiler that provides AspectJ with a loop join point, is presented. It is shown how to use this extension for writing aspects that parallelise loops.

Abstract: Pattern composition has been shown as a challenge to applying design patterns in real software systems. One of the main problems is that multiple design patterns in a system are not limited to affect only the application concerns. They also crosscut each other in multiple heterogeneous ways so that their separation and composition are far from being trivial. In this context, it is of paramount importance to systematically verify whether aspect-oriented programming (AOP) supports improved composability of design patterns. This paper presents a systematic investigation on how AOP scales up to deal with modularization of pattern-specific concerns in the presence of pattern interactions. We have made both qualitative and quantitative assessments of 62 pairwise compositions taken from 3 medium-sized systems implemented in Java and AspectJ programming languages. Our analysis has also included the evaluation of compositions involving more than two patterns. The assessment was based on four fundamental software attributes, namely separation of concerns, coupling, cohesion, and conciseness.

Abstract: Taking aspects as incremental modifications to their base classes, this paper presents an incremental approach to testing whether or not aspect-oriented programs and their base classes conform to their respective behavior models. We exploit a rigorous aspect-oriented extension to state models for capturing the impact of aspects on the state transitions of base class objects as well as an explicit weaving mechanism for composing aspects into their base models. We generate abstract tests for base classes and aspect-oriented programs from their state models. As base class tests are not necessarily valid for aspect-oriented programs, we identify several rules for maximizing reuse of concrete base class tests for aspects according to the state-based impact of aspects on their base classes. To illustrate our approach, we use two examples that indicate distinctive types of aspect-oriented applications and exhibit fundamental features in complex applications: aspects removing state transitions from base classes and aspects adding and modifying state transitions in base classes. Our results show that majority of base class tests can be reused for aspects, but subtle modifications to some of them are necessary. In particular, positive (or negative) base class tests can become negative (or positive) aspect tests. We also discuss how several types of aspect-specific faults can be revealed by the state-based testing.

Abstract: Aspect-oriented software development is gaining popularity with the wider adoption of languages such as AspectJ. To reduce the manual effort of testing aspects in AspectJ programs, we have developed a framework, called Aspectra, that automates generation of test inputs for testing aspectual behavior, i.e., the behavior implemented in pieces of advice or intertype methods defined in aspects. To test aspects, developers construct base classes into which the aspects are woven to form woven classes. Our approach leverages existing test-generation tools to generate test inputs for the woven classes; these test inputs indirectly exercise the aspects. To enable aspects to be exercised during test generation, Aspectra automatically synthesizes appropriate wrapper classes for woven classes. To assess the quality of the generated tests, Aspectra defines and measures aspectual branch coverage (branch coverage within aspects). To provide guidance for developers to improve test coverage, Aspectra also defines interaction coverage. We have developed tools for automating Aspectra's wrapper synthesis and coverage measurement, and applied them on testing 12 subjects taken from a variety of sources. Our experience has shown that Aspectra effectively provides tool supports in enabling existing test-generation tools to generate test inputs for improving aspectual branch coverage.

Abstract: The relationships between objects in object-oriented programs are as important as the objects themselves. Unfortunately, most object-oriented programming languages provide little support for such relationships, leaving the task of implementing them entirely to the programmer. Relationships are typically hard-coded into the participating classes, resulting in tangled code that unnecessarily couples these classes together. The classes become harder to understand and cannot be reused independently. Aspect-oriented programs can model relationships explicitly, treating them as separate concerns that cross-cut their participants. We show how relationships can be implemented as a library of aspects in Aspect/J. Aspects keep relationships independent of their participants, making the resulting programs easier to read, write and reuse, and as efficient as hand-written code.

Abstract: In this paper, we present a collection of well-known high-level concurrency patterns and mechanisms, coded in AspectJ. We discuss benefits of these implementations relative to plain Java implementations of the same concerns. We detect benefits from using AspectJ in all the cases presented, in the form of higher modularity, reuse, understandability and unpluggability. For most of the implementations, two alternatives can be used: one based on traditional pointcut interfaces and one based on annotations.

Abstract: OOP style requires programmers to organize their code according to objects (or nouns, using natural language as a metaphor), causing a program's actions (verbs) to become scattered during implementation. We define an Action-Oriented Identifier Graph (AOIG) to reconnect the scattered actions in an OOP system. An OOP system with an AOIG will essentially support the dynamic virtual remodularization of OOP code into an Action-Oriented View. We have developed an algorithm to automatically construct an AOIG, and an implementation of the construction process. To automatically construct an AOIG, we use Natural Language Processing (NLP) techniques to process the natural language clues left by programmers in source code and comments, and we connect code segments through the actions that they perform. Using a reasonably sized program, we present several applications of an AOIG (feature location, working set recovery, and aspect mining), which demonstrate how the AOIG can be used by software engineering tools to combat the tyranny of the dominant decomposition.

Abstract: In this paper, we contribute to the characterisation of a programming style specific to aspect-oriented programming. For this purpose, we present a collection of refactorings for aspect-oriented source code, comprising refactorings to enable extraction to aspects of crosscutting concerns from object-oriented legacy code, the subsequent tidying up of the extracted aspects and factoring out of common code from similar aspects to superaspects. The second group of refactorings is documented in detail. In addition, we propose some new aspect-oriented code smells, including one smell that is specific to aspect modules. We also propose a reinterpretation of some of the traditional object-oriented code smells in the light of aspect-orientation, to detect the presence of crosscutting concerns.

Abstract: This paper presents a challenge case study to the aspect-oriented community: ensuring the ACID properties (atomicity, consistency, isolation and durability) for transactional objects. We define a set of ten base aspects, each one providing a well-defined reusable functionality. The base aspects are simple, yet have complex dependencies among each other. We then show how these base aspects can be configured and composed in different ways to implement different concurrency control and recovery strategies. This composition is delicate: some aspects conflict with each other, others have to be reconfigured dynamically at run-time. We believe that this case study can serve as a benchmark for aspect-oriented software development, in particular for evaluating the expressivity of aspect-oriented programming languages, the performance of aspect-oriented programming environments, and the suitability of aspect-oriented modeling notations.

Abstract: The design structure matrix (DSM) methodology and the net option value (NOV) model have been used before to show how aspects can add value to a design. Following an in-depth analysis of that study, this paper demonstrates how aspects can be beneficial as well as detrimental. The structural transformations involved in aspect modularizations are carefully analyzed in the context of DSMs. This analysis exposes the unique reversion effect on dependencies that aspect modules are known for. To capture that effect within the NOV model, we extend its original set of six modular operators with an additional reversion operator. Using a design case study, its NOV worksheet and NOV experiments' curves are presented to show a simulation of the evolutionary patterns of modules, including aspect modules. These patterns show how subtle dependencies, or the lack of them, bring down, or up, the value of an existing design. Based on the observations made in this case study, preliminary design guidelines for aspects are formulated.

Abstract: Software development in the domain of embedded and deeply embedded systems is dominated by cost pressure and extremely limited hardware resources. As a result, modern concepts for separation of concerns and software reuse are widely ignored, as developers worry about the thereby induced memory and performance overhead. Especially object-oriented programming (OOP) is still little in demand. For the development of highly configurable fine-grained system software product lines, however, separation of concerns (SoC) is a crucial property. As the overhead of object-orientation is not acceptable in this domain, we propose aspect-oriented programming (AOP) as an alternative. Compared to OOP, AOP makes it possible to reach similar or even better separation of concerns with significantly smaller memory footprints. In a case study for an embedded system product line the memory costs for SoC could be reduced from 148–236% to 2–10% by using AOP instead of OOP.

Abstract: AOP languages are continuously evolving, for example (1) pointcut languages are becoming increasingly powerful with respect to the expressiveness of the pointcut language itself, (2) new program properties can be used as a selection criterion in pointcut designators, or (3) new types of program elements can be introduced by means of a crosscut specification. In this paper we investigate the consequences of these trends. To this end, we focus particularly on the usage of meta-data annotations: several recent (versions of) AOP languages support the use of annotations as a selection criterion in pointcut designators or the introduction of annotations, or both. We investigate the introduction of annotations through the use of expressive pointcut languages; explain why introduction of annotations is useful, and in particular, why and how annotations can be derived from other annotations.We explore the issues that arise due to the inter-dependencies between annotation introductions. We investigate when such dependencies may cause ambiguities, and we present an algorithm that resolves the dependencies when possible, and detects ambiguous cases that cannot be resolved. The solution we propose is implemented within the Compose* tool, which supports the introduction of meta-data annotations.

Abstract: The development process for operating system kernels in Unix-like systems is becoming increasingly complex. The simple, easily understandable kernels of the 1970s have evolved into giant software systems consisting of hundreds of modules implemented in millions of lines of code, resulting in greatly increased resource and time overhead for bug fixes as well as functional improvements. Many code modifications and additions in kernel code are crosscutting, since they exhibit cross-module or cross-layer functionality, thus an aspect-oriented programming (AOP) approach is well suited for solving these problems. Operating system code implicitly involves dynamic behavior due to various threads in kernel mode that run in different process or hardware contexts. Methods to solve the crosscutting problems have to be able to adapt dynamically to this changing environment; as a result, dynamic AOP inside the kernel is required to implement required functionality. This paper analyzes the feasibility of using dynamic AOP in kernel code. Using the TOSKANA system, it is shown that implementing dynamic AOP features is not only possible in operating system kernels, but also realizable with a justifiable overhead. First, the cross-module and cross-layer properties inherent in kernel code are presented, with special consideration of crosscutting concerns in procedural C kernel code. Then, TOSKANA—our toolkit for deploying dynamic aspects into an operating system kernel—is introduced. TOSKANA provides before, after and around advice for in-kernel functions and supports the specification of pointcuts as well as the implementation of aspects themselves as dynamically exchangeable kernel modules. The use of TOSKANA is demonstrated by several examples of cross-module as well as cross-layer problems and their solutions using dynamic AOP functionality inside the kernel. Performance results are presented to characterize the aspect deployment overhead incurred by using TOSKANA.

Abstract: The goals of aspect oriented software development (AOSD) and frameworks for configurable protocols (CPs) are similar in many respects. AOSD allows the specification of cross-cutting concerns called aspects as separate modules that are woven with the base program as needed. CPs are oriented towards building protocols or services with different quality of service (QoS) properties and attributes out of collections of independent modules, with each configuration customizing the service for a given application and execution environment. As AOSD evolves to address issues in areas such as middleware, operating systems, and distributed computing that have traditionally been the domain of CPs, lessons learned from the development of these frameworks could be useful. The purpose of this paper is to draw parallels between AOSD and CP frameworks, with a specific focus on the Cactus framework and how it compares and contrasts with the aspect-oriented paradigm.

Abstract: This paper presents an approach to enrich MATLAB with aspectoriented extensions to experiment different implementation features. The language we propose aims to configure the low-level data representation of real variables and expressions, to a specifically-tailored fixed-point data representation that benefits from a more efficient support by computing engines (e.g., DSPs, application-specific architectures, etc.) without specific hardware-based floating point units. Additionally, the approach aims to help developers to introduce handlers and monitoring features, and to configure a function with an optimized implementation.

Abstract: Run-time weaving of distributed aspects, if performed without any support for atomicity, endangers the global behavioral integrity of the application. Existing aspect-oriented middleware supports run-time weaving of distributed aspects, without addressing this problem. This inherently limits the type of behavioral changes that can be performed at run time. This paper presents a model and an architecture for middleware, named Lasagne, that supports run-time weaving of distributed aspects in an atomic way. The paper makes the case that run-time weaving of distributed aspects is well suited for supporting dynamic and behavioral adaptations that are cross-component, cross-node or cross-layer. Adding support for atomic weaving ensures that such system-wide adaptations are performed in a safe and coordinated way.

Abstract: In the web services environment software development can involve writing both object-oriented programs and XML transformations. This can be seen in the popular Web Services architecture. In this architecture, crosscutting concerns are often manifest as transformations on XML messages; encrypting messages, adapting between schemas types or adding extra-functional elements such as transaction contexts can be seen as prime examples. Some existing middleware platforms provide support for Handlers where crosscutting message transformation concerns can be addressed. Although handlers localize some concerns, they do not support the sound software-engineering principle of "programming to an interface". This prevents a clean mapping from design to implementation and inhibits useful static checking which could take advantage of a well specified interface. To address this and similar design challenges, we have developed Doxpects, which solve many problems with the existing handler approach to implementing these new crosscutting concerns. We describe an AOP abstraction called the content-based pointcut which integrates support for XML transformation to enable implementation of crosscutting concerns with good modularity properties. We present examples based on XML encryption and service interoperability implemented on top of the Apache Axis Web Services middleware.

Abstract: This paper describes the design and implementation of association aspects, which are a linguistic mechanism for the AspectJ language that concisely associates aspect instances to object groups by extending the per-object aspects in AspectJ. This mechanism allows an aspect instance to be associated to a group of objects, and by providing a new pointcut primitive to specify aspect instances as execution context of advice. With association aspects, we can straightforwardly implement crosscutting concerns that have stateful behavior related to a particular group of objects. The new pointcut primitive can more flexibly specify aspect instances when compared against previous implicit mechanisms. We implemented a compiler for association aspects by modifying the AspectJ compiler, which reduces the size of data structures for keeping associations. Our benchmark tests confirm that the overheads of association aspects are reasonably small when compared against functionally equivalent aspects in pure AspectJ that manually manage associations. The expressiveness of association aspects is demonstrated through development of an integrated development environment with and without association aspects.

Abstract: This talk is an essay on design. In the 16 century, Michel de Montaigne invented a new genre of writing he called an essai, which in modern French translates to attempt. Since then, the best essays have been explorations by an author of a topic or question, perhaps or probably without a definitive conclusion. Certainly there can be no theme or conclusion stated at the outset, repeated several times, and supported throughout, because a true essay takes the reader on the journey of discovery that the author has or is experiencing. This essay—on design—is based on my reflections on work I’ve done over the past 3 years. Some of that work has been on looking at what constitutes an “ultra large scale software system” and on researching how to keep a software system operating in the face of internal and external errors and unexpected conditions.

Abstract: Shakeins are a novel programming construct which, like mixins and generic classes, generates new classes from existing ones in a universal, uniform, and automatic manner: From a given class, a shakein generates a new class which has the same type as the original, but with different data and code implementation. We argue that shakeins are restricted, yet less chaotic, aspects. We further claim that shakeins are well suited for the introduction of aspect-oriented programming (AOP) into existing middleware applications. We introduce the AspectJ2EE language which, with the help of shakeins and a new deploy-time weaving mechanism, brings the blessings of AOP to the J2EE framework. A unique advantage of AspectJ2EE, which is less general (and hence less complicated) than AspectJ, is that it can be smoothly integrated into J2EE implementations without breaking their architecture.

Abstract: In order to provide better alignment between conceptual requirements and aspect-oriented implementations, specification methods should enable the encapsulation of behavioral abstractions of systems. In this paper we argue that horizontal architectures, consisting of such behavioral abstractions, can provide better separation of concerns than conventional architectures, while supporting incremental development for more common units of modularity such as classes. We base our arguments on our experiences with the DisCo method, where behavioral abstractions are composed using the superposition principle, a technique closely associated with aspect orientation. Moreover, we demonstrate how the alignment between an abstract, horizontally architected specification (or model) and its aspect-oriented implementation can be achieved. Mappings are discussed that implement symmetric DisCo specifications both in Hyper/J, which enables symmetric separation of concerns, and in AspectJ that uses asymmetric structuring.

Abstract: Current quality of service (QoS) management approaches in real-time systems lack support for configurability and reusability as they cannot be configured for a target application or reused across many applications. In this paper we present the concept of a QoS aspect package that enables developing configurable QoS management for real-time systems. A QoS aspect package represents both the specification and the implementation of a set of aspects and components that provide a number of QoS policies. A QoS aspect package enables upgrades of already existing systems to support QoS performance assurance by adding aspects and components from the package. Furthermore, a family of real-time systems can easily be developed by adding aspects from the QoS aspect package into an existing system configuration. We illustrate the way a family of real-time database systems is developed using the QoS aspect package with a case study of an embedded real-time database system, called COMET. Our experiments with the COMET database have shown that it is indeed possible to design a real-time system without QoS management and then with a reasonable effort add the QoS dimension to the system using a QoS aspect package.

Abstract: Some “non-” or “extra-functional” features, such as reliability, security, and tracing, defy modularization mechanisms in programming languages. This makes such features hard to design, implement, and maintain. Implementing such features within a single platform, using a single language, is hard enough. With distributed, heterogeneous systems, these features induce complex implementations which crosscut different languages, OSs, and hardware platforms, while still needing to share data and events. Worse still, the precise requirements for such features are often locality-dependent and discovered late (e.g., security policies). This paper describes an interface description language, Dado, to help program crosscutting features in CORBA based middleware software through an aspect-oriented programming. A Dado specification comprises pairs of adaptlets which are explicitly modeled in an extended version of CORBA IDL. Dado supports flexible and type-checked interactions (using generated stubs and skeletons) between adaptlets and between objects and adaptlets. Dado also supports co-ordinated, run-time binding of adaptlet-based features to applications in a distributed setting.

Abstract: In the 1970s, 1980s and 1990s, computer designers created a series of “option-rich modular design architectures” in both hardware and software. But a pure design is, strictly speaking, only an idea. Unless the design is reified—made real, brought into reality—it cannot affect the physical world and cannot be used or consumed. In order to affect the world and be valued, a design idea must be first completed and then made into something. Those actions in turn require human effort and human organization. Designs need the economy for several purposes: to implement design processes so that the designs can be completed; to carry out design instructions so that the designs can be realized; to transfer artifacts to users who value them; and to get designers and producers paid for their efforts. Designs influence the economy by creating perceptions of financial value. These perceptions in turn motivate investment and the creation of new economic institutions. Option-rich and modular architectures are extremely effective conduits of value, but their evolution may be difficult to control. In this talk, I will adopt the “designs’ point of view” in order to understand the economic institutions and mechanisms by which new designs and new artifacts come into existence.

Abstract: Aspect-oriented programming (AOP) describes a range of techniques that enable the separation, organisation and composition of various programming concerns that cannot be adequately encapsulated using the principal decomposition mechanisms available to modern programming languages.Naturally, most AOP-related research is focussed on its application to the development of computer software. However, we believe that it is worthwhile considering whether AOP and cognate techniques might be usefully adapted as a means for an end-user to organise, represent and compose information in computer systems that support application domains in which scattering and tangling are present.Music is notoriously rich in deeply tangled relationships. Moreover, there is no universally accepted representation of music that simultaneously represents all dimensions of interest to the composer.In this paper we describe Aspect Oriented Music Representation, an approach to the organisation, representation and composition of musical materials based on MDSOC. Our approach extends MDSOC by adding a dynamic hyperspace and by allowing users to write detailed composition expressions using an extensible set of compositors. We introduce the concept of composition history, enabling symmetric composition to be related to joinpoints, demonstrating a way to combine symmetric and asymmetric aspect approaches.

Abstract: Legacy software systems do not solely consist of source code: various other types of artifacts play a role, notably the build system. As each considerable change to the software system potentially demands modifications of build-related files, maintainers and developers alike need to find their way around quickly. The MAKAOframework aims to be a suitable visualisation and reverse-engineering framework for build systems, facilitating research regarding the need for aspect-oriented mechanisms when modularizing builds.