CSC/ECE 517 Fall 2009/wiki2 1 ma
Metaprogramming
What is Metaprogramming?
Meta- (from Greek: μετά = "after", "beyond", "with", "adjacent", "self"), is a prefix used in English to indicate a concept which is an abstraction from another concept, used to complete or add to the latter.
Metaprogramming is the writing of computer programs that write or manipulate other programs (or themselves) as their data, or that do part of the work at compile time that would otherwise be done at runtime. In many cases, this allows programmers to get more done in the same amount of time as they would take to write all the code manually, or it gives programs greater flexibility to efficiently handle new situations without recompilation. Source: [1]
Metaprogramming is divided into runtime metaprogramming, also known as reflection, and compile time metaprogramming. Reflection is more interesting since it allows interaction and modification of objects, components and structures that do not exist at compile time.
Examples of Metaprograms
- the compiler or interpreter of your favourite language
- Lex and Yacc
- CORBA's IDL compiler
- a Quine (a program that, when executed, prints a copy of its own source code - see QuineProgram for examples)
- Programs to generate EJB code and XML from database metadata
- Macros are nothing but special cases of metaprograms, as they are replaced by the actual code during macro expansion.
Source: [2]
Metaprogramming style in various languages
Metaprogramming seems to have origniated in Lisp. John Foderaro mentions Lisp as a programmable programming language. Lisp facilitates reflection through the use of an interpreter implemented in the same language. Unlike Smalltalk and Lisp, Java and C++ do not feature extensive built-in reflection facilities.
Metaprogramming in Ruby
Ruby is a dynamically-typed, interpreted, object oriented language. One of the unique aspects of Ruby is its extensive reflexive metaprogramming facilities.
What makes Ruby good for metaprogramming
- Ruby is Dynamic and reflective
- Everything is open to change
- Blocks allow writing new control structures
- Most declarations are executable statements
- An easy syntax
Classification of metaprogramming features in Ruby
- The dynamic nature of Ruby supports creating classes and methods at runtime
- Methods can be defined directly on Singleton classes: class_eval can be used to define methods on singleton classes. This will then modify the behaviour of the sub classes(if any) and not the base class.
- Blocks and proc objects: Materializing a Proc and saving this in variables and sending it around is a good way to use metaprogramming to do interesting things. Lambda function is used to define proc objects
- The different evals: There are 4 different evals in Ruby
- eval: This call can take a string or binding to evaluate but not a block
- class_eval: It is just a alias for module_eval
- instance_eval: It will evaluate the string or the block in the context of the receiver. Thus it sets self to be the receiver.
- module_eval: It will evaluate the string or the block in the context of the module it is called on. Thus it is used to define new methods on singleton classes. This is the most commonly used eval call.
The difference between the above 4 evals can be understood with examples here. Another useful external link on evals can be found here
Examples
We begin by showing how methods can be defined dynamically in Ruby. Consider we need a method that duplicates strings eg. "foo".duplicate -> "foofoo". And a deduplicate method for removing duplication eg. "foofoo".deduplicate -> "foo". We can define such methods dynamically in Ruby. This dynamic feature in Ruby forms the simplest kind of metapgrogramming.
class String def duplicate self * 2 end def deduplicate self[0, self.length/2] end end
For instance attr_reader, attr_writer, attr_accessor are inbuilt keywords that declare the object properties. These are actually not just syntax, but methods defined in Module. These methods are written in C. In other words, the object language here is Ruby but the metalanguage is C - Refer Appendix. Representing the functionality for the attr_reader method as a metaprogram in Ruby.
class Module
def attr_reader (*syms)
sys.each do |sym|
class_eval %{def #{sym} @#{sym} end}
end
end
end
Consider how define_method can be used dynamically in Ruby
Eagle=Class.new e=Eagle.new class Eagle define_method:fly do puts "I am flying" end end e.fly Output: I am flying
Rails becomes an all-powerful MVC framework, thanks to the metaprogramming features in Ruby.
Other elaborate examples can be found in the References section of this wiki page. A detailed discussion on Metaprogramming in Ruby was done in the CSC517 course lecture, the notes for which can be found here
Metaprogramming in C++
C++ provides for a type of metaprogramming called as template metaprograming. Template Metaprogramming (TMP) is a programming technique that uses the priniciple of early binding. This means that pieces of codes called templates are replaced by actual code including compile-time constants, data structures, and complete functions. Then the compiler puts together all the code and compiles it. Hence the compiler in a sense acts as a "virtual computer" [3] as it replaces parts of the program with instructions, which would otherwise have been done at run time.
In TMP similar groups of lines of codes are replaced by a common template. Initially the template has to be defined with a base set of lines of code which are common in all. Then at the time of usage, templates have to be instantiated. Thus the templte definition specifies the general form of the code whereas the instantiation gives the specific lines of code formed from the template definition.
Examples
Calculating a value at compile time
The code to find summation of a number without using templates can be given as:
int summation(int n)
{
if (n == 0 )
return 0;
return n + summation(n - 1);
}
void findsummation()
{
int a = summation(5); //a= (5+ 4 + 3 + 2 + 1 + 0) == 15
int b = summation(0); //b=0
}
Now using templates the same program can be written as:
template <int N>
//TEMPLATE DEFINITION
struct Summation
{
enum { value = N + Summation<N - 1>::value };
};
template <>
struct Summation<0>
{
enum { value = 0 };
};
void findsummation()
{
int a = Summation<5>::value; // == 15 // INSTANTIATION
int b = Summation<0>::value; // == 1 // INSTANTIATION
}
Thus with templates, the values of a and b were calculated at compile time rather than at run time. This was possible because 5 and 0 were literals, if they had been variables then their values wouldn’t have been known at compile time and hence a and b could not have been calculated at compile time.
Loop unrolling
Further templates can be used to unroll loops, that is a loop is replaced by repeating the code within the loop a certain number of times. more on this example
template< int i >
class LOOP{
public:
static inline void EXEC(){
cout << "A-" << i << " ";
LOOP< i-1 >::EXEC();
cout << "B-" << i << " ";
}
};
class LOOP< 0 >{
public:
static inline void EXEC(){
cout << "A-" << i;
cout << "\n";
cout << "B-" << i;
}
};
The output of LOOP< 8 >::EXEC() is shown below:
A-8 A-7 A-6 A-5 A-4 A-3 A-2 A-1 A-0
B-0 B-1 B-2 B-3 B-4 B-5 B-6 B-7 B-8
At compile time the loop unrolls itself and produces the following lines of code:
cout << "A-" << 8 << " "; cout << "A-" << 7 << " "; ... cout << "A-" << 0; cout << "\n"; cout << "B-" << 0; ... cout << "B-" << 7 << " "; cout << "B-" << 8 << " ";
More Examples can be found at C++ Template Programming, Template Metaprogramming and TMP in c++
Illustrating the differences
Unlike Ruby, C++ does not support a built-in metaprogramming system aside from template metaprogramming. Template programming is also known as "programming at compile time". Templates allow the compiler to determine certain variable and object types at compile time. The disadvantages of templates are : i) it is not specialized enough (C++ templates are Turing-complete [4]. Often they can be used for collection classes but they can also be employed in metaprogramming. This can make it hard to figure out how templates can be used to solve a specific problem), ii) poor error messages (when errors occur at compile time due to incorrectness of templates, the error messages can be cryptic)
Conclusion
Metaprogramming is thus an essential and useful programming feature that allows elimination of duplicated code and enables clean execution with lesser lines of code. The style of metaprogramming differs when it comes to different languages. Ruby and Lisp have more specialized metaprogramming constructs as compared to Java or C++. Metaprogramming is apparently is a higher-level concept and probably used often by expert programmers, nevertheless through metaprogramming the overall code or program becomes very easy to interpret. Its a trade-off that should be balanced by software programmers.
Appendix
- Metalanguage: The language in which the metaprogram is written
- Object language: The language of the programs that are manipulated
- Reflection or Reflexivity: The ability of a programming language to be its own metalanguage
- Template: A feature of the C++ programming language that allow functions and classes to operate with generic types. This allows a function or class to work on many different data types without being rewritten for each one.
- Early Binding: In programming languages, name binding is the association of values with identifiers. The binding of names before the program is run is called early (also "static")
References/External Links
- Wikipedia article on metaprogramming
- Metaprogramming
- TMP in C++
- Turing completeness in C++
- presentation about Meta programming in Ruby made at the 2005 O’Reilly Open Source Convention by Glenn Vanderburg
- Defining attributes with Metaprogramming
- More examples on Ruby metaprogramming
- Rubybeans and Metaprogramming
- Metaprogramming in Ruby
- C++ Template Programming
- Template Metaprogramming