Aspect-orientation can help to separate concerns in software. One of the goals of this separation is to promote flexibility and configurability; this is especially true when constructing program families (and product-lines). This paper introduces a set of principles that instruct in the creation of flexible, configurable, aspect-oriented systems. We illustrate the principles through their application to a software product-line. The principle of dependency alignment serves as a guideline for structuring concern implementation in modules, eliminating unwarranted dependencies between concerns. The principles of orthogonal and weakly orthogonal aspects instruct in the design of aspects that are included in some system configurations, but not in others. We show how these principles scale to larger systems and larger concern implementations.

Abstract. The emergence of handheld devices associated with wireless technologies has introduced new challenges for middleware. First, mobility is becoming a key characteristic; mobile devices may move around different areas and have to interact with different types of networks and services, and may be exposed to new communication paradigms. Second, the increasing number and diversity of devices, as in particular witnessed in the home environment, lead to the advertisement of supported services according to different service discovery protocols as they come from various manufacturers. Thus, if networked services are advertised with protocols different than those supported by client devices, the latter are unable to discover their environment and are consequently isolated. This paper presents a system based on event-based parsing techniques to provide full service discovery interoperability to any existing middleware. Our system is transparent to applications, which are not aware of the existence of our interoperable system that adapts itself to both its environment across time and its host to offer interoperability anytime anywhere. A prototype implementation of our system is further presented, enabling us to demonstrate that our approach is both lightweight in terms of resource usage and efficient in terms of response time. 1

In this paper, we survey three generation of reflective middleware research carried out at Lancaster University, present experiences gained from this research, and highlight a number of important areas of future research. In particular, we discuss the extension of our reflective middleware ideas in terms of both depth and breadth. The depth extension applies reflective middleware principles to systems that lie beneath the traditional middleware domain: e.g. operating systems and networks. The breadth extension then applies the principles in a much broader range of application areas than those traditionally considered in reflective middleware research. These include reflective middleware for Grid computing and for sentient-object-based real-time control systems. We also briefly consider future work in applying our approach to the development of self-managing systems. Keywords Reflective middleware, multi-model approach, deep middleware, case studies, autonomic computing. 1.

Abstract. Software systems should often propose continuous services and cannot easily be stopped. However, in order to meet new requirements from the user or the marketing, systems should be able to evolve in order to propose new services or modify existing ones. Adapting software systems at runtime is not an easy task and should be realize with attention. In this paper, we present K@RT, our generic and extensible framework for managing dynamic software product lines.

This paper presents a CORBA-compliant middleware architecture that is more flexible and extensible compared to standard CORBA. The portable design of this architecture is easily integrated in any standard CORBA middleware; for this purpose, mainly the handling of object references (IORs) has to be changed. To encapsulate those changes, we introduce the concept of a generic reference manager with portable profile managers. Profile managers are pluggable and in extreme can be downloaded on demand. To illustrate the use of this approach, we present a profile manager implementation for fragmented objects and another one for bridging CORBA to the Jini world. The first profile manager supports truly distributed objects, which allow seamless integration of partitioning, scalability, fault tolerance, end-to-end quality of service, and many more implementation aspects into a distributed object without losing distribution and location transparency. The second profile manager illustrates how our architecture enables fully transparent access from CORBA applications to services on non-CORBA platforms.

With the proliferation of networked devices, today’s multimedia applications operate, as never before, in heterogeneous and dynamic environments. An attractive way to deal with this situation is to make applications self-adaptive (or self-reconfigurable); that is, make them able to observe them-selves and their environment, to detect significant changes and to reconfigure their own behavior in QoS-specific ways. This issue has made the subject of numerous works, especially in the context of multimedia applications. However, several key requirements of adaptivity have not been well addressed such as: the generality to a wide range of applications, the customizability to each application context and the flexibility of reconfiguration mechanisms. We address these aspects in a component-based framework for building self-reconfigurable multimedia applications, named PLASMA. This paper describes the architecture of PLASMA and shows its use through an application use case. Experimental evaluations show that reconfigurations have a low cost, while significantly improving the QoS. 1.

Abstract: State-of-the-art middleware and component technologies force application developers to code platform-specific knowledge into the application components. This means that components for applications that are sensitive to Quality of Service (QoS) in practice become dependent on a specific platform, which is contrary to the idea of component architectures. To properly support such applications, component architectures must be extended to enable exchange of QoS-related information and to manage computing resources effectively to meet those requirements. In this paper, we describe the QuA component architecture. This architecture allows clients to specify logical function (type) and quality requirements for a service and then the platform is responsible for discovering and configuring component implementations that satisfy the requirements, a process we refer to as service planning. To demonstrate the feasibility of QuA, we describe an example scenario where video is streamed to mobile terminals. We explain how QuA performs service planning both during initial configuration of the application and then again during a dynamic reconfiguration, to adapt the application to varying resource availability. 1

Today’s software component technology does not support safe deployment of real-time and multimedia applications. We propose platform managed deployment configuration and dynamic adaptation to enable component middleware to exploit adaptive components. An example of a remote video binding shows how alternate configurations are compared using error prediction functions to select the best for the current deployment environment.

Abstract. The emergence of portable computers and wireless technologies has introduced new challenges for middleware. Mobility brings new requirements and is becoming a key characteristic. Mobile devices may move around different areas and have to interact with different types of networks, services and may be exposed to new communication paradigms. Thus, mobile distributed systems need to dynamically detect and adapt their interaction protocols to interoperate with services available in the environment. As a result, middleware for mobile devices must overcome two heterogeneity issues to provide interoperability in the mobile environment, i.e, heterogeneity of discovery protocols and of interaction protocols between services. Whereas adaptation techniques from reflective middleware are suitable for the latter, it is more problematic for the former if both issues are addressed concurrently. Specifically, reflective mechanisms consume too many resources like bandwidth, memory and CPU, which are limited on the mobile devices. This paper first highlights why current solutions to interoperability fail to realize service discovery protocol interoperability with both high performance and low resource consumption. Second, this paper addresses this open issue by using software architecture concepts enhanced with event-based parsing techniques to provide efficient, lightweight and flexible mechanisms to bring full service discovery interoperability to any existing mobile platform. 1

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 runtime 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 runtime 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. Key words: aspect-oriented middleware, run-time weaving 1