CSC/ECE 517 Fall 2010/ch3 1c AE: Difference between revisions

From Expertiza_Wiki
Jump to navigation Jump to search
Line 2: Line 2:
== Definition ==
== Definition ==


Reflection is the ''integral'' quality of a program to dynamically manipulate its own state. More specifically, the program can infer and modify itself by making use of the representation of its own state. The state of a program can be its implementation aspects like syntax, semantics, structure, etc. The program acts through its self-accessible state and takes itself as its domain to be acted upon. It contains [http://en.wikipedia.org/wiki/Metadata metadata] and associated operations to manipulate the metadata in runtime. Programming languages that possess this quality are said to be reflective.
Reflection is the ''integral'' quality of a program to dynamically manipulate its own state. More specifically, the program can infer and modify itself by making use of the representation of its own state. The state of a program can be its implementation aspects like syntax, semantics, structure, etc. The program acts through its self-accessible state and takes itself as its domain to be acted upon. Programming languages that possess this quality are said to be reflective.
 
Consider the following simple example


Consider a simple example of Reflection in Java below :
  public class HelloWorld {
  public class HelloWorld {
   public void printName() {
   public void printName() {
       System.out.println(this.getClass().getName());
       System.out.println(this.getClass().getName());
   }
   }
}
}
 
The line
The line
(new HelloWorld()).printName();
(new HelloWorld()).printName();
sends the string HelloWorld to standard out. Now let x be an instance of HelloWorld or one of its subclasses. The line
sends the string 'HelloWorld' to the standard output. Let ''obj'' be an object of HelloWorld or one of its subclasses. When the program reaches the line,
x.printName();
obj.printName();
sends the string naming the class to standard out.
it sends the name of the class to the standard output.
 
This small example is more dramatic than it seems—it contains each of the steps previously mentioned. The printName method examines the object for its class (this.getClass()). In doing so, the decision of what to print is made by delegating to the object's class. The method acts on this decision by printing the returned name. Without being overridden, the printName method behaves differently for each subclass than it does for HelloWorld. The printName method is flexible; it adapts to the class that inherits it, causing the change in behavior.  


This simple example denotes an effective feature. The printName method looks at the object ''obj'' for its class (this.getClass()). It decides what to print by delegating to the object's class in runtime.(i.e.,) the printName method behaves differently for each subclass of HelloWorld. The method is so flexible that it dynamically adapts itself to the class or subclass that inherits it.


Reflection is a valuable language feature to facilitate metaprogramming. A reflective system shall allow programmers to create new metalevel objects and selectively substitute them for an existing part of the running system. Those programs become their own meta language. Thus, reflection is writing programs that manipulate other programs or themselves.
Reflection being an effective language feature enables [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming]. A reflective system would possess the feature of allowing programmers to design, create make use of the objects to act dynamically based on an existing part of the running system. Thus, reflection can also be defined as a feature where a programming language behaves like its own metalanguage.
It contains [http://en.wikipedia.org/wiki/Metadata metadata] and associated operations to manipulate it in runtime.


== Pros and cons of reflection ==
== Pros and cons of reflection ==

Revision as of 01:41, 5 October 2010

Reflective Language Features vs. Reflective Packages

Definition

Reflection is the integral quality of a program to dynamically manipulate its own state. More specifically, the program can infer and modify itself by making use of the representation of its own state. The state of a program can be its implementation aspects like syntax, semantics, structure, etc. The program acts through its self-accessible state and takes itself as its domain to be acted upon. Programming languages that possess this quality are said to be reflective.

Consider a simple example of Reflection in Java below : 

public class HelloWorld {
  public void printName() {
     System.out.println(this.getClass().getName());
  }
}

The line 

(new HelloWorld()).printName();

sends the string 'HelloWorld' to the standard output. Let obj be an object of HelloWorld or one of its subclasses. When the program reaches the line, 

obj.printName();

it sends the name of the class to the standard output.

This simple example denotes an effective feature. The printName method looks at the object obj for its class (this.getClass()). It decides what to print by delegating to the object's class in runtime.(i.e.,) the printName method behaves differently for each subclass of HelloWorld. The method is so flexible that it dynamically adapts itself to the class or subclass that inherits it.

Reflection being an effective language feature enables metaprogramming. A reflective system would possess the feature of allowing programmers to design, create make use of the objects to act dynamically based on an existing part of the running system. Thus, reflection can also be defined as a feature where a programming language behaves like its own metalanguage. It contains metadata and associated operations to manipulate it in runtime.

Pros and cons of reflection

Pros:

  • Simplicity: Generated code is generally more readable and debuggable for developers.
  • Compile time errors: Reflexive procedures fail more often at runtime than during compilation. For instance, changing the object to be loaded will probably cause the generated loading class to throw a compilation error, but the reflexive procedure won't see any difference until the class is encountered during runtime.
  • Without it, our solutions are messy, cumbersome, and fragile. Consider the following scenarios:
  • More flexible

Cons:

  • Maintenance: With passive code generation, changing the objects to be loaded may require the loading class to be updated or regenerated. If the classes are regenerated, then customizations may be lost.
  • Performance Overhead
  • Reflection involves dynamic resolving , certain Java virtual machine 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.

Security Restrictions

  • Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet.

Exposure of Internals

  • Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

Reflective mechanisms

Types of reflection like introspection, intercession, structural & behavioral -- Reflection at Different Stages of the Program Lifecycle

Categorizing Reflection We identify two main criteria to categorize reflective systems. These criteria are when reflection takes place and what may be reflected. If we take what may be reflected as a criterion, we can distinguish: · Introspection: The system structure can be accessed but not modified. If we take Java as an example, with its java.lang.reflect package, we can get information about classes, objets, methods and fields at runtime [4]. · Structural Reflection: The system structure can be dynamically modified. An example of this kind of reflection is the addition of object’s fields. · Computational (Behavioral) Reflection: The system semantics (behavior) can be modified. In the standard Java API v.1.3, the class java.lang.reflect.Proxy has been added [5]; it can be used to modify the dispatching method mechanism, being handled by a proxy object. · A reflective programming language can be capable of changing itself, i.e. changing its own lexical or syntactical specification; that is what we call Linguistic Reflection. As an example, with OpenJava reflective language, the own language can be enhanced to be adapted to specific design patterns [6].


Reflective languages

Languages like LISP, CLOS, etc

Reflection in OO like JAVA

OO-languages (java ‘s reflex package, C#’s, C++’s, etc) Java is so well crafted and its reflection API so carefully constrained that security is controlled simply. By learning when to use reflection and when not to, you will avoid unnecessarily complex code that can often be the result of amateurish use of reflection. In addition, you will learn to evaluate the performance of your designs, thereby ensuring the resulting code satisfies its performance requirements.

This introduction describes reflection, but scarcely reveals its value in this limited space. This article and the next will cover:

Reflection basics Class fundamentals Using methods reflectively


In Java, reflection enables to discover information about the loaded classes: Fields, Methods and constructors Generics information Metadata annotations

It also enables to use these metaobjects to their instances in run time environment. E.g. Method.invoke(Object o, Object… args) With the Java reflection API, you can interrogate an object to get all sorts of information about its class.

References

http://www.springerlink.com/content/6l63883r9224q186/ http://www.cs.indiana.edu/~jsobel/rop.html http://publications.csail.mit.edu/lcs/pubs/pdf/MIT-LCS-TR-272.pdf http://www.di.uniovi.es/ooosws2001/papers/ortin_final.pdf http://download.oracle.com/javase/1.4.2/docs/api/java/lang/reflect/package-summary.html http://scg.unibe.ch/archive/papers/Duca06dMOOSEMODELS2006.pdf file:///C:/Users/Summer/Downloads/10.1.1.158.2012.pdf - good link .. http://www.ub.uni-konstanz.de/kops/volltexte/2002/803/pdf/DissertationEgbertAlthammer.pdf http://www.laputan.org/reflection/ooffrmla.html

Retrieved from "https://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2010/ch3_1c_AE&oldid=36690"