Introduction

Both Ruby and Java allow the use of an eval() type of function which can be used to dynamically interpret code at run-time.

Pros and cons

As with any feature, Ruby's eval() comes with benefits and potential disadvantages.

Pros

eval() provides some powerful advantages to the programmer, including the ability to write programs that can compose (and execute) arbitrary new code at run time.

Dynamic Metaprogramming Capability

The capability to generate new code at run time provides the application developer the option of having the program dyamically extend itself, leading to a dynamic Metaprogramming capability.

Flexibilility

Ruby's eval() capability permits Ruby developers to create flexible applications able to rewrite and extend themselves on the fly. Even a statically typed, compiled language such as Java can take advantage of this flexibility through the BeanShell addon.

Ease of Use

As demonstrated below, eval() makes it easy to extend the functionality of programs at run time, to adapt to new requirements or changes in the underlying data model. Because the interpreter or virtual machine instance retains state across invocations during the instance lifetime, the current process, and all new code passed to eval(), are available to the application, easing the burden on the programmer.

Cons

The power and flexibility comes with the price of some performance and security.

Performance

eval() must parse the code and compile it at run time, and in view of this, the performance implications of interpreted languages apply. The speed penalty may not be worth the flexibility of generating new code at run time in some cases. In addition, adding new code will increase the memory required by the application, and the increased load on the processor may have to be considered for non-trivial run time evaluation.

Security

If eval() is used to generate and invoke code created with arbitrary data received from another, less trusted application, extreme care should be used. Allowing an untrusted application to modify a running program is an enormous security risk. It is difficult to imagine circumstances in which eval() should be used in safety critical applications.

Ruby Example

The eval function can be used for dynamically calling functions. For example in Ruby:

  # Create an array of functions
  functions = ['function1','function2','function3']
  
  # Define functions
  def function1()
      puts "inside function1"
  end 

  def function2()
     puts "inside function2"
  end 

  def function3()
     puts "inside function3"
  end 

  # Factory Pattern
  def CallFunction(functionname)
     eval functionname
  end 

  #Results
  irb(main):039:0> CallFunction functions[0]
  inside function1
  => nil
  irb(main):040:0> CallFunction functions[1]
  inside function2
  => nil
  irb(main):041:0> CallFunction functions[2]
  inside function3
  => nil

What makes this so powerful is that the function names in the array can be stored in an array or someplace else like a database or xml file.

Taking this one step further we can store the function definition in an array as well:

  #Create an array for the function name and function definition
  function1 = ['function4'] # We could have more then one
  function2 =['def function4 ()  puts "inside function4" end'] # We could have more then one
  
  # Dynamically create/define function
  eval function2[0]
  
  # Dynamically call the the name of the function
  irb(main):060:0> eval function1[0]
  inside function4
  => nil

So, in this example function4() is created dynamically at run-time. This allows us to store parts of the code as data and to create functions when needed. An application written using eval to dynamically generate functions would allow new functions to be added easily. For example, you could create new definitions of functions and insert them into a database table.

Java Example

The base Java language does not have a direct equivalent to Ruby's eval() facility, because Java is a compiled, statically typed language. However, Java environments can use a facility similar to Ruby's eval() through the BeanShell addon, available from http://beanshell.org/bsh-2.0b4.jar.

Because a Java program can create instances of the BeanShell interpreter, and submit arbitrary Java code to the interpreter for evaluation at run time, Java developers can take advantage of BeanShell's eval facility to create programs that create and execute new programs on the fly.

A BeanShell interpreter object retains state across invocations, so that previously evaluated classes, objects, methods, and variables are available to classes, objects, methods, and variables that are evaluated later in the lifetime of each BeanShell instance.

BeanShell is distributed as an executable jar, which when run, provides a BeanShell workspace in which Java code can be developed in a command line environment. To view the output from the code below in the BeanShell Workspace, the user must invoke "File->Capture System in/out/err" from the "Bsh Workspace" menu, before running the code.

  import java.lang.StringBuffer;  // needed for mutable strings

  // Create an array for function names
  StringBuffer[] functions = new StringBuffer[4];

  // Define functions
  void function1() {System.out.println("inside function1");}
  void function2() {System.out.println("inside function2");}
  void function3() {System.out.println("inside function3");}

  // Factory Pattern
  void CallFunction (functionname) {eval(functionname + "();");}

  // Initialize function names
  functions[0] = new StringBuffer("function1");
  functions[1] = new StringBuffer("function2");
  functions[2] = new StringBuffer("function3");

  // Results
  bsh % CallFunction (functions[0]);
  inside function1
  bsh % CallFunction (functions[1]);
  inside function2
  bsh % CallFunction (functions[2]);
  inside function3
  bsh %

As in the Ruby example, the function names in the array can be stored in an array, or someplace else like a database or xml file.

In addition, similar to the Ruby example, we can store the function definition in an array as well:

  // Create an array for the function name and function definition
  StringBuffer[] function1 = new StringBuffer[10]; // We could have more than one
  StringBuffer[] function2 = new StringBuffer[10]; // We could have more than one

  // Dynamically create/define function
  function1[0] = new StringBuffer("function4");

  // Dynamically call the the name of the function
  bsh % function2[0] = new StringBuffer("void function4() {System.out.println(\"inside 
  function 4\");}");
  bsh % eval(function2[0].toString());
  bsh % CallFunction (function1[0]);
  inside function 4
  bsh %

As in the Ruby example, in this Java example using BeanShell eval(), function4() is created dynamically at run-time. This allows us to store parts of the code as data and to create functions when needed. An application written using eval to dynamically generate functions would allow new functions to be added easily. For example, you could create new definitions of functions and insert them into a database table.