Dynamic AOP (Aspect-Oriented Programming) is receiving growing interests in both the academia and the industry. Since it allows weaving aspects with a program at runtime, it is useful for rapid prototyping and adaptive software. However, the previous implementations of dynamic AOP systems suffered from serious performance penalties. This paper

Abstract. Dynamic Aspect-Oriented Programming (d-AOP) is an important tool to implement adaptation in a wide variety of applications. In particular, large distributed infrastructures, middleware, and pervasive computing environments can greatly benefit from d-AOP to adapt software systems at run time. In this paper, we discuss the design of PROSE, an open source, generic platform for software adaptation. The paper discusses the join-points needed in practical systems together with examples of how they can be used, different implementation strategies and their practical implications. It also describes a highly efficient mechanism to implement stub and advice weaving. 1

Abstract. Modern computing and network environments demand a high degree of adaptability from applications. At run time, an application may have to face many changes: in configuration, in protocols used, in terms of the available resources, etc. Many such changes can only be adequately addressed through dynamic evolution of the software architecture of the application. In this paper, we propose a novel approach to dynamically evolve a software architecture based on run-time aspect oriented programming. In our framework, a system designer/administrator can control the architecture of an application by dynamically inserting and removing code extensions. It is even possible to replace a significant part of the underlying middleware infrastructure without stopping the application. The novelty of this work is that it allows for a much more flexible development strategy as it delegates issues like middleware choice and adherence to an architectural specification to a framework enhanced by dynamic code extensions. 1

Abstract. In this paper, we have briefly analyzed the aspect-oriented approach with respect to the software evolution topic. The aim of this analysis is to highlight the aspect-oriented potentiality for software evolution and its limits. From our analysis, we can state that actual pointcut definition mechanisms are not enough expressive to pick out from design information where software evolution should be applied. We will also give some suggestions about how to improve the pointcut definition mechanism.

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.

Abstract Although dynamic programming environments are in widespread use, only basic runtime composition mechanisms are covered by today’s modeling languages. Thus, it is common in real-world development projects that dynamic compositions are not modeled formally and are consequently hard to use, for example together with the model-driven paradigm where formal models are essential to generate source code. In this paper, we propose an approach based on model transformations between the valid structural and behavioral runtime states that a system can have. We use UML 2.0 class and activity diagrams for specifying the structural and behavioral model states and provide a UML 2.0 meta-model extension for describing the valid model transformations between corresponding model states. 1

doi:10.1016/j.infsof.2006.10.001

In this paper we present a Model for Dynamic Hyperslices which uses a particular Aspect-Oriented (AO) approach – Hyperspaces – for decomposition and reflection as a means for composition of software modules. This model allows for structured, dynamic, incremental change introduction and rollback, thus, supporting run-time evolution yet preserving component modularity. The applicability of the model is illustrated through a schema adaptation scenario. 1.

Assuring that a given code is faithfully executed with defined parameters and constraints on an un-trusted host is an open problem, which is especially important in the context of computing over communications networks. This work evaluates applicability of Aspect-Oriented Programming (AOP) to the problem of remotely authenticating code during execution, which aims at assuring that the software is not maliciously tampered prior to and during execution. A flow of idiosyncratic signatures is continuously generated and associated to data transmitted by a function that is encapsulated in an aspect and whose execution is subordinated to the proper execution of the software being authenticated. The flow of signatures is validated by a remote component.

Adaptive middleware is increasingly being used to provide applications with the ability to adapt to changes such as software evolution, fault tolerance, autonomic behavior, or mobility. It is only by supporting adaptation to such changes that these applications will become truly dependable. In this paper we discuss the use of event based systems as a platform for developing adaptive middleware. Events have the advantage of supporting loosely coupled architectures, which raises the possibility of orthogonally extending applications with the ability to communicate through events. We then use this ability to change the behavior of applications at run time in order to implement the required adaptations. In the paper we briefly describe the mechanisms underlying our approach and show how the resulting system provides a very flexible and powerful platform in a wide range of adaptation scenarios. 1.