Reflection for Statically Typed Languages

@inproceedings{Guimares1998ReflectionFS,
  title={Reflection for Statically Typed Languages},
  author={Jos{\'e} de Oliveira Guimar{\~a}es},
  booktitle={ECOOP},
  year={1998}
}
An object-oriented language that permits changing the behavior of a class or of a single object is said to support computational reflection. Existing reflective facilities in object-oriented languages are either complex, type unsafe, or have a large performance penalty. We propose a simple, easy-to-understand, and statically typed model that captures much of the functionalities of other reflective facilities. It brings the power of reflection to the world of type safe and efficient languages. 

The Green language

The Green Language Exception System

This paper presents the object-oriented exception system of the Green language, which fully uses the objectoriented programming features, which includes the use of classes, types and subtyping, objects, and inheritance.

The Cyan Language

This is the manual of Cyan, a prototype-based object-oriented language that supports static typing, single inheritance, mixin objects, generic prototypes, and Java-like interfaces.

The Green Language Type System

The Green language type system is presented which supports classes as classless objects and a mechanism to treat basic values as objects and simplifies several other language mechanisms and prevents any infinite regression of metaclasses.

Semantics-directed implementation of method-call interception

A form of method-call interception that allows the programmer to superimpose extra functionality onto method calls at run-time and is based on a naive implementational model, which is subsequently refined to optimise program execution.

The Green language type system

Kava - Using Byte code Rewriting to add Behavioural Reflection to Java

The implementation of Kava is described, the authors' reflective implementation of Java that doesn't require a modified compiler or JVM, can operate on byte code rather than source code and cannot be bypassed, and some of the linguistic issues and technical challenges involved in implementing such a tool on top of a standard JVM.

Using Reflection as a Mechanism for Enforcing Security Policies on Compiled Code

It is shown how behavioural reflection can be used to enforce security policies on compiled code and how Kava, a portable reflective Java implementation, is used to show how to secure a third-party application, and its performance is compared with non-reflective security enforcement.

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

The class wrapper approach is evaluated, and issues that relate to the transparent application of reflection to COTS systems are discussed, which has informed the design of a new version of Dalang called Kava that implements a metaobject protocol through the application of standard byte code transformations.

Reflection patterns in the context of object and component technology

This work introduces the term semantic coupling when two classes are coupled by means of a semantic convention, and in the example A and Object are semantically coupled.

References

SHOWING 1-10 OF 39 REFERENCES

Reflection in Oberon

It is shown how metaprogramming can be used to implement an easy-to-use database interface and a comparison with other metapprogramming systems for statically-typed programming languages is compared.

Computational reflection in class based object-oriented languages

A model of computational reflection where meta-objects are instances of a class META-OBJECT or of one of its subclasses is introduced, showing that it is important to differentiate between structural reflection and computational reflection.

Reflection in Object-Oriented Programming

  • M. Ibrahim
  • Computer Science
    Int. J. Artif. Intell. Tools
  • 1992
The goal of this article is to define reflection and its components, introduce the appropriate terminology, and present briefly some reflective applications in object-oriented systems.

Reflective facilities in Smalltalk-80

The ability to override method lookup can bring much of the power of reflection to languages like Smalltalk-80 at no cost in efficiency.

Pi: a case study in object-oriented programming

How object-oriented programming in C + + has influenced Pi's evolution is explained: lazy construction of an abstract syntax-based tree gave a clean interface to the remainder of Pi, with an efficient and robust implementation.

Environmental acquisition: a new inheritance-like abstraction mechanism

The proposed model for acquisition as a hierarchical abstraction mechanism is a strongly typed model that allows static type checking of programs exploiting this mechanism, and is compared to several other mechanisms including inheritance and delegation, and shows that it is significantly different than these.

Metaclasses are first class: The ObjVlisp Model

This paper shows how an attempt at a uniform and reflective definition resulted in an open-ended system supporting ObjVlisp, which it is proposed to unify Smalltalk classes and their terminal instances.

A metaobject protocol for C++

This paper presents a metaobject protocol (MOP) for C++ that avoids penalties on runtime performance by adopting a new meta-architecture in which the metaobjects control the compilation of programs instead of being active during program execution.

Feature-Oriented Programming: A Fresh Look at Objects

The feature model is presented as an extension of Java and two translations to Java are given, one via inheritance and the other via aggregation, which generalizes inheritance and aggregation.

Designing an Extensible Distributed Language with a Meta-Level Architecture

A variant of C++ is described called Open C++, in which the programmer can alter the implementation of method calls to obtain new language functionalities suitable for the programmer's applications.