From Dalang to Kava - The Evolution of a Reflective Java Extension

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.

[1]  Sheng Liang,et al.  Dynamic class loading in the Java virtual machine , 1998, OOPSLA '98.

[2]  Christophe Dony,et al.  Exception handling and object-oriented programming: towards a synthesis , 1990, OOPSLA/ECOOP '90.

[3]  Pierre Cointe,et al.  Towards a methodology for explicit composition of metaobjects , 1995, OOPSLA.

[4]  Satoshi Matsuoka,et al.  OpenJIT—A Reflective Java JIT Compiler , 2000 .

[5]  José de Oliveira Guimarães,et al.  Reflection for Statically Typed Languages , 1998, ECOOP.

[6]  Satoshi Matsuoka,et al.  Object-oriented concurrent reflective languages can be implemented efficiently , 1992, OOPSLA '92.

[7]  Robert J. Stroud,et al.  Using Metaobject Protocols to Implement Atomic Data Types , 1995, ECOOP.

[8]  Shigeru Chiba,et al.  A metaobject protocol for fault-tolerant CORBA applications , 1998, Proceedings Seventeenth IEEE Symposium on Reliable Distributed Systems (Cat. No.98CB36281).

[9]  Jean-Charles Fabre,et al.  Friends - A Flexible Architecture for Implementing Fault Tolerant and Secure Distributed Applications , 1996, EDCC.

[10]  Jeff McAffer.  Meta-level Programming with CodA , 1995, ECOOP.

[11]  Michiaki Tatsubori,et al.  Programming Support of Design Patterns with Compile-time Reflection , 2000 .

[12]  Ian Welch,et al.  Adaptation of Connectors in Software Architectures , 1998, ECOOP Workshops.

[13]  Jean-Charles Fabre,et al.  Implementing fault tolerant applications using reflective object-oriented programming , 1995 .

[14]  Ira R. Forman,et al.  Reflections on Metaclass Rorgramming in SOM , 1994, OOPSLA.

[15]  Bob Blakley,et al.  Approach to Object Security in Distributed SOM , 1996, IBM Syst. J..

[16]  Robert J. Stroud.  Transparency and reflection in distributed systems , 1993, OPSR.

[17]  Ralph Johnson,et al.  design patterns elements of reusable object oriented software , 2019 .

[18]  Takashi Masuda,et al.  Designing an Extensible Distributed Language with a Meta-Level Architecture , 1993, ECOOP.

[19]  Henry Lieberman,et al.  Using Prototypical Objects to Implement Shared Behavior in Object Oriented Systems , 1986, OOPSLA.

[20]  Thorsten von Eicken,et al.  JRes: a resource accounting interface for Java , 1998, OOPSLA '98.

[21]  Daniel G. Bobrow,et al.  Book review: The Art of the MetaObject Protocol By Gregor Kiczales, Jim des Rivieres, Daniel G. and Bobrow(MIT Press, 1991) , 1991, SGAR.

[22]  Shigeru Chiba,et al.  A metaobject protocol for C++ , 1995, OOPSLA.

[23]  Alan Burns,et al.  MOPping up Exceptions , 1998, ECOOP Workshops.

[24]  Geoff A. Cohen,et al.  Automatic Program Transformation with JOIE , 1998, USENIX Annual Technical Conference.

[25]  Stephen N. Freund,et al.  Adding type parameterization to the Java language , 1997, OOPSLA '97.

[26]  Urs Hölzle,et al.  Binary Component Adaptation , 1997, ECOOP.

[27]  Urs Hölzle,et al.  Integrating Independently-Developed Components in Object-Oriented Languages , 1993, ECOOP.

[28]  Chris Zimmermann.  Advances in Object-Oriented Metalevel Architectures and Reflection , 1996 .