CSC/ECE 517 Fall 2010/ch4 4g km

Metaprogramming in dynamically typed languages

---

Introduction

In the previous article for which the link does not exist yet, we learn that command patterns in static and dynamic languages provide separation of objects that request actions from the objects that ultimately perform actions. This is done by encapsulating the request for an action on a specific object. These command patterns are executed at runtime and simply hide the fact that another program is being called. Another technique of encapsulating behavior is for the program to have changes initiated at compile time. This type of design requires that the program not only can call another piece of code at runtime but it can build these calls at compile time via metaprogramming. In this article we take a closer look at metaprogramming in dynamically typed languages.

What is Metaprogramming?

Metaprogramming is the ability for a computer program to manipulate itself or other programs at the time of compilation as opposed to performing this manipulations at runtime. This tends to allow for greater flexibility for a program to handle new situations. Metaprogramming is ideal for several scenarios to include the use of application programming interfaces (API's), programs writing programs, and working with other programs outside of itself. API's allow the run-time engine to be exposed externally where it normally would not be. When a program writes another program that just means the running program dynamically outputs strings that can later be ran as en executed program. And finally, working with other programs outside itself refers to the running program's ability to accept language descriptions that it can execute transformations of the outside language.

Example of Metaprogramming

There is a classic example of use for metaprogramming that involves some form of writing a program that outputs some set of numbers in order but the trick is that it cannot be done in a loop. For this example we will ask for a program that outputs the numbers from 1 to 100 without using any looping. Ideally one would like to write the following (in pseudo code):

 for i = 1 to 100 
   print i

which outputs

 1
 2 
 ...
 100

however since a loop is not allowed, you could use the loop to write code that will write the code:

 for i = 1 to 100
   print "print i"

which outputs

 print 1
 print 2
 ...
 print 100

which then outputs

 1
 2 
 ...
 100

the elegance of this technique is that it is very easy to repeat or manipulate.

Taking the same pseudo code example, we can see how each of the following languages would incorporate this.

Python

 f = open('outputfile.py', 'w')
 f.write('#!/usr/bin/python \n')
 for i in range(1, 100):
    f.write('print' + i + '\n')
 f.closed

JavaScript

  fh = fopen('c:\\outputfile.js', 3);
  for (i=0;i<=100;i++) { 
     document.write('document.write' + i);
  }

Ruby

 1.upto 100 do |i|
   puts "puts #{i}"
 end

Dynamic Typed Programming Languages

Dynamic typed programming languages are often referred to as 'weak typed' languages since it is not required for the variables to bound to a particular type at compile time instead each variable is bound to an object. Another unique characteristic of dynamic languages is that while variables need to be defined before they can be used, you don’t need to define them at the beginning of the program, just define it before its first use it. These characteristics are allowed because it is not the compiler that checks for proper variable declaration, these type errors will only occur at runtime and potentially the program will suddenly stop due to a crash.

Putting it all together

How does metaprogamming work with dynamic typed languages?

Metaprogramming in some Dynamic Languages

We have already seen how some languages can be used for programs to write programs, now lets examine how they handle some of the other characteristics of metaprogramming:

Manipulate itself at runtime.

Python

  class SomeClassThatAlreadyExists
     def some_method(params)
        print "some code"
     end
  end

JavaScript

  SomeClassThatAlreadyExists.prototype.some_method = function () {
     document.write("some_code");
  }

Ruby

  class SomeClassThatAlreadyExists
     def some_method
        puts "some code"
     end
  end

What’s Next?

In the next article for which the link does not exist yet, we will look at static-analysis tools for Ruby.

References

1. Metaprogramming
2. Dynamic Programming Languages
3. Command Pattern