CSC/ECE 517 Spring 2013/ch1b 1i lh
- Write-up of This Topic.
- Expertiza Wiki Entry on Meta-programming in Statically Typed Languages 1
- Expertiza Wiki Entry on Meta-programming in Statically Typed Languages 2
- Expertiza Wiki Entry on What is Meta-programming
Meta-programming in Dynamically Typed Languages
"I rather write a x86 program in binary using the butterfly method than writing this article" - Hao Liu
This page is a discuss about meta-programming and its implementation and uses in dynamically typed languages.
Introduction to Meta-programming
In essence meta-programs are computer programs that can write or manipulate other programs or themselves as their data. Meta-programming is the general term for techniques use to write such program. The language in which the meta-program is written is called the metalanguage. The language of the programs that are manipulated is called the object language.[1]
This simplistic definition of meta-program and meta-programming tend to give reader a very intimidating first impression and render a image of a sentient self modifying program that ultimately take over the world. In reality meta-program and meta-programming techniques can very in complexity from the extreme of sentient self modifying program to simple and everyday thing such as a pre-processor macro. In most cases meta-programming are use to improve the quality of life of the programmer by improving the readability and re-usability of the code and by providing a higher level of abstraction.
Any programming language, even a simple shell script, can be use for meta-programming, so long as they have the ability to reading and modifying the source code of another program or it's own source code as a text file.
For example:
#!/usr/bin/env bash
echo -e "#include <stdio.c>" >> program.c
echo -e "int main() {" >> program.c
for ((I=1; I<=5; I++)) do
echo -e " printf(\042 meta \042);" >> program.c
done
echo -e "return 0}" >> program.c
g++ program.c
a.out
This simple bash script generates a program that prints out
meta meta meta meta meta
by generating a c source code as a text file, than compile to source code into a executable binary file using a compiler.
In this article we will be focusing more on the implementation and use of reflection to facilitate meta-programming in dynamically typed languages.
Reflection is the ability of a computer program to examine and modify the structure and behavior of an object at runtime.[2]
Dynamically Typed Programming Languages
In general programming languages can be split into two categories base on their type system, statically typed and dynamically typed. A programming language is said to be statically typed if type checking is performed during compile-time. In comparison, a programming language is said to be dynamically typed deferring type checking until run-time as opposes to compile-time. [3]
In dynamically typed languages, the variables and parameters do not have a designated type and may take different type of values at different times. In all the operations, the operands must be type checked at run-time just before performing the operation. Dynamically typed languages don’t need to make a distinction between classes created at compile time and classes provided. It is possible to define classes at run time and in fact, classes are always defined at run time. These eliminate many developer constraints by avoiding the need of book keeping, declarations etc. Due to this flexibility these languages make an ideal candidate for prototyping and are widely used in agile development environments. However, dynamic languages are known to have performance issues. Static languages have code optimization features at compile time, but dynamic languages allow run-time code optimizations only. [4] In dynamically typed languages, the interpreter deduces type and type conversions, this makes development time faster, but it also can provoke run-time failures. These run-time failures are caught early on during compile time for statically typed languages.
Examples of dynamically typed languages:
- Perl
- Python
- JavaScript
- PHP
- Ruby
- SmallTalk
Meta-programming in Dynamically Typed Languages
Ruby
Ruby is a dynamic, reflective, general-purpose object-oriented programming language that combines syntax inspired by Perl with Smalltalk-like features. It was also influenced by Eiffel and Lisp[8]. Ruby was first designed and developed in the mid-1990s by Yukihiro "Matz" Matsumoto in Japan.
Example of metaprograming in Ruby
In ruby you can write methods using metaprogramming to insert code into the program. A widely use example of such metaprogramming method is the attr_accessor method in the class named Module.
In this example attr_accessor method is use to insert the accessor codes to the class
class MyClass attr_accessor :info end
Is the same as
class MyClass def variable=(value) @variable = value end
def variable @variable end end
The method method_missing() is another example of metaprograming in Ruby. In ruby if the interpreter can’t find the method anywhere up the object’s chain of inheritance, it will go back to the object and call the method named method_missing(). The interpreter looks for method_missing() in the object’s methods and up the object’s chain of inheritance until it reaches the Object class where method_missing() is defined.
class MyClass
def method_missing(name, *args)
puts "#{name} was called with arguments: #{args.join(', ')}"
end
end
m = MyClass.new
m.undefined_method("one", "two") # => undefined_method was called with arguments: one, two
m.another_undefined_method("three", "four") # => another_undefined_method was called with arguments: three, four
The class MyClass does not have a method named undefined_method() or another_underfined_method() but the method_missing() method created responds to these methods.