We exploit the main similarity between the aspect-oriented programming paradigm and the inter-object, scenario-based approach to specification in order to construct a new way of executing systems based on the latter. Specifically, we show how to compile multi-modal scenario-based specifications, given in the visual language of Live Sequence Charts (LSC), into what we call Scenario Aspects, implemented in AspectJ. Unlike synthesis approaches, which attempt to take the inter-object scenarios and construct intra-object statebased specifications, we follow the ideas behind the LSC play-out algorithm to coordinate the simultaneous monitoring and direct execution of the specified scenarios. We demonstrate our compilation scheme using a small application whose inter-object behaviors are specified using LSCs.

Abstract. Aspect-Oriented Programming (AOP) and Component-Based Software Engineering (CBSE) offer solutions to improve the separation of concerns and to enhance a program structure. If the integration of AOP into CBSE has already been proposed, none of these solutions focus on the application of CBSE principles to AOP. In this paper we propose a twofold integration of AOP and CBSE. We introduce a general model for components and aspects, named Fractal Aspect Component (FAC). FAC decomposes a software system into regular components and aspect components (ACs), where an AC is a regular component that embodies a crosscutting concern. We reify the aspect domain of an AC and the relationship between an AC and a component, called an aspect binding, as first-class runtime entities. This clarifies the architecture of a system where components and aspects coexist. The system can evolve from the design to the execution by adding or removing components, aspects or bindings. 1

Web service technologies accelerate application development by allowing the selection and integration of third-party web services, achieving high modularity, flexibility and configurability. However, current approaches only allow this integration by hard wiring the references to concrete web services into the client applications. Moreover they do not provide any management support, which is fundamental for achieving robustness. We observe the need for the application to be independent of specific services and present the WSML, a management layer placed in between the application and the world of web services. In this paper we identify the requirements for this layer to realise the dynamic selection and integration of services, client-side management of services, and support for rules that govern the selection, integration and composition.

In most component models, a software component consists of a functional part and a controller part. The controller part may be extensible

Abstract. Next-generation middleware must support complex compositions that involve dependencies between multiple components residing in different contexts and locations in the network. In this paper we present DyMAC, an aspect-oriented middleware platform that offers an aspect-component model to support such complex distributed compositions by means of advanced remote pointcuts, transparent remote advice and distributed instantiation scopes for aspects. The remote pointcuts can evaluate on calls and executions of remote method invocations and can also evaluate on the distributed context. The remote advice can be executed transparently in a remote environment while still respecting the full semantics of existing types of advice, including around advice. The component model unifies aspects and components into one entity with one interaction standard. To our knowledge, DyMAC middleware is the first AO middleware platform that distributes the concepts of aspect-oriented composition completely and transparently. 1

The main drawback of all dynamic AOP technologies available today is the rather high performance overhead in comparison to static weaving approaches. In this paper, we propose an approach to improve the performance of both the interception mechanism and the aspect interpreter of a dynamic AOP system. The interception of the base application is optimized by employing the Java HotSwap technology in such a way that only those joinpoints where aspects are applied upon are trapped. When new aspects are added, all corresponding joinpoints are hotswapped for a trapped version. Likewise, when aspects are removed, the corresponding traps are removed, if no other aspect is applicable at the given trap. In order to improve the aspect interpreter, we propose the Jutta system that allows generating and caching a highly optimized code fragment for each joinpoint. This code fragment contains the combined aspectual behavior for the joinpoint at hand. We integrate HotSwap and Jutta in the JAsCo dynamic AOP system and perform extensive benchmarks to evaluate the performance gain of this approach. In addition, the enhanced JAsCo performance is compared to a selection of current state-of-the-art dynamic AOP approaches. These benchmarks indicate that JAsCo, enhanced with HotSwap and Jutta, is able to improve on the current state-of-the-art performance-wise.

Web Service orchestration engines need to be more open to enable the addition of new behaviours into service-based applications. In this paper, we illustrate how, in a BPEL engine with aspect-weaving capabilities, a process-driven application based on the Google Web Service can be dynamically adapted with new behaviours and hot-fixed to meet unforeseen postdeployment requirements. Business processes (the application skeletons) can be enriched with additional features such as debugging, execution monitoring, or an application-specific GUI. Dynamic aspects are also used on the processes themselves to tackle the problem of hot-fixes to long running processes. In this manner, composing a Web Service ’on-the-fly ’ means weaving its choreography interface into the business process. 1.

In this paper we present the mechanisms of lifting and lowering which have been incorporated into recent programing languages. In these languages, lifting and lowering are key features in the integration of static, class based inheritance and instance based composition with delegation. We present the embedding of these concepts into our model Object Teams. We elaborate the details of rules and constraints at the type level, which give to the approach the capability of non-invasively integrating modules with different inheritance structures. These rules setup a new kind of substitutability called translation polymorphism. We show how translation polymorphism integrates with subtype polymorphism. By generalizing over the presented techniques we conclude that lifting opens a second dimension for dispatch in object-oriented languages, be supplementing method dispatch with instance dispatch. 1

Crosscutting concerns are pervasive in embedded software, because of the various constraints imposed by the environment and the stringent QOS requirements on the system. This paper presents a framework for modularizing crosscutting concerns in embedded and distributed software, and automating their composition at the modeling level, for simulation and validation purposes. The proposed approach does not extend the semantics of UML in order to represent aspects. Rather, it dedicates a metamodel to the representation of the composition semantics between aspects and core models. The paper illustrates this approach by presenting a model weaver for SDL statecharts developed at Motorola Labs. Crosscutting behavior is designed with plain SDL statecharts and encapsulated into modules called aspect beans. The weaver looks at the aspect beans and the core SDL statecharts from a perspective that is defined by lightweight extensions to the SDL and UML metamodels. A connector metamodel defines the structure of the aspect-to-core binding definition. Finally, a weaver behavioral metamodel defines composition primitives for specifying weaving strategies.

Mobile devices like PDAs or mobile phones have become widespread. Similarly, network functionality like GSM, Bluetooth, or WLAN has become standard. Nevertheless, not many applications take mobility into account. The reason may be due to the lack of an appropriate platform supporting networking, discovery, activation of new behavior, etc. as it is used in enterprise applications. Hence, in this paper we propose a new dynamic lightweight platform-Jadabs- consisting of a small footprint core layer and a modularized pluggable distributed infrastructure. Jadabs uses the service oriented architecture of OSGi and combines it with a dynamic Aspect Oriented Programming approach. In the paper we show how to extend OSGi with dynamic AOP functionality and made the latter to work in a container. The resulting platform is about 300 KBytes in size.