Towards a Reflective Component-based Middleware Architecture Nikos Parlavantzas, Geoff Coulson, Mike Clarke and Gordon Blair Distributed Multimedia Research Group, Computing Department, Lancaster University, Bailrigg, Lancaster LA1 4YR, UK. {parlavan, geoff, mwc, gordon}@comp.lancs.ac.uk Abstract Current middleware is inflexible and monolithic and fails to address emerging needs for adaptation to changing requirements. As a solution, we propose that middleware be built as a reflective and component-based system. Our architecture is based on component frameworks and component framework-specific meta-interfaces and leads to extensible, composable, and dynamically flexible middleware systems. Moreover, it addresses the critical problem of ensuring integrity in the face of dynamic adaptation. A pilot implementation, based on an efficient, lightweight component model, is currently underway. 1. Introduction It is now well established that middleware platforms must accommodate a wide variety of requirements imposed by both applications and underlying environments. Moreover, they must be able to absorb both design-time and run-time changes in these requirements. Unfortunately, the current generation of middleware is, to a large extent, monolithic and inflexible and, thus, fails to address these needs. There have been some efforts to introduce reconfigurability, but these are typically piecemeal, ad-hoc, and usually involve selection between a fixed number of options. In our opinion, a more systematic and principled solution is needed. To this end, we have previously carried out research on a reflective middleware architecture [2,3,4]. The main principles of this architecture are the association of a meta-space per object (as opposed to, for example, per- class meta-interfaces) and the decomposition of the meta- space in multiple, orthogonal meta-models. The research has resulted in a pilot implementation of the architecture in Python which has focused primarily on achieving as great a degree of flexibility as possible. The work described in this paper represents an evolution of our previous work, based on component technology, which is additionally focused on efficient implementation and on ensuring integrity in the face of dynamic adaptation. Component technology has recently emerged as a promising approach for building highly adaptable software systems. This adaptability is a result of the capability to change configurations by adding, removing and replacing their constituent components (importantly, components come in a binary form and thus can be dynamically deployed within an address space). Additional benefits of component technology include reusability, dynamic extensibility, understandability, and reduced development costs [19]. Currently, component technology is applied only at the application level on top of middleware infrastructures, which hide distribution and other non- functional concerns from component developers. However, in order to address the need for adaptability, we believe that middleware itself should be built according to a component-based architecture. Furthermore, we believe that the resulting component- based middleware should be reflective to help facilitate and manage run-time changes in component configurations. In other words, it should incorporate structures representing aspects of itself and offer meta- interfaces for inspecting and adapting these reified aspects. Unfortunately, designing these meta-interfaces is not easy. We have found that the ‘obvious’ solution of exposing the whole middleware implementation as a graph of component instances and allowing arbitrary manipulations is not acceptable for reasons of robustness. Maintaining integrity is a critical issue arising in the construction of all reflective systems. Our proposed approach to addressing this issue is through the notion of component frameworks. This paper discusses our proposed architecture for middleware which employs both reflection and component frameworks. This paper is structured as follows. Section 2 outlines the basic principles underlying our architecture. Section 3 then describes our component model in some detail. Following this, Section 4 outlines the component- based middleware architecture itself, and Section 5 discusses our implementation work to date. Finally, Section 6 discusses some related work, and Section 7 presents concluding remarks.