Skip to main content

Über dieses Buch

The LNCS journal Transactions on Aspect-Oriented Software Development is devoted to all facets of aspect-oriented software development (AOSD) techniques in the context of all phases of the software life cycle, from requirements and design to implementation, maintenance and evolution. The focus of the journal is on approaches for systematic identification, modularization, representation and composition of crosscutting concerns, i.e., the aspects and evaluation of such approaches and their impact on improving quality attributes of software systems. This volume, the 9th in the Transactions on Aspect-Oriented Software Development series, contains three regular submissions and two special sections, each consisting of two papers. The papers focus on the following topics: modularization, pointcut language, dynamic adaptation, event-based programming, aspect-aware design, system software, object composition and templates.



Regular Papers

Domain-Driven Discovery of Stable Abstractions for Pointcut Interfaces

The benefits of defining explicit pointcut interfaces in aspect-oriented applications have been advocated by many. A pointcut interface exposes a set of crosscutting abstract behaviors that multiple aspects of an application can leverage and use. In order to maximally promote pointcut reuse across applications from a certain problem domain, a pointcut interface should preferably expose stable abstractions in that problem domain.

In this paper, we propose a top-down method for designing such stable pointcut interfaces. The method builds upon state-of-the-art domain analysis techniques and employs systematic re-engineering of use case models to discover stable abstractions that are anchored in the domain model of the application. At architecture creation time, these stable domain abstractions are mapped onto pointcut interfaces.

We provide algorithmic procedures for use case re-engineering and guidelines for architecture creation. This enables further experimentation with the proposed method and its automation, which in turn improves the ease of adoption. The paper enhances the detailed description of the method by applying it in a running example.

We have applied our method in two case studies, where we observe that the resulting pointcut interfaces can be reused for implementing the composition logic of different aspects without requiring modification to their pointcut signatures. In summary, both case studies provide compelling examples that illustrate non-trivial reuse of the pointcut interfaces that have been created using our method.

Dimitri Van Landuyt, Steven Op de beeck, Eddy Truyen, Wouter Joosen

Aspect of Assembly: From Theory to Performance

Ubiquitous computing systems raise numerous challenges in software engineering. Among these, the dynamic variation of open ubiquitous computing environments requires continuous adaptation of applications. Aspect-Oriented Programming is a well-adapted technique to bring together independence of concerns and extensibility for dynamic adaptation. However, the dynamic adaptation has to occur within a reasonable timeframe, which requires a detailed knowledge of the weaving duration. In this paper, we introduce “Aspect of Assembly”, an aspect-oriented approach to develop services- and components-based applications. Then we study the response time of the adaptation process by decomposing the weaving process. The model of the duration of the adaptation process enables us to define

a priori

constraints to meet temporal requirements for real-world applications. Throughout this paper, we illustrate our work with an actual industrial use case to provide service continuity for a hydrant worker in the water industry.

Jean-Yves Tigli, Stéphane Lavirotte, Gaëtan Rey, Nicolas Ferry, Vincent Hourdin, Sana Fathallah Ben Abdenneji, Christophe Vergoni, Michel Riveill

Dynamic Aspect-Oriented Programming in Java: The HotWave Experience

Dynamic aspect-oriented programming (AOP) enables runtime adaptation of programs. It enables sophisticated, aspect-based software engineering tools, such as adaptive profilers or debuggers, which dynamically modify instrumentation code in response to user interactions. Today, many AOP frameworks for Java, notably AspectJ, focus on aspect weaving at build-time or at load-time, and offer only limited support for program adaptation by (re)weaving aspects at runtime. In this article, we present HotWave, an AOP framework based on AspectJ for standard Java Virtual Machines (JVMs). HotWave supports dynamic (re)weaving of previously loaded classes, and it ensures that all classes loaded in a JVM can be (re)woven, including the classes of the standard Java class library. HotWave features inter-advice communication, a mechanism that allows for efficient data passing between advice that are woven into the same method. We explain HotWave’s programming model and discuss our implementation techniques. As a case study, we present an adaptive, aspect-based profiler that leverages HotWave’s distinguishing features. A performance evaluation shows that HotWave does not introduce any overhead when no aspect is woven and explores the overhead of runtime weaving. While the duration of runtime weaving can be significant, the execution of woven code with HotWave does not incur any extra overhead when compared to the execution of code woven at build-time or at load-time.

Danilo Ansaloni, Walter Binder, Philippe Moret, Alex Villazón

Modularity in Systems Software

Abstracting Context in Event-Based Software

With the recent immersion of advanced mobile devices in the daily lives of millions, pervasive computing is becoming a reality. Developing pervasive software systems is inherently difficult though it requires to deal with heterogeneous infrastructure besides peer-to-peer communication and device mobility. Thus, programming support for such applications must provide loose coupling between different participants, as well as loose coupling between applications and communication protocols. Event-based programming provides an appealing paradigm to decouple participants, however many event-based systems and languages have hardwired communication protocols, which limits their adaptability to heterogeneous deployment environments.

In this paper we address this issue by abstracting the


in which events are created and handled, including protocols used to convey, compose, and consume these events. More precisely, we propose to extend an event-based programming model with

context aspects


for short. We demonstrate the elegant usage of conspects through several examples based on their implementation in EventJava and illustrate how they allow to modularize event-based pervasive software. We also provide a thorough empirical investigation of the performance overheads and benefits of conspects, including the costs of weaving them dynamically. Through empirical evaluations, we assess the benefits of conspects for switching protocols without any changes to the base applications through three case studies with EventJava. The three studies are (1) a tornado monitoring system deployed on different architectures ranging from desktop x86 to embedded LEON3, (2) a mobile social networking suite with protocols for different scenarios, and (3) the introduction of a novel adaptive communication protocol in our mobile social network suite as well as in a novel robotic swarm application.

Adrian Holzer, Lukasz Ziarek, K. R. Jayaram, Patrick Eugster

The Aspect-Aware Design and Implementation of the CiAO Operating-System Family

CiAO is the first operating-system family that has been developed with AOP concepts from the very beginning. By its


design and implementation, CiAO reaches excellent configurability, separation of concerns, and low footprints in the resulting systems that outperform leading commercial implementations. CiAO implements the automotive operating-system standard OSEK/AUTOSAR OS and provides configurability of all fundamental system properties by means of AOP.

We describe the aspect-aware design approach and implementation idioms that led to this efficiency and flexibility. On the example of three larger case studies from CiAO, we demonstrate how AOP can be employed in this respect on different levels of complexity: From highly configurable, yet efficient low-level hardware abstractions over the implementation of central kernel policies up to the decomposition of a complete operating-system specification.

Our results show that by a consequent application of the aspect-aware approach, AOP becomes a promising technology to reach configurability, separation of concerns,


runtime/memory efficiency on all levels of operating-system development.

Daniel Lohmann, Olaf Spinczyk, Wanja Hofer, Wolfgang Schröder-Preikschat

Modularity Constructs in Programming Languages

First-Class Compositions

Defining and Composing Object and Aspect Compositions with First-Class Operators

A considerable amount of research, especially within the OO and AOSD communities, has focused on understanding the potential and limitations of various composition techniques. This has led to a large number of proposals for alternative composition techniques, including many variations of message dispatch, inheritance, and aspect mechanisms. This paper makes the case that there is no single perfect composition technique that suits every situation, since different techniques incur different tradeoffs. The proper composition technique to use depends on the particular design problem and its requirements (such as the required adaptability, reusability, understandability and robustness). However, most programming languages limit the available composition techniques to a very few. To address this, we propose a novel composition model, called


. The model provides

dedicated abstractions

that can be used to express a

wide variety of object composition techniques

(“composition operators”). Examples include various forms of inheritance, delegation, and aspects. The proposed model


objects (with encapsulated state and a message interface) and composition operators; composition operators are specified as first-class citizens. Multiple composition operators can be combined within the same application, and composition operators can even be used to compose new composition operators from existing ones. This opens new possibilities for developing domain-specific composition operators, taxonomies of composition operators, and for reuse and refinement of composition operators. To validate and experiment with the proposed model, we have designed and implemented a simple language,


, that we also use in this paper to show concrete examples.

Lodewijk Bergmans, Wilke Havinga, Mehmet Aksit

Challenges in the Design of the Package Template Mechanism

Package Templates are a mechanism for writing modules meant for reuse, where each module (template) consists of a collection of classes. A package template must be instantiated in a program at compile time to form a set of ordinary classes, and during instantiation, the classes may be adapted by means of renaming, adding attributes (fields and methods), and supplying type parameters. An approach like this naturally gives rise to two distinct dimensions along which classes can be extended. One is the ordinary subclass dimension, while the other is comprised of the ability to adapt classes during instantiations. The latter dimension also allows for a form of static multiple inheritance, in that classes from two or more instantiations may be merged to form a new class. This will be handled entirely at compile time, and the new class will have all the attributes from the merged classes and also the attributes added in the instantiating template. This paper discusses how these two dimensions play together in the different mechanisms that make up the Package Templates approach, and the design considerations involved. The paper also argues that the compromise made in Package Templates between simplicity of the type system on the one hand and expressiveness on the other is, for most purposes, better than similar approaches based on virtual classes.

Eyvind W. Axelsen, Fredrik Sørensen, Stein Krogdahl, Birger Møller-Pedersen


Weitere Informationen

Premium Partner

Neuer Inhalt

BranchenIndex Online

Die B2B-Firmensuche für Industrie und Wirtschaft: Kostenfrei in Firmenprofilen nach Lieferanten, Herstellern, Dienstleistern und Händlern recherchieren.



Best Practices für die Mitarbeiter-Partizipation in der Produktentwicklung

Unternehmen haben das Innovationspotenzial der eigenen Mitarbeiter auch außerhalb der F&E-Abteilung erkannt. Viele Initiativen zur Partizipation scheitern in der Praxis jedoch häufig. Lesen Sie hier  - basierend auf einer qualitativ-explorativen Expertenstudie - mehr über die wesentlichen Problemfelder der mitarbeiterzentrierten Produktentwicklung und profitieren Sie von konkreten Handlungsempfehlungen aus der Praxis.
Jetzt gratis downloaden!