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á, Kava, Javassist) have addressed this limitation by providing reflective extensions of Java with richer MetaObject Protocols (MOPs). All these extensions provide a particular, monolithic, infrastructure that reflects the commitment of the designer to particular trade-offs between efficiency, 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. Reflex can be seen both as a reflective extension of Java and as a first step towards a framework for building such extensions.
Process algebras are proposed as a foundation for aspect-oriented programming. A particular process algebra is described, and programs illustrating its use in programming are given. It is argued that the framework clarifies the notion of equivalence between programs and correctness of aspect-weaving algorithms. The question of which notion of equivalence is most appropriate is discussed from theoretical and practical points of view. An aspect-weaving algorithm is presented and proven correct. A simple imperative aspect-oriented language is presented and translated into the given process algebra.
The advent of interactive shared media spaces has augmented the traditional role of multimedia by providing a natural and intuitive means for interpersonal communication. These shared media-rich environments serve as a natural basis for distributed collaboration through a seamless blend of presentational, conversational and interactive multimedia. This integration, however, presents challenges ranging from the need to support various media types to managing real-time object interaction. This work addresses how to facilitate media space design by employing reflection as a primary design, implementation and management technique within a pattern-based meta-level architecture. Reflection is used to isolate system-level issues such as behavioural coordination from low-level, media-specific computation as well as to facilitate dynamic adaptation of differing behavioural requirements. The architectural framework and underlying topology are illustrated along with the model’s application to a distance education system. Finally, the prototype and its use of the ObjecTime CASE tool are overviewed.
Today, CORBA architecture brings the major industrial solution for achieving the interoperability between distributed software components in heterogeneous environments. While the CORBA project attempts to federate distributed mechanisms within a unique architecture, its internal model is not very flexible and seems not to be suitable for future evolutions. In this paper, we present OpenCorba, a reflective open broker, enabling users to adapt dynamically the representation and the execution policies of the software bus. We first expose the reflective foundations underlying the implementation of OpenCorba: i) metaclasses which provide a better separation of concerns in order to improve the class reuse; ii) a protocol which enables the dynamic changing of metaclass in order to allow run-time adaptation of systems. Based on this reflective environment, OpenCorba enables the adaptability of the internal characteristics of the broker in order to change its run-time behavior (e.g. remote invocation, IDL type checking, IR error handling). OpenCorba gives a clear example of the benefits of reflective middleware.
Platform portability is one of the utmost demanded properties of a system today, due to the diversity of runtime execution environment of wide-area networks, and parallel programs are no exceptions. However, parallel execution environments are VERY diverse, could change dynamically, while performance must be portable as well. As a result, techniques for achieving platform portability are sometimes not appropriate, or could restrict the programming model, e.g., to simple message passing. Instead, we propose the use of reflection for achieving platform portability of parallel programs. As a prototype experiment, a software DSM system called OMPC++ was created which utilizes the compile-time metaprogramming features of OpenC++ 2.5 to generate a message-passing MPC++ code from a SPMD-style, shared-memory C++ program. The translation creates memory management objects on each node to manage the consistency protocols for objects arrays residing on different nodes. Read- and write- barriers are automatically inserted on references to shared objects. The resulting system turned out to be quite easy to construct compared to traditional DSM construction methodologies. We evaluated this system on a PC cluster linked by the Myrinet gigabit network, and resulted in reasonable performance compared to a high-performance SMP.
When a metaprogram automatically creates rules, some created rules are useless because they can never apply. Some metarules, that we call impossibility metarules, are used to remove useless rules. Some of these metarules are general and apply to any generated program. Some are domain specific metarules. In this paper, we show how dynamic metaprogramming can be used to create domain specific impossibility metarules. Applying metaprogramming to impossibility metaprogramming avoids writing specific metaprogram for each domain metaprogramming is applied to. Our meta-metaprograms have been used to write metaprograms that write search rules for different games and planning domains. They write programs that write selective and efficient search programs.
Every role is designed for a specific collaboration, so it can work rightly in the expected context. For example, according to the two role models presented in (a) of Fig. 1, the role Employer is modeled to associate with the role Employee by one-or-more multiplicity, so all of its instances must not be permitted to be handled without an associated instance of the role Employee.
Designers are often unsuccessful in designing for change using traditional modularity techniques. A complementary modularity technique called information transparency can improve a designer's ability to simplify changes by exposing the interdependence of dispersed program elements that must be changed together for correctness. Information transparency represents modules via similarity and architecture, rather than locality and abstraction.With these, a programmer can create locality with a software tool, easing change in much the same way as traditional modularity. When combined with information hiding, then, more complex module structures can be represented. Information transparency techniques include naming conventions, formatting style, and ordering of code in a file. Transparency can be increased by better matching tool capabilities and programming style. We discuss applications of information transparency and introduce design principles for software designers and tool designers.
In this paper, we present a method for systematic synthesis of middleware based on the meta-level requirements of the application that stands on top of it. Particular attention is paid to the ability to accommodate evolving requirements of a running application.
A number of approaches have been proposed to achieve separation of concerns. Although all these approaches form suitable candidates for separating cross-cutting concerns in a system, one approach can be more suitable for implementing certain types of concerns as compared to the others. This paper proposes a hybrid approach to separation of concerns. The approach is based on using the most suitable approach for implementing each cross-cutting concern in a system. The discussion is based on using three different approaches: composition filters, adaptive programming and aspect-oriented programming to implement cross-cutting concerns in SADES, a customisable and extensible object database evolution system.
This short paper presents A-TOS (Aspect-TOS (TCL Object System)), an aspect-oriented framework that allows the programmer to define its own specialized aspects and to weave or remove them at runtime. Since A-TOS is based on a configurable and semantic-reliable object-wrapping technique, it is able to solve what we call the Aspect-Composition Issue (ACI), i.e., to detect and solve many semantic conflicts when weaving the different aspects together.
The UML shares with reflective architectures the idea that self-definition of languages and systems is a key principle for building and maintaining complex systems. The UML is now defined by a four-layer metalevel structure, enabling a flexible and extensible definition of models by metamodels, and even a self-description of the meta-metamodel (the MOF). This metalevel dimension of UML is currently restricted to structural reflection. But recently a new extension to the UML, called the Action Semantics (AS), has been proposed for standardization to the OMG. This paper explores how this proposed extension brings a behavioural reflection dimension to the UML. Indeed, we show that it is not only possible but quite effective to use the AS for manipulating UMLmo dels (including the AS metamodel). Besides elegant conceptual achievements, such as a metacircular definition of the AS, reflective modeling with the AS leverages on the UMLmetalev el architecture to provide the benefits of a reflective approach, in terms of separation of concerns, within a mainstream industrial context. A complete model can now be built as an ideal model representing the core concepts in the application, to which non-functional requirements are integrated as fully traceable transformations over this ideal model. For example, this approach paves the way for powerful UML-defined semantics-based model transformations such as refactoring, aspect weaving, application of design patterns or round-trip engineering.
The reflection in Java provides generality to Java code at the cost of severe overhead at run-time. Partial evaluation have been used to remove reflection from the runtime code, but the feasibility of it for Java programs in general is still an open research issue. We present a partial evaluation technique that can remove reflection in Java programs using type information. We also present a mechanism to deal with exceptions in partial evaluation of Java programs that enables the partial evaluation process fully automatic.
We describe our experience with SILK, a Scheme dialect written in Java. SILK grazes symbiotically on Java's reflective layer, enriching itself with Java's classes and their behavior. This is done with three procedures. (constructor) and (method) provide access to a specific Java constructor or method respectively. (import) allows the entire behavior of a class to be imported easily. (import) converts Java methods into generic functions that take methods written in Java or Scheme. In return, SILK provides Java applications with an interactive development and debugging environment that can be used to develop graphical applications from the convenience of your web browser. Also, because SILK has introspective access into Java, it can also be used for compile time metaobject scripting. For example, it can generate a new class using an old one as a template.
Software architectures have recently emerged as a level of design concerned with specifying the overall structure of a system. Traditionally, software architectures only provide static descriptions of the participants and interaction structures in a system. Dynamic software architectures, however, can be reconfigured at runtime and therefore provide support for building dynamically adaptable applications. Software architectures can be specified using architectural reflection. In this paper we introduce an architecture meta-model that realises a dynamic software architecture. The architecture meta-model reifies the configuration graph of the architecture and is automatically generated from our component definitions and implementation language source-code. We show how graph transformations that re-write the architecture's configuration graph can be implemented as reflective programs, called adaptation contracts. Adaptation contracts are written in a separate programming language, thus cleanly separating the adaptation code from the computational code. Adaptation contracts can even be replaced at run-time. They are deployed in a run-time meta-level architecture that addresses issues of system safety, integrity and overhead during graph transformation. The paper also describes a prototype implementation of our model called K-Components.
Fully reflective systems have the notion of a control transfer from base-level code to meta-level code in order to change the behavior of the base-level system. There exist various opinions on how the programming model of a meta architecture has to look like. A common necessity of all models and systems is the need to intercept messages and operations, such as the creation of objects. We analyze the trade-offs of various message interception mechanisms for Java. We show their impact on the meta-level programming model and performance. We demonstrate that it is beneficial to integrate the interception mechanism with the virtual machine and the just-in-time compiler.
Middleware is playing an increasingly central role in the design of modern computer systems and will, we believe, continue to enjoy this prominence in the future. There is, however, a demonstrable need for more openness and flexibility in middleware [1]. We believe strongly that reflective middleware is the right technology to meet these demands. Indeed, there is strong evidence that such platforms are not only significantly more configurable and reconfigurable than conventional platforms, but that they offer better support for software evolution generally [2]. The main goals of OpenORB v2, the system discussed in this extended abstract, are to address what we perceive as the most pressing shortcomings of current reflective middleware platforms. First, performance: in the worst case, this needs to be on a par with that of conventional platforms, and in the best case (e.g. in cut-down configurations) it should be significantly better. Second, integrity: while permitting maximal reconfigurability, it should be possible to control and constrain reconfigurations so that damaging changes are discouraged and/ or disallowed.
In order to be able to adapt the non-functional properties of distributed applications, we designed and implemented the JavaPod platform. Then, in order to evaluate this platform, we used it to reimplement Baghera, a "real-world", distributed application for computer-aided learning of elementary geometry.After a brief description of Baghera and of our platform, this article presents how we implemented and associated with Baghera components several non-functional properties. These experiments show that our platform can be extended with new non-functional properties, and that these properties can be composed and associated with applications at deployment time, without changing the application's code. Finally this article shows that the new composition mechanism used in JavaPod is more adapted than existing ones to compose non-functional properties.
