Since version 1.1 of the Java Development Kit, the Java reflective facilities have been successively extended. However, they still prove to be limited. A number of systems (e.g. MetaXa, Guaran a, Kava, Javassist) have addressed this limitation by providing reflective extensions of Java with richer MetaObject Protocols (MOPs). All these extensions provide a particular infrastructure that reflects the commitment of the designer to particular trade-offs between eciency, portability, expressiveness and flexibility. Unfortunately, these trade-offs are not satisfactory for all applications, since different applications may have different needs. This calls for breaking down the building of a reflective extension into different components that can be specialized in order to fit specific needs. We qualify such a reflective extension as open. In this paper, we present Reflex, a prototype open reflective extension of Java. As such, Reflex is a working reflective extension implemented by composing basic building blocks organized following a framework. Reflex comprises the definition of the framework, default generic components and some specialized components.

Dalang is a reflective extension for standard Java. It extends the reflective API to include behavioural reflection as well as introspection. It differs from some other reflective Java implementations in that it requires no change, either to the Java Virtual Machine or the Java system classes. We outline the implementation of Dalang Java, evaluate it, describe our approach to addressing problems with the current implementation and conclude with some open questions that require further research.

Altering the semantics of programs has become of major interest. This is due to the necessity of adapting existing software, for instance to achieve interoperability between o#-the-shelf components. A system allowing such alterations should operate at the bytecode level in order to preserve portability and to be useful for pieces of software whose source code is not available. Furthermore, working at the bytecode level should be done while keeping high-level abstractions so that it can be useful to a wide audience. In this paper, we present Jinline, a tool that operates at load time through bytecode manipulation. Jinline makes it possible to inline a method body before, after, or instead of occurrences of language mechanisms within a method. It provides appropriate high-level abstractions for fine-grained alterations while o#ering a good expressive power and a great ease of use.

As part of the Legion metacomputing project, we have developed a reflective model, the Reflective Graph & Event (RGE) model, for incorporating functionality into applications. In this paper we apply the RGE model to the problem of making applications more robust to failures. RGE encourages system developers to express fault-tolerance algorithms in terms of transformations on the data structures that represent computations--- messages and methods---hence enabling the construction of generic and reusable fault-tolerance components. We illustrate the expressive power of RGE by encapsulating the following fault-tolerance techniques into RGE components: two-phase commit distributed checkpointing, passive replication, pessimistic method logging, and forward recovery. 1 Introduction The advent of fast networks and the wide availability of computing resources make possible the realization of powerful virtual computers, or metasystems, that harness resources on a national or global ...

This paper presents a library of meta-objects suitable for developing distributed systems. The reflective architecture of Guaran'a makes it possible for these meta-objects to be easily combined in order to form complex, dynamically reconfigurable meta-level behavior. We briefly describe the implementation of Guaran'a on Java 1 . Then, we explain how several meta-level services, such as persistence, distribution, replication and atomicity, can be implemented in a transparent, reconfigurable and flexible way. 1 Introduction Computational reflection [29, 34] (henceforth just reflection) has proven to be a useful support mechanism for building distributed systems in a transparent way [1, 2, 7, 12, 14, 19, 18, 25, 28, 30, 32, 36, 37, 35, 39, 40]. Guaran'a [31] is a reflective software architecture that aims at encouraging the reuse of reflective solutions. It provides simple mechanisms for combining multiple meta-objects into the meta-level configuration of a single object. These meta-o...

We analyze how to use the reflective approach to integrate an authorization system into a distributed object-oriented framework. The expected benefits from the reective approach are: more stability of the security layer (i.e., with a more limited number of hidden bugs), better software and development modularity, more reusability, and the possibility to adapt the security module with at most a few changes to other applications. Our analysis is supported by simple and illustrative examples written in Java.

Current implementations of reflective Java extensions typically either require access to source code, or require a modified Java platform. This makes them unsuitable for applying reflection to Commercial-off-the-Shelf (COTS) systems. In order to address this we developed a prototype Java extension Dalang based on class wrapping that worked with compiled code, and was implemented using a standard Java platform. In this paper we evaluate the class wrapper approach, and discuss issues that relate to the transparent application of reflection to COTS systems. This has informed our design of a new version of Dalang called Kava that implements a metaobject protocol through the application of standard byte code transformations. Kava leverages the capabilities of byte code transformation toolkits whilst presenting a high-level abstraction for specifying behavioural changes to Java components.

Abstract. In this paper we present a proposal for safely evolving a software system against run-time changes. This proposal is based on a reflective architecture which provides objects with the ability of dynamically changing their behavior by using their design information. The meta-level system of the proposed architecture supervises the evolution of the software system to be adapted that runs as the base-level system of the reflective architecture. The meta-level system is composed of cooperating components; these components carry out the evolution against sudden and unexpected environmental changes on a reification of the design information (e.g., object models, scenarios and statecharts) of the system to be adapted. The evolution takes place in two steps: first a meta-object, called evolutionary meta-object, plans a possible evolution against the detected event then another meta-object, called consistency checker meta-object validates the feasibility of the proposed plan before really evolving the system. Meta-objects use the system design information to govern the evolution of the base-level system. Moreover, we show our architecture at work on a case study.

this paper, we describe a mechanism based on a metaobject protocol approach that allows dynamic reconfiguration of the behaviour of downloaded applications with no need for access to source code and only minor modifications to the code that launches the application. As an illustration we look at a case study of a real thin client application and how the various security threats it is exposed to in different execution environments can be neutralised. 1. Introduction and Related Work

Developing distributed software systems is a complex activity that involves facing not only the problems of a specific application, but also those typical of distribution. Computational reflection supplies a means to handle different concerns with distinct components and a framework in which the latter can interact smoothly. We propose a reflective software architecture that encapsulates distribution concerns within components that are separated from and independent of those addressing functional concerns. The proposed architecture achieves a thorough management of distribution and in particular provides a means to dynamically adapt allocation policies to the characteristics of application objects, available hosts and changes of the distributed environment. The proposed approach is helpful for achieving the incremental development of easy to evolve software systems. In particular, we discuss the benefits of applying it to existing web and e-commerce applications. 1.