CSC/ECE 517 Fall 2012/ch1 1w5 su

From PG_Wiki
Jump to: navigation, search

Reflective Language Features vs Reflective Packages[1]

Reflection is the ability of a computer program to examine and modify the structure and behavior (specifically the values, meta-data, properties and functions) of an object at runtime.[2]

The concept of reflection is best understood by reaching back to the study of self-awareness in artificial intelligence: "Here I am walking down the street in the rain. Since I'm starting to get drenched, I should open my umbrella." This thought fragment reveals a self-awareness of behavior and state, one that leads to a change in that selfsame behavior and state. It would be desirable for computations to avail themselves of these reflective capabilities, examining themselves in order to make use of meta-level information in decisions about what to do next. [3]

A reflective language is a programming language that has been architected to allow reflection. This means the language was constructed to 'reason' effectively and consequentially about its own inference process. Examples in which reflection is a part of the language itself : Ruby, PHP, Python

Languages that are not reflective can incorporate some of the features of reflection by using reflective packages. Examples of languages which require a package to avail reflection : Java, C#


Brief History of Reflection

Year Development [4]
Jun 1976 Origin of Reflective Programming:

The idea of reflection came to Brian Smith at the Xerox Palo Alto Research Center. Smith was working on Knowledge Representation Language(KRL) and as an exercise to learn the language, he worked on a project to represent KRL in KRL. He reasoned that this would be a good way to learn the language since he had to both use and mention the language. He worked on it long enough to become intrigued with the thought of building a system that was self-descriptive. In the five years since, Smith worked on initial versions of such a language, which he called MANTIQ.

1982 Brian Cantwell Smith writes a doctoral dissertation at MIT introducing the notion of computational reflection. 3-LISP is the first official programming language to use reflection. [5]
1983 Smalltalk v1.0 has 75% of the standard Reflection command language. [6]
1984 The Interim 3-LISP Reference Manual is published, co authored by Brian Cantwell Smith. [7]
1987 Smalltalk v2.0 adds the rest of the Reflection. [6]
1987-89 Perl [8]
Oct 1996 Visual J++ and C# has reflections. Python v1.4 [9]
Feb 1997 Java Reflections (JDK v1.1) [10]
Feb 1998 Python v1.5 makes it easier for reflective programming. [9]
Jul 2004 PHP v5.0 [11]

Techniques used by reflective systems

There are two techniques used by reflective systems:

Introspection is about discovering the component interfaces and relationships among them whereas intercession is about the possibility of re-configuring the architecture at runtime.


Introspection is what allows the program to "know" information about itself. This can include an object knowing what kind of object it is, and what methods it has.
Example (Ruby):

class Sample
  #empty class
samp =
samp.class   # outputs the name of the class
samp.methods # list the methods that Sample and it's superclass,'Object', has


Intercession includes calling methods dynamically, which means that the actual method that is called on an object is decided when the program is running, and not when the program is compiled.
Example (Ruby):

class Sample      #defines two methods that print different numbers depending on which method is called
  def printOne
    puts 1
  def printTwo
    puts 2
samp = #Create an instance of the Sample class
samp.send(option) #printTwo method is called
samp.send(option) #printOne method is called

Without reflection, calls to these methods could not be changed at runtime. However, reflection allows the method calls to depend on string values that do not have to be initialized until runtime as seen in the above code.

Some of the more dynamic intercessive features that reflection gives a programming language are possible because of the dynamic nature of the language. For example, in Ruby, a method can be added to an object that has already been instanced.

samp =
def samp.anothermethod            #will create a method on the instance of Sample
  puts "This is a new method"

If another Sample object is created, this new object will not have access to the anothermethod method because that method was only added to a specific instance of the Sample class. In Java, methods cannot be created on existing objects (because it is a statically typed language), so this kind of reflection is not possible.

Types of Reflection

Parallel to the concepts of introspection and intercession, there are two types of reflection:

Behavioral reflection is the ability to intercept an operation such as method invocation and alter the behavior of that operation. If an operation is intercepted, the runtime system calls a method on a meta-object for notifying it of that event. The developers can define their own version of the meta-object so that the meta-object can execute the intercepted operation with customized semantics.

However, behavioral reflection only provides the ability to alter the behavior of operation; it does not provide the ability to alter data structures used by the program statically fixed at compile time. The latter, called structural reflection, allows a program to change, for example, the definition of a class, function or record on demand. [12]

Reflective Languages Features VS Reflective Packages

In a reflective language,

In a language with a reflective package,

Following are a few examples of reflection in different languages, providing a clear understanding of the distinction between reflective language feature versus reflective package. The examples have code snippet(s) with the class declaration, and also code to fetch the class information (the class name, its instance variables, its methods, method arguments and to check if an object is an instance of a class) using reflections. Output for the corresponding lines is displayed in a tabular format.

Reflective Languages Features


The ability to introspect is an inherent feature of Ruby. [13]

The Object class (ancestor of every class) provides Object#instance_of? and Object#kind_of? methods for checking the instance's class. The latter returns true when the particular instance the message was sent to is an instance of a descendant of the class in question.

class MyParent
  def initialize
  def foo
    #do stuff
class MyChild < MyParent
  def initialize
    @var = 0
  def bar(arg1,arg2)
    #do stuff
Script Output
child = #<MyChild:0x27d1a78 @var=0>
child.instance_of? MyChild true
child.kind_of? MyParent true
child.class MyChild
child.methods [:bar,:foo, :nil?, :==.....#other functions inherited from Object, Kernel and BasicObject]
child.class.instance_method(:bar) [:arg1,:arg2]


PHP 5 comes with a complete reflection API that adds the ability to reverse-engineer classes, interfaces, functions, methods and extensions. There is no installation needed to use these functions; they are part of the PHP core. PHP uses ReflectionClass class to report information about a class. [14]

    class myparent {
        public function foo($bar) {
            // do stuff

    class mychild extends myparent {
        public $val;

        private function bar(myparent &$baz) {
            // do stuff

        public function __construct($val) {
            $this->val = $val;

    $child = new mychild('hello world');

Script Output
$reflect = new ReflectionClass('mychild');
if ($reflect->isInstance($child)) {
   echo "child object is an instance of the class 'mychild'\n";
echo "\nPrinting all methods in the 'mychild' class:\n";
echo "============================================\n";
foreach( $reflect->getMethods() as $reflectmethod) {
   echo "  { $reflectmethod->getName()}()\n";
   echo "  ", str_repeat("-", strlen($reflectmethod->getName()) + 2), "\n";
   foreach( $reflectmethod->getParameters()  as $num => $param) {
       echo "    Param $num: \$", $param->getName() </span>, "\n";
       echo "      Passed by reference: ", (int)$param->isPassedByReference(), "\n";
       echo "      Can be null: ", (int)$param->allowsNull(), "\n";
       echo "      Class type: ";
       if ($param->getClass()) {
           echo  $param->getClass()->getName();
       } else {
           echo "N/A";
       echo "\n\n";
child object is an instance of the class 'mychild'

Printing all methods in the 'mychild' class:
    Param 0: $baz
      Passed by reference: 1
      Can be null: 0
      Class type: myparent

    Param 0: $val
      Passed by reference: 0
      Can be null: 1
      Class type: N/A

    Param 0: $bar
      Passed by reference: 0
      Can be null: 1
      Class type: N/A


Python provides a way to examine the contents of modules (and other objects) using the built-in dir() function. Also, the built-in functions isinstance and hasattr can be used to determine what an object is and what an object does respectively. [15]

 class Person(object):
     """Person class."""
     def __init__(self, name, age): = name
         self.age = age
     def intro(self):
         """Return an introduction."""
         return "Hello, my name is %s and I'm %s." % (, self.age)
Script Output
bob = Person("Robert", 35) # Create a Person instance <none>
joe = Person("Joseph", 17) # Create another <none> = "football" # Assign a new attribute to one instance <none>
isinstance(bob, Person) True
hasattr(joe, 'intro') True
dir(Person) # Attributes of the Person class
['__class__', '__delattr__', '__dict__', '__doc__', '__getattribute__',
'__hash__', '__init__', '__module__', '__new__', '__reduce__', '__repr__',
'__setattr__', '__str__', '__weakref__', 'intro']
dir(bob) # Attributes of bob
['__class__', '__delattr__', '__dict__', '__doc__', '__getattribute__',
'__hash__', '__init__', '__module__', '__new__', '__reduce__', '__repr__',
'__setattr__', '__str__', '__weakref__', 'age', 'intro', 'name']
dir(joe) # Note that joe has an additional attribute
['__class__', '__delattr__', '__dict__', '__doc__', '__getattribute__',
'__hash__', '__init__', '__module__', '__new__', '__reduce__', '__repr__',
'__setattr__', '__str__', '__weakref__', 'age', 'intro', 'name', 'sport']
bob.intro() # Calling bob's intro method "Hello, my name is Robert and I'm 35."
dir(bob.intro) # Attributes of the intro method
['__call__', '__class__', '__cmp__', '__delattr__', '__doc__', '__get__',
'__getattribute__', '__hash__', '__init__', '__new__', '__reduce__',
'__repr__', '__setattr__', '__str__', 'im_class', 'im_func', 'im_self']


Introspection can be achieved using the ref and isa functions in Perl.

package MyParent;
sub new {
    my $class = shift;
    return bless {}, $class;
package MyClass;
use base 'MyParent';
Script Output
package main;
my $par= MyParent->new();
my $child = MyChild->new();
print "This is the parent.\n" if ref $par eq 'MyParent'; This is the parent.
print "child is of kind MyParent.\n" if $child->isa('MyParent'); child is of kind MyParent.

Reflective Packages


Package java.lang.reflect provides classes and interfaces for obtaining reflective information about classes and objects allowing programmatic access to information about the fields, methods and constructors of loaded classes, and the use of reflected fields, methods, and constructors to operate on their underlying counterparts, within security restrictions.

public class Base
  public Base
  public void Foo(int _arg1,int _arg2)
  //Foo Logic
public class Derived extends Base
  int m_value;
  public Derived
    m_value = 0;
  public void Bar(int _arg1, String _arg2)
    //Bar Logic
Code Output
import java.lang.reflect;
public static void main(String[] args)
  Derived obj = new Derived();
  Boolean instance = Derived.class.isInstance(obj);
  Boolean isParent = Base.class.isAssignableFrom(obj.getClass);
  Method[] methods = obj.getMethods();
  String className = obj.getClass().getName();	
  //to get parameter types for Bar
  //technique 1
  for(int i =0 ; i<methods.length;i++) 
        Type[] parameterTypes = methods[i].getTypeParameters();	
  Type[] parameterTypes = obj.
      getMethod("Bar", int.class, String.class).getTypeParameters();	

[Foo,Bar] (note : only public methods are returned)




In C# to use reflections [16], the System.Reflection namespace must be included. It contains classes and interfaces that provide a managed view of loaded types, methods, and fields, with the ability to dynamically create and invoke types.

       public class Base
           public Base()
           public void Foo(int a)
               int m = a;
       public class Derived :  Base
           public int m;
           public Derived()
               m = 0;
           public void Bar(int b, string c)
Code Output
using System.Reflection;
Derived obj = new Derived();
Console.WriteLine("Classname - " + obj.GetType().Name);              
Console.WriteLine("Instance of derived - " + typeof(Derived).IsInstanceOfType(obj));
Console.WriteLine("Does inherit from base ?" + typeof(Base).IsAssignableFrom(obj.GetType()));
MethodInfo[] methods = obj.GetType().GetMethods(BindingFlags.Public | 
 BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly);
for (int i = 0; i < methods.Length; i++)
     MethodInfo myMethodInfo = (MethodInfo)methods[i];
     Console.WriteLine("\nThe name of the method is {0}.", myMethodInfo.Name); 
MethodInfo mInfo = obj.GetType().GetMethod("Bar");
Console.WriteLine("Found method: {0}", mInfo);
Classname - Derived
Instance of derived - true
Does inherit from base? true
The name of the method is Bar
Found method: Bar(int32, System.string)


Moose [17] provides a powerful introspection API, that lets you add attributes and methods, apply roles, and much more.

package User;
 use Moose;
 my $meta = __PACKAGE__->meta;
 for my $attr ( $meta->get_all_attributes ) {
     print $attr->name, "\n";
 for my $method ( $meta->get_all_methods ) {
     print $method->fully_qualified_name, "\n";

Advantages and Disadvantages


  1. Access to Metadata and Ability to Manipulate Classes: You can access the metadata of classes and methods, get the annotations and analyze them. Writing direct code is based on specific class details (like interface, method or field names) known at compile-time. If we need to write code that depends on class details known only at runtime, then reflection comes handy.
  2. Creating Adaptable and Flexible Solutions: Because of its dynamic nature, reflection is useful for creating adaptable and flexible software that is often not possible with direct code. Theoretically, it is well known that reflection can help add more dynamism and flexibility to frameworks and design patterns.
  3. Writing Tools that Require Implementation Details: Many of the developer tools need access to internal or implementation details of the code For example, an intelligent text editor can query a class using reflection and get details about its implementation, which can be very helpful. When user types in an object name and a ‘.’ to access a member, the text editor can pop with a list box with list of accessible members (obtained using reflection) that the programmer can select from.
  4. Signature-Based Polymorphism: Java and C# programmers are familiar with polymorphism based on interface inheritance. Reflection provides an alternative where we can invoke methods having same signature, from different classes not have a common interface (which is required in interface based polymorphism).



  1. Violates Object-Oriented Principles: Use of reflection essentially exposes much of implementation details – such as the methods, fields, accessibility and other metadata – of the class used. This violates the objectives of object oriented programming like abstraction and information hiding, where only the relevant higher level details of the class that the programmer needs to know are exposed to the users and low-level implementation details are hidden.
  2. Security: Reflection allows code to perform some operations that would be illegal in non-reflective code, such as accessing private fields and methods which could potentially be a security concern.
  3. Performance Overhead: Reflection requires dynamic resolution due to which certain optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts, and should be avoided in sections of code which are called frequently in performance-sensitive applications.
  4. Static type check: Using reflection lets you bypass the static type checking. This mean type errors will be caught at runtime instead of compile time.
  5. Exception handling: The static checks done by a compiler in static code have to be done by the programmers using exception handling code when reflections are used. Providing more exception handling code increases implementation effort and also adds significantly to the code length making it less readable.


Reflection allows the creation of more versatile and flexible programs through both introspective and intercessive features. These features include the ability for a program to know about itself, and to act on that information. Reflections can come in handy in implementing tools or technologies that involve the use of implementation details. But like any other language feature, reflection can be misused and should be used only when necessary.


  1. Updated the page: CSC/ECE_517_Fall_2010/ch1_1c_JF
  2. Reflection on Wikipedia
  3. An Introduction to Reflection-Oriented Programming - J.M. Sobel , Daniel P. Friedman - 1996
  4. Java Reflection - Ken Cooney
  5. Brian Cantwell Smith, "Procedural Reflection in Programming Languages", Massachusetts Institute of Technology, Feb 1982
  6. Infoworld July 27, 1987, News Briefs. P31,32
  7. Brian Cantwell Smith, Jim des Rivières. "Interim 3-LISP Reference Manual". Xerox PARC. 1984
  8. The Timeline of Perl and its Culture
  9. A. Andersen, A note on reflection in Python 1.5, Distributed Multimedia Research Group Report, MPG-98-05, Lancaster University, UK, March 1998
  10. Joe Weber. Special Edition Using Java 1.1, Third Edition.
  11. Reflection in php
  13. Ruby Reflections.
  14. PHP Reflections
  15. Python Reflections
  16. C# Reflections
  17. Moose Reflections

See Also

Examples of Introspection

Even more Examples of Introspection

Using Java Reflection

D. Bobrow, R. Gabriel, and J. White. CLOS in context—the shape of the design space. In A. Paepcke, editor, Object-Oriented Programming: the CLOS perspective, pages 29–61. MIT Press, 1993.

Sobel, J.M. and Daniel P. Friedman 1996 Reflection-Oriented Programming Indiana University, Bloomington, IN

Anh Nguyen-tuong and Steve J. Chapin and Andrew S. Grimshaw and Charlie Viles. 1998 Using Reflection for Flexibility and Extensibility in a Metacomputing Environment ORNL Central Research Library, Northrop Grumman Information Technologies Alexandria, VA

Thomas, Dave with Chad Fowler and Andy Hunt. Programming Ruby. North Carolina: The Pragmatic Bookshelf, 2005.

McHale, Ciaran 2008 Java Reflection Explained Simply

Ducasse, Stéphane and Rmod Inria Lille Nord and Marcus Denker and Adrian Lienhard 2009 Evolving a Reflective Language Lessons Learned from Implementing Traits European Smalltalk User Group

Personal tools