CSC/ECE 517 Fall 2009/wiki2pthelm

Reflection-Oriented Programming

Reflection-Oriented Programming (ROP) is defined as a programming model design with the intent to analyze and improve it's structure, performance or other implementation aspects during runtime, as opposed to compile time. Two key concepts of ROP are meta-information, which is the state of the program at execution time, and metaprogramming, which is the idea that a language can act as it's own reflection. In other words, a language can reflect (modify) itself. More precisely, we define reflection-oriented programming to be a programming style that uses any means available (reflection or otherwise) to extend the meta-information in order to avoid situations in which a local program's requirements leads to non-local rewriting of said program [4].

Reflection vs. ROP

Reflection is the process by which a computer program can observe and modify it's own structure and behavior[1]. It allows an executing program to examine or "introspect" upon itself, and manipulate internal properties of the program[2]. Java, Ruby and .NET are among the most popular reflective languages, however there are many others[3]. Although reflection is the primary concept behind ROP, it does not necessarily preclude the existence of ROP. ROP is a concept of design; as with most designs, it is not necessarily dependent on the implementation. Computational programming can also be used, and does not assume the presence of source code at runtime, something that is essential to the concept of reflection[4].

Meta-Information

Meta-Information, or metadata, is the state of the program at execution time. Put another way, Meta-information is information about information. For example, a if a document is considered to be information, its title, location, and subject are examples of meta-information[5].

Metaprogramming

Metaprogramming introduces the concept of "programs that write programs". Reflection is one type of metaprogramming, and therefore can be considered as an option when attempting to design based on ROP. Metaprograms are written in Metalanguage[6].

Examples

ROP is more than just simple reflection, it is analyzation or improvement at runtime without prior knowledge of source. A good example of this concept is Measuring Computational Expense. To implement such behavior, we need only these definitions:

 define reflective <runtime> (<simple-reflective>)
 slot ticks, init-value: 0;
 end;

 define method atomic (v, outer :: <runtime>)
 update(outer, ticks: add1(outer.ticks))
 end;

 define method compound-initial (outer :: <runtime>)
 update(outer, ticks: add1(outer.ticks))
 end;

</source>

The inherited definition of compound-rest suffices. Now suppose we want to evaluate some expression E without counting its cost. We could use the reify and reflect operations like this:

let r = reify(<runtime>);
let result = E;
reflect(<runtime>, r, result);

Here we capture the expense meta-information before evaluating E and save it as r. After evaluating E, we restore the old meta-information. The result from evaluating E is returned. Of course, any time we want to know the cumulative expense for the program, we can examine reify(<runtime>).ticks[4].

References

[1] Reflection (Computer Science), Wikipedia: http://en.wikipedia.org/wiki/Reflection_%28computer_science%29
[2] Using Java Reflection, Sun: http://java.sun.com/developer/technicalArticles/ALT/Reflection/
[3] List of reflective programming languages and platforms, Wikipedia: http://en.wikipedia.org/wiki/List_of_reflective_programming_languages_and_platforms
[4] An Introduction to Reflection-Oriented Programming, Sobel & Friedman: http://www2.parc.com/csl/groups/sda/projects/reflection96/docs/sobel/sobel.pdf
[5] What is Metainformation?: http://searchoracle.techtarget.com/sDefinition/0,,sid41_gci900705,00.html [6] Metaprogramming, Wikipedia: http://en.wikipedia.org/wiki/Metaprogramming