Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-21T01:54:58Z

Mlwiles: /* Putting it all together */

'''Metaprogramming in dynamically typed languages'''

----

==Introduction==
In the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2010/ch4_4f previous article for which the link does not exist yet], we learn that [http://en.wikipedia.org/wiki/Command_pattern 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 [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming]. In this article we take a closer look at metaprogramming in [http://en.wikipedia.org/wiki/Dynamic_programming_language 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 and plan for growth. Metaprogramming is ideal for several scenarios to include the use of [http://en.wikipedia.org/wiki/Application_programming_interface 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. Ideally metaprogramming has one main objective, to allow for new features.

==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') // Open the file for writing
f.write('#!/usr/bin/python \n')
for i in range(1, 100):
f.write('print' + i + '\n') // Write the string to a file
f.closed // Close the file

===JavaScript===
f = fopen('outputfile.js', 3); // Open the file for writing
if(f!=-1) { // If the file has been successfully opened
for (i=0;i<=100;i++) {
str = 'document.write' + i;
fwrite(f, str); // Write the string to a file
}
fclose(f); // Close the file
}

===Ruby===
f = File.open(outputfile.rb, 'w') // Open the file for writing
1.upto 100 do |i|
f.write("puts #{i}") // Write the string to a file
end
f.close // Close the file

==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 usage. 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.

==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 one of the other characteristics of metaprogramming: Manipulate itself at runtime. Each of the following will take a class (SomeClassThatAlreadyExists) that was already defined and add an new method (some_method) to it.

===Python===
class SomeClassThatAlreadyExists
def some_method
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

==Putting it all together==
How does metaprogamming work with dynamic typed languages?

*Interpreted Languages
Most dynamic languages are interpreted, not compiled. The basic idea here is for the code to be interpreted at run-time, allows generic objects to dynamically interact with each other. This interaction in itself is potentially manipulating the behavior of the program as it is executing. Generic objects are not the only uniqueness of an interpreted language, the 'eval' statement is something else to consider. The ability to evaluate an expression via the 'eval' statement allows for the program to redefine functions at run-time. These two capabilities for dynamic languages have become immensely valuable to programmers.

*Dynamic methods
These types of methods are very flexible. The program have have an object created from a class, then you can add additional methods to the instance of that class. Therefore manipulating the program at run time by allowing for only this instance of the object to have additional methods. Not to be confused with extending classes or adding additional methods to classes.

*Singletons classes
Singleton classes should not be mistake for the Singleton design pattern. These types of classes available in some dynamic languages allow for [http://en.wikipedia.org/wiki/Dynamic_dispatch dynamic dispatching]. An common technique often used on singleton classes is to add dynamic methods to the instance.

*"Everything is an object"
Many languages a 'weak-typed' which means that potentially anything can be anything else. The most obvious way to have this behavior is by making everything an object. What historically are considered primitive data types now are all considered objects (e.g. string, integers, etc). In some of these languages even functions and procedures are considered objects. In some languages such as Ruby, even classes are Objects since they (as well as everything else) inherits from Object. Since classes can be used to define, extend, or redefine other classes (often referred to as a [http://en.wikipedia.org/wiki/Metaclass metaclass]) this is also potentially changing the behavior of the original program.

Some other traits of some common dynamic languages worth mentioning are: the use of method_missing, [http://en.wikipedia.org/wiki/Introspection introspection], [http://en.wikipedia.org/wiki/Lazy_loading lazy loading], [http://en.wikipedia.org/wiki/Declarative_programming declarative code], extensible type system, and method aliasing.

==Conclusion==
Dynamic languages are increasingly recognized for playing a major role in software development, specifically for quick prototyping because of the forgiveness of the languages letting requirements evolve. These languages are historically looked at as scripting languages that are inexpensive and not scalable. Allowing for these types of behavior comes at a price. The price is the potential for poor performance since the code is runtime optimized. Another downfall is that rapid development is great but the flexibility allowed between type conversions means that there is a higher probability for runtime errors. While understanding these limitation and accepting the risks, these languages can be very powerful specifically in the area of Metaprogramming.

==What’s Next?==
In the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2010/ch4_4h next article for which the link does not exist yet], we will look at [http://en.wikipedia.org/wiki/Static_analysis static-analysis] tools for Ruby.

==References==
Websites:
*Wikipedia.org: Metaprogramming, http://en.wikipedia.org/wiki/Metaprogramming
*c2.com Wiki: Metaprogramming article, http://c2.com/cgi/wiki?MetaProgramming
*Code generation Vs Metaprogramming, http://www.qcodo.com/wiki/article/background/metaprogramming
*Solenoid, The first metaprogramming framework for [http://exist-db.org eXist-db], http://solenoid.schematronic.org
*The Art of Enterprise Metaprogramming, http://www.ibm.com/developerworks/linux/library/l-metaprog3/?ca=dgr-wikiaMetaprogP3
*Wikipedia.org: Dynamic Programming Languages, http://en.wikipedia.org/wiki/Dynamic_programming_language
*Eclipse.org, Dynamic Languages Toolkit, http://www.eclipse.org/dltk/
*Wikipedia.org: Application Programming Interfaces (API's), http://en.wikipedia.org/wiki/Application_programming_interface

Books/Articles:
*Tratt, L. 2005. Compile-time meta-programming in a dynamically typed OO language. In Proceedings of the 2005 Symposium on Dynamic Languages (San Diego, California, October 18 - 18, 2005). DLS '05. ACM, New York, NY, 49-63. http://doi.acm.org.www.lib.ncsu.edu:2048/10.1145/1146841.1146846
*Madsen, O.L.; Nogaard, C.; , "An object-oriented metaprogramming system," System Sciences, 1988. Vol.II. Software Track, Proceedings of the Twenty-First Annual Hawaii International Conference on , vol.2, no., pp.406-415, 5-8 Jan 1988, http://ieeexplore.ieee.org.www.lib.ncsu.edu:2048/stamp/stamp.jsp?tp=&arnumber=11831&isnumber=538

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-21T01:53:38Z

Mlwiles: /* Putting it all together */

'''Metaprogramming in dynamically typed languages'''

----

==Introduction==
In the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2010/ch4_4f previous article for which the link does not exist yet], we learn that [http://en.wikipedia.org/wiki/Command_pattern 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 [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming]. In this article we take a closer look at metaprogramming in [http://en.wikipedia.org/wiki/Dynamic_programming_language 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 and plan for growth. Metaprogramming is ideal for several scenarios to include the use of [http://en.wikipedia.org/wiki/Application_programming_interface 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. Ideally metaprogramming has one main objective, to allow for new features.

==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') // Open the file for writing
f.write('#!/usr/bin/python \n')
for i in range(1, 100):
f.write('print' + i + '\n') // Write the string to a file
f.closed // Close the file

===JavaScript===
f = fopen('outputfile.js', 3); // Open the file for writing
if(f!=-1) { // If the file has been successfully opened
for (i=0;i<=100;i++) {
str = 'document.write' + i;
fwrite(f, str); // Write the string to a file
}
fclose(f); // Close the file
}

===Ruby===
f = File.open(outputfile.rb, 'w') // Open the file for writing
1.upto 100 do |i|
f.write("puts #{i}") // Write the string to a file
end
f.close // Close the file

==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 usage. 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.

==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 one of the other characteristics of metaprogramming: Manipulate itself at runtime. Each of the following will take a class (SomeClassThatAlreadyExists) that was already defined and add an new method (some_method) to it.

===Python===
class SomeClassThatAlreadyExists
def some_method
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

==Putting it all together==
How does metaprogamming work with dynamic typed languages?

*Interpreted Languages
Most dynamic languages are interpreted, not compiled. The basic idea here is for the code to be interpreted at run-time, allows generic objects to dynamically interact with each other. This interaction in itself is potentially manipulating the behavior of the program as it is executing. Generic objects are not the only uniqueness of an interpreted language, the 'eval' statement is something else to consider. The ability to evaluate an expression via the 'eval' statement allows for the program to redefine functions at run-time. These two capabilities for dynamic languages have become immensely valuable to programmers.

*Dynamic methods
These types of methods are very flexible. The program have have an object created from a class, then you can add additional methods to the instance of that class. Therefore manipulating the program at run time by allowing for only this instance of the object to have additional methods. Not to be confused with extending classes or adding additional methods to classes.

*Singletons classes
Singleton classes should not be mistake for the Singleton design pattern. These types of classes available in some dynamic languages allow for [http://en.wikipedia.org/wiki/Dynamic_dispatch dynamic dispatching]. An common technique often used on singleton classes is to add dynamic methods to the instance.

*"Everything is an object"
Many languages a 'weak-typed' which means that potentially anything can be anything else. The most obvious way to have this behavior is by making everything an object. What historically are considered primitive data types now are all considered objects (e.g. string, integers, etc). In some of these languages even functions and procedures are considered objects. In some languages such as Ruby, even classes are Objects since they (as well as everything else) inherits from Object. Since classes can be used to define, extend, or redefine other classes (often referred to as a [http://en.wikipedia.org/wiki/Metaclass Metaclass]) this is also potentially changing the behavior of the original program.

Some other traits of some common dynamic languages worth mentioning are: the use of method_missing, [http://en.wikipedia.org/wiki/Introspection introspection], [http://en.wikipedia.org/wiki/Lazy_loading lazy loading], declarative code, extensible type system, and method aliasing

==Conclusion==
Dynamic languages are increasingly recognized for playing a major role in software development, specifically for quick prototyping because of the forgiveness of the languages letting requirements evolve. These languages are historically looked at as scripting languages that are inexpensive and not scalable. Allowing for these types of behavior comes at a price. The price is the potential for poor performance since the code is runtime optimized. Another downfall is that rapid development is great but the flexibility allowed between type conversions means that there is a higher probability for runtime errors. While understanding these limitation and accepting the risks, these languages can be very powerful specifically in the area of Metaprogramming.

==What’s Next?==
In the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2010/ch4_4h next article for which the link does not exist yet], we will look at [http://en.wikipedia.org/wiki/Static_analysis static-analysis] tools for Ruby.

==References==
Websites:
*Wikipedia.org: Metaprogramming, http://en.wikipedia.org/wiki/Metaprogramming
*c2.com Wiki: Metaprogramming article, http://c2.com/cgi/wiki?MetaProgramming
*Code generation Vs Metaprogramming, http://www.qcodo.com/wiki/article/background/metaprogramming
*Solenoid, The first metaprogramming framework for [http://exist-db.org eXist-db], http://solenoid.schematronic.org
*The Art of Enterprise Metaprogramming, http://www.ibm.com/developerworks/linux/library/l-metaprog3/?ca=dgr-wikiaMetaprogP3
*Wikipedia.org: Dynamic Programming Languages, http://en.wikipedia.org/wiki/Dynamic_programming_language
*Eclipse.org, Dynamic Languages Toolkit, http://www.eclipse.org/dltk/
*Wikipedia.org: Application Programming Interfaces (API's), http://en.wikipedia.org/wiki/Application_programming_interface

Books/Articles:
*Tratt, L. 2005. Compile-time meta-programming in a dynamically typed OO language. In Proceedings of the 2005 Symposium on Dynamic Languages (San Diego, California, October 18 - 18, 2005). DLS '05. ACM, New York, NY, 49-63. http://doi.acm.org.www.lib.ncsu.edu:2048/10.1145/1146841.1146846
*Madsen, O.L.; Nogaard, C.; , "An object-oriented metaprogramming system," System Sciences, 1988. Vol.II. Software Track, Proceedings of the Twenty-First Annual Hawaii International Conference on , vol.2, no., pp.406-415, 5-8 Jan 1988, http://ieeexplore.ieee.org.www.lib.ncsu.edu:2048/stamp/stamp.jsp?tp=&arnumber=11831&isnumber=538

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-21T01:50:35Z

Mlwiles: /* Putting it all together */

'''Metaprogramming in dynamically typed languages'''

----

==Introduction==
In the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2010/ch4_4f previous article for which the link does not exist yet], we learn that [http://en.wikipedia.org/wiki/Command_pattern 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 [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming]. In this article we take a closer look at metaprogramming in [http://en.wikipedia.org/wiki/Dynamic_programming_language 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 and plan for growth. Metaprogramming is ideal for several scenarios to include the use of [http://en.wikipedia.org/wiki/Application_programming_interface 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. Ideally metaprogramming has one main objective, to allow for new features.

==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') // Open the file for writing
f.write('#!/usr/bin/python \n')
for i in range(1, 100):
f.write('print' + i + '\n') // Write the string to a file
f.closed // Close the file

===JavaScript===
f = fopen('outputfile.js', 3); // Open the file for writing
if(f!=-1) { // If the file has been successfully opened
for (i=0;i<=100;i++) {
str = 'document.write' + i;
fwrite(f, str); // Write the string to a file
}
fclose(f); // Close the file
}

===Ruby===
f = File.open(outputfile.rb, 'w') // Open the file for writing
1.upto 100 do |i|
f.write("puts #{i}") // Write the string to a file
end
f.close // Close the file

==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 usage. 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.

==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 one of the other characteristics of metaprogramming: Manipulate itself at runtime. Each of the following will take a class (SomeClassThatAlreadyExists) that was already defined and add an new method (some_method) to it.

===Python===
class SomeClassThatAlreadyExists
def some_method
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

==Putting it all together==
How does metaprogamming work with dynamic typed languages?

*Interpreted Languages
Most dynamic languages are interpreted, not compiled. The basic idea here is for the code to be interpreted at run-time, allows generic objects to dynamically interact with each other. This interaction in itself is potentially manipulating the behavior of the program as it is executing. Generic objects are not the only uniqueness of an interpreted language, the 'eval' statement is something else to consider. The ability to evaluate an expression via the 'eval' statement allows for the program to redefine functions at run-time. These two capabilities for dynamic languages have become immensely valuable to programmers.

*Dynamic methods
These types of methods are very flexible. The program have have an object created from a class, then you can add additional methods to the instance of that class. Therefore manipulating the program at run time by allowing for only this instance of the object to have additional methods. Not to be confused with extending classes or adding additional methods to classes.

*Singletons classes
Singleton classes should not be mistake for the Singleton design pattern. These types of classes available in some dynamic languages allow for [http://en.wikipedia.org/wiki/Dynamic_dispatch dynamic dispatching]. An common technique often used on singleton classes is to add dynamic methods to the instance.

*Method_missing

*Introspection

*Lazy loading

*Declarative code

*Extensible type system

*Method aliasing

*Evaluation techniques (evaluation code at runtime, in instance and scope classes)

*"Everything is an object"
Many languages a 'weak-typed' which means that potentially anything can be anything else. The most obvious way to have this behavior is by making everything an object. What historically are considered primitive data types now are all considered objects (e.g. string, integers, etc). In some of these languages even functions and procedures are considered objects. In some languages such as Ruby, even classes are Objects since they (as well as everything else) inherits from Object. Since classes can be used to define, extend, or redefine other classes (often referred to as a [http://en.wikipedia.org/wiki/Metaclass Metaclass]) this is also potentially changing the behavior of the original program.

==Conclusion==
Dynamic languages are increasingly recognized for playing a major role in software development, specifically for quick prototyping because of the forgiveness of the languages letting requirements evolve. These languages are historically looked at as scripting languages that are inexpensive and not scalable. Allowing for these types of behavior comes at a price. The price is the potential for poor performance since the code is runtime optimized. Another downfall is that rapid development is great but the flexibility allowed between type conversions means that there is a higher probability for runtime errors. While understanding these limitation and accepting the risks, these languages can be very powerful specifically in the area of Metaprogramming.

==What’s Next?==
In the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2010/ch4_4h next article for which the link does not exist yet], we will look at [http://en.wikipedia.org/wiki/Static_analysis static-analysis] tools for Ruby.

==References==
Websites:
*Wikipedia.org: Metaprogramming, http://en.wikipedia.org/wiki/Metaprogramming
*c2.com Wiki: Metaprogramming article, http://c2.com/cgi/wiki?MetaProgramming
*Code generation Vs Metaprogramming, http://www.qcodo.com/wiki/article/background/metaprogramming
*Solenoid, The first metaprogramming framework for [http://exist-db.org eXist-db], http://solenoid.schematronic.org
*The Art of Enterprise Metaprogramming, http://www.ibm.com/developerworks/linux/library/l-metaprog3/?ca=dgr-wikiaMetaprogP3
*Wikipedia.org: Dynamic Programming Languages, http://en.wikipedia.org/wiki/Dynamic_programming_language
*Eclipse.org, Dynamic Languages Toolkit, http://www.eclipse.org/dltk/
*Wikipedia.org: Application Programming Interfaces (API's), http://en.wikipedia.org/wiki/Application_programming_interface

Books/Articles:
*Tratt, L. 2005. Compile-time meta-programming in a dynamically typed OO language. In Proceedings of the 2005 Symposium on Dynamic Languages (San Diego, California, October 18 - 18, 2005). DLS '05. ACM, New York, NY, 49-63. http://doi.acm.org.www.lib.ncsu.edu:2048/10.1145/1146841.1146846
*Madsen, O.L.; Nogaard, C.; , "An object-oriented metaprogramming system," System Sciences, 1988. Vol.II. Software Track, Proceedings of the Twenty-First Annual Hawaii International Conference on , vol.2, no., pp.406-415, 5-8 Jan 1988, http://ieeexplore.ieee.org.www.lib.ncsu.edu:2048/stamp/stamp.jsp?tp=&arnumber=11831&isnumber=538

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-21T01:29:34Z

Mlwiles: /* References */

'''Metaprogramming in dynamically typed languages'''

----

==Introduction==
In the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2010/ch4_4f previous article for which the link does not exist yet], we learn that [http://en.wikipedia.org/wiki/Command_pattern 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 [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming]. In this article we take a closer look at metaprogramming in [http://en.wikipedia.org/wiki/Dynamic_programming_language 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 and plan for growth. Metaprogramming is ideal for several scenarios to include the use of [http://en.wikipedia.org/wiki/Application_programming_interface 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. Ideally metaprogramming has one main objective, to allow for new features.

==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') // Open the file for writing
f.write('#!/usr/bin/python \n')
for i in range(1, 100):
f.write('print' + i + '\n') // Write the string to a file
f.closed // Close the file

===JavaScript===
f = fopen('outputfile.js', 3); // Open the file for writing
if(f!=-1) { // If the file has been successfully opened
for (i=0;i<=100;i++) {
str = 'document.write' + i;
fwrite(f, str); // Write the string to a file
}
fclose(f); // Close the file
}

===Ruby===
f = File.open(outputfile.rb, 'w') // Open the file for writing
1.upto 100 do |i|
f.write("puts #{i}") // Write the string to a file
end
f.close // Close the file

==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 usage. 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.

==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 one of the other characteristics of metaprogramming: Manipulate itself at runtime. Each of the following will take a class (SomeClassThatAlreadyExists) that was already defined and add an new method (some_method) to it.

===Python===
class SomeClassThatAlreadyExists
def some_method
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

==Putting it all together==
How does metaprogamming work with dynamic typed languages?

*Interpreted Languages
Most dynamic languages are interpreted, not compiled. The basic idea here is for the code to be interpreted at run-time, allows generic objects to dynamically interact with each other. This interaction in itself is potentially manipulating the behavior of the program as it is executing. Generic objects are not the only uniqueness of an interpreted language, the 'eval' statement is something else to consider. The ability to evaluate an expression via the 'eval' statement allows for the program to redefine functions at run-time. These two capabilities for dynamic languages have become immensely valuable to programmers.

*Dynamic methods

*Singletons and Open classes

*Method_missing

*Introspection

*Lazy loading

*Declarative code

*Extensible type system

*Method aliasing

*Evaluation techniques (evaluation code at runtime, in instance and scope classes)

*"Everything is an object"
Many languages a 'weak-typed' which means that potentially anything can be anything else. The most obvious way to have this behavior is by making everything an object. What historically are considered primitive data types now are all considered objects (e.g. string, integers, etc). In some of these languages even functions and procedures are considered objects. In some languages such as Ruby, even classes are Objects since they (as well as everything else) inherits from Object. Since classes can be used to define, extend, or redefine other classes (often referred to as a [http://en.wikipedia.org/wiki/Metaclass Metaclass]) this is also potentially changing the behavior of the original program.

==Conclusion==
Dynamic languages are increasingly recognized for playing a major role in software development, specifically for quick prototyping because of the forgiveness of the languages letting requirements evolve. These languages are historically looked at as scripting languages that are inexpensive and not scalable. Allowing for these types of behavior comes at a price. The price is the potential for poor performance since the code is runtime optimized. Another downfall is that rapid development is great but the flexibility allowed between type conversions means that there is a higher probability for runtime errors. While understanding these limitation and accepting the risks, these languages can be very powerful specifically in the area of Metaprogramming.

==What’s Next?==
In the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2010/ch4_4h next article for which the link does not exist yet], we will look at [http://en.wikipedia.org/wiki/Static_analysis static-analysis] tools for Ruby.

==References==
Websites:
*Wikipedia.org: Metaprogramming, http://en.wikipedia.org/wiki/Metaprogramming
*c2.com Wiki: Metaprogramming article, http://c2.com/cgi/wiki?MetaProgramming
*Code generation Vs Metaprogramming, http://www.qcodo.com/wiki/article/background/metaprogramming
*Solenoid, The first metaprogramming framework for [http://exist-db.org eXist-db], http://solenoid.schematronic.org
*The Art of Enterprise Metaprogramming, http://www.ibm.com/developerworks/linux/library/l-metaprog3/?ca=dgr-wikiaMetaprogP3
*Wikipedia.org: Dynamic Programming Languages, http://en.wikipedia.org/wiki/Dynamic_programming_language
*Eclipse.org, Dynamic Languages Toolkit, http://www.eclipse.org/dltk/
*Wikipedia.org: Application Programming Interfaces (API's), http://en.wikipedia.org/wiki/Application_programming_interface

Books/Articles:
*Tratt, L. 2005. Compile-time meta-programming in a dynamically typed OO language. In Proceedings of the 2005 Symposium on Dynamic Languages (San Diego, California, October 18 - 18, 2005). DLS '05. ACM, New York, NY, 49-63. http://doi.acm.org.www.lib.ncsu.edu:2048/10.1145/1146841.1146846
*Madsen, O.L.; Nogaard, C.; , "An object-oriented metaprogramming system," System Sciences, 1988. Vol.II. Software Track, Proceedings of the Twenty-First Annual Hawaii International Conference on , vol.2, no., pp.406-415, 5-8 Jan 1988, http://ieeexplore.ieee.org.www.lib.ncsu.edu:2048/stamp/stamp.jsp?tp=&arnumber=11831&isnumber=538

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-21T01:29:03Z

Mlwiles: /* References */

'''Metaprogramming in dynamically typed languages'''

----

==Introduction==
In the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2010/ch4_4f previous article for which the link does not exist yet], we learn that [http://en.wikipedia.org/wiki/Command_pattern 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 [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming]. In this article we take a closer look at metaprogramming in [http://en.wikipedia.org/wiki/Dynamic_programming_language 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 and plan for growth. Metaprogramming is ideal for several scenarios to include the use of [http://en.wikipedia.org/wiki/Application_programming_interface 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. Ideally metaprogramming has one main objective, to allow for new features.

==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') // Open the file for writing
f.write('#!/usr/bin/python \n')
for i in range(1, 100):
f.write('print' + i + '\n') // Write the string to a file
f.closed // Close the file

===JavaScript===
f = fopen('outputfile.js', 3); // Open the file for writing
if(f!=-1) { // If the file has been successfully opened
for (i=0;i<=100;i++) {
str = 'document.write' + i;
fwrite(f, str); // Write the string to a file
}
fclose(f); // Close the file
}

===Ruby===
f = File.open(outputfile.rb, 'w') // Open the file for writing
1.upto 100 do |i|
f.write("puts #{i}") // Write the string to a file
end
f.close // Close the file

==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 usage. 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.

==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 one of the other characteristics of metaprogramming: Manipulate itself at runtime. Each of the following will take a class (SomeClassThatAlreadyExists) that was already defined and add an new method (some_method) to it.

===Python===
class SomeClassThatAlreadyExists
def some_method
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

==Putting it all together==
How does metaprogamming work with dynamic typed languages?

*Interpreted Languages
Most dynamic languages are interpreted, not compiled. The basic idea here is for the code to be interpreted at run-time, allows generic objects to dynamically interact with each other. This interaction in itself is potentially manipulating the behavior of the program as it is executing. Generic objects are not the only uniqueness of an interpreted language, the 'eval' statement is something else to consider. The ability to evaluate an expression via the 'eval' statement allows for the program to redefine functions at run-time. These two capabilities for dynamic languages have become immensely valuable to programmers.

*Dynamic methods

*Singletons and Open classes

*Method_missing

*Introspection

*Lazy loading

*Declarative code

*Extensible type system

*Method aliasing

*Evaluation techniques (evaluation code at runtime, in instance and scope classes)

*"Everything is an object"
Many languages a 'weak-typed' which means that potentially anything can be anything else. The most obvious way to have this behavior is by making everything an object. What historically are considered primitive data types now are all considered objects (e.g. string, integers, etc). In some of these languages even functions and procedures are considered objects. In some languages such as Ruby, even classes are Objects since they (as well as everything else) inherits from Object. Since classes can be used to define, extend, or redefine other classes (often referred to as a [http://en.wikipedia.org/wiki/Metaclass Metaclass]) this is also potentially changing the behavior of the original program.

==Conclusion==
Dynamic languages are increasingly recognized for playing a major role in software development, specifically for quick prototyping because of the forgiveness of the languages letting requirements evolve. These languages are historically looked at as scripting languages that are inexpensive and not scalable. Allowing for these types of behavior comes at a price. The price is the potential for poor performance since the code is runtime optimized. Another downfall is that rapid development is great but the flexibility allowed between type conversions means that there is a higher probability for runtime errors. While understanding these limitation and accepting the risks, these languages can be very powerful specifically in the area of Metaprogramming.

==What’s Next?==
In the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2010/ch4_4h next article for which the link does not exist yet], we will look at [http://en.wikipedia.org/wiki/Static_analysis static-analysis] tools for Ruby.

==References==
*Wikipedia.org: Metaprogramming, http://en.wikipedia.org/wiki/Metaprogramming
*c2.com Wiki: Metaprogramming article, http://c2.com/cgi/wiki?MetaProgramming
*Code generation Vs Metaprogramming, http://www.qcodo.com/wiki/article/background/metaprogramming
*Solenoid, The first metaprogramming framework for [http://exist-db.org eXist-db], http://solenoid.schematronic.org
*The Art of Enterprise Metaprogramming, http://www.ibm.com/developerworks/linux/library/l-metaprog3/?ca=dgr-wikiaMetaprogP3
*Wikipedia.org: Dynamic Programming Languages, http://en.wikipedia.org/wiki/Dynamic_programming_language
*Eclipse.org, Dynamic Languages Toolkit, http://www.eclipse.org/dltk/
*Wikipedia.org: Application Programming Interfaces (API's), http://en.wikipedia.org/wiki/Application_programming_interface
*Tratt, L. 2005. Compile-time meta-programming in a dynamically typed OO language. In Proceedings of the 2005 Symposium on Dynamic Languages (San Diego, California, October 18 - 18, 2005). DLS '05. ACM, New York, NY, 49-63. http://doi.acm.org.www.lib.ncsu.edu:2048/10.1145/1146841.1146846
*Madsen, O.L.; Nogaard, C.; , "An object-oriented metaprogramming system," System Sciences, 1988. Vol.II. Software Track, Proceedings of the Twenty-First Annual Hawaii International Conference on , vol.2, no., pp.406-415, 5-8 Jan 1988, http://ieeexplore.ieee.org.www.lib.ncsu.edu:2048/stamp/stamp.jsp?tp=&arnumber=11831&isnumber=538

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-21T01:23:49Z

Mlwiles: /* Putting it all together */

'''Metaprogramming in dynamically typed languages'''

----

==Introduction==
In the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2010/ch4_4f previous article for which the link does not exist yet], we learn that [http://en.wikipedia.org/wiki/Command_pattern 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 [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming]. In this article we take a closer look at metaprogramming in [http://en.wikipedia.org/wiki/Dynamic_programming_language 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 and plan for growth. Metaprogramming is ideal for several scenarios to include the use of [http://en.wikipedia.org/wiki/Application_programming_interface 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. Ideally metaprogramming has one main objective, to allow for new features.

==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') // Open the file for writing
f.write('#!/usr/bin/python \n')
for i in range(1, 100):
f.write('print' + i + '\n') // Write the string to a file
f.closed // Close the file

===JavaScript===
f = fopen('outputfile.js', 3); // Open the file for writing
if(f!=-1) { // If the file has been successfully opened
for (i=0;i<=100;i++) {
str = 'document.write' + i;
fwrite(f, str); // Write the string to a file
}
fclose(f); // Close the file
}

===Ruby===
f = File.open(outputfile.rb, 'w') // Open the file for writing
1.upto 100 do |i|
f.write("puts #{i}") // Write the string to a file
end
f.close // Close the file

==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 usage. 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.

==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 one of the other characteristics of metaprogramming: Manipulate itself at runtime. Each of the following will take a class (SomeClassThatAlreadyExists) that was already defined and add an new method (some_method) to it.

===Python===
class SomeClassThatAlreadyExists
def some_method
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

==Putting it all together==
How does metaprogamming work with dynamic typed languages?

*Interpreted Languages
Most dynamic languages are interpreted, not compiled. The basic idea here is for the code to be interpreted at run-time, allows generic objects to dynamically interact with each other. This interaction in itself is potentially manipulating the behavior of the program as it is executing. Generic objects are not the only uniqueness of an interpreted language, the 'eval' statement is something else to consider. The ability to evaluate an expression via the 'eval' statement allows for the program to redefine functions at run-time. These two capabilities for dynamic languages have become immensely valuable to programmers.

*Dynamic methods

*Singletons and Open classes

*Method_missing

*Introspection

*Lazy loading

*Declarative code

*Extensible type system

*Method aliasing

*Evaluation techniques (evaluation code at runtime, in instance and scope classes)

*"Everything is an object"
Many languages a 'weak-typed' which means that potentially anything can be anything else. The most obvious way to have this behavior is by making everything an object. What historically are considered primitive data types now are all considered objects (e.g. string, integers, etc). In some of these languages even functions and procedures are considered objects. In some languages such as Ruby, even classes are Objects since they (as well as everything else) inherits from Object. Since classes can be used to define, extend, or redefine other classes (often referred to as a [http://en.wikipedia.org/wiki/Metaclass Metaclass]) this is also potentially changing the behavior of the original program.

==Conclusion==
Dynamic languages are increasingly recognized for playing a major role in software development, specifically for quick prototyping because of the forgiveness of the languages letting requirements evolve. These languages are historically looked at as scripting languages that are inexpensive and not scalable. Allowing for these types of behavior comes at a price. The price is the potential for poor performance since the code is runtime optimized. Another downfall is that rapid development is great but the flexibility allowed between type conversions means that there is a higher probability for runtime errors. While understanding these limitation and accepting the risks, these languages can be very powerful specifically in the area of Metaprogramming.

==What’s Next?==
In the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2010/ch4_4h next article for which the link does not exist yet], we will look at [http://en.wikipedia.org/wiki/Static_analysis static-analysis] tools for Ruby.

==References==

#Wikipedia.org, Metaprogramming, http://en.wikipedia.org/wiki/Metaprogramming
#Wikipedia.org, Dynamic Programming Languages, http://en.wikipedia.org/wiki/Dynamic_programming_language
#Wikipedia.org, Command Pattern, http://en.wikipedia.org/wiki/Command_pattern
#Wikipedia.org, Application Programming Interfaces (API's), http://en.wikipedia.org/wiki/Application_programming_interface
#Wikipedia.org, Static-Analysis, http://en.wikipedia.org/wiki/Static_analysis
#Tratt, L. 2005. Compile-time meta-programming in a dynamically typed OO language. In Proceedings of the 2005 Symposium on Dynamic Languages (San Diego, California, October 18 - 18, 2005). DLS '05. ACM, New York, NY, 49-63. http://doi.acm.org.www.lib.ncsu.edu:2048/10.1145/1146841.1146846
#Madsen, O.L.; Nogaard, C.; , "An object-oriented metaprogramming system," System Sciences, 1988. Vol.II. Software Track, Proceedings of the Twenty-First Annual Hawaii International Conference on , vol.2, no., pp.406-415, 5-8 Jan 1988, http://ieeexplore.ieee.org.www.lib.ncsu.edu:2048/stamp/stamp.jsp?tp=&arnumber=11831&isnumber=538

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-21T01:20:43Z

Mlwiles: /* Putting it all together */

'''Metaprogramming in dynamically typed languages'''

----

==Introduction==
In the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2010/ch4_4f previous article for which the link does not exist yet], we learn that [http://en.wikipedia.org/wiki/Command_pattern 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 [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming]. In this article we take a closer look at metaprogramming in [http://en.wikipedia.org/wiki/Dynamic_programming_language 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 and plan for growth. Metaprogramming is ideal for several scenarios to include the use of [http://en.wikipedia.org/wiki/Application_programming_interface 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. Ideally metaprogramming has one main objective, to allow for new features.

==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') // Open the file for writing
f.write('#!/usr/bin/python \n')
for i in range(1, 100):
f.write('print' + i + '\n') // Write the string to a file
f.closed // Close the file

===JavaScript===
f = fopen('outputfile.js', 3); // Open the file for writing
if(f!=-1) { // If the file has been successfully opened
for (i=0;i<=100;i++) {
str = 'document.write' + i;
fwrite(f, str); // Write the string to a file
}
fclose(f); // Close the file
}

===Ruby===
f = File.open(outputfile.rb, 'w') // Open the file for writing
1.upto 100 do |i|
f.write("puts #{i}") // Write the string to a file
end
f.close // Close the file

==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 usage. 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.

==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 one of the other characteristics of metaprogramming: Manipulate itself at runtime. Each of the following will take a class (SomeClassThatAlreadyExists) that was already defined and add an new method (some_method) to it.

===Python===
class SomeClassThatAlreadyExists
def some_method
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

==Putting it all together==
How does metaprogamming work with dynamic typed languages?

#Interpreted Languages
Most dynamic languages are interpreted, not compiled. The basic idea here is for the code to be interpreted at run-time, allows generic objects to dynamically interact with each other. This interaction in itself is potentially manipulating the behavior of the program as it is executing. Generic objects are not the only uniqueness of an interpreted language, the 'eval' statement is something else to consider. The ability to evaluate an expression via the 'eval' statement allows for the program to redefine functions at run-time. These two capabilities for dynamic languages have become immensely valuable to programmers.

#"Everything is an object"
Many languages a 'weak-typed' which means that potentially anything can be anything else. The most obvious way to have this behavior is by making everything an object. What historically are considered primitive data types now are all considered objects (e.g. string, integers, etc). In some of these languages even functions and procedures are considered objects. In some languages such as Ruby, even classes are Objects since they (as well as everything else) inherits from Object. Since classes can be used to define, extend, or redefine other classes (often referred to as a [http://en.wikipedia.org/wiki/Metaclass Metaclass]) this is also potentially changing the behavior of the original program.

#extensible type system
#dynamic methods
#Singletons and Open classes
#method_missing
#introspection
#lazy loading
#declarative code
#method aliasing
#evaluation techniques (evaluation code at runtime, in instance and scope classes)

==Conclusion==
Dynamic languages are increasingly recognized for playing a major role in software development, specifically for quick prototyping because of the forgiveness of the languages letting requirements evolve. These languages are historically looked at as scripting languages that are inexpensive and not scalable. Allowing for these types of behavior comes at a price. The price is the potential for poor performance since the code is runtime optimized. Another downfall is that rapid development is great but the flexibility allowed between type conversions means that there is a higher probability for runtime errors. While understanding these limitation and accepting the risks, these languages can be very powerful specifically in the area of Metaprogramming.

==What’s Next?==
In the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2010/ch4_4h next article for which the link does not exist yet], we will look at [http://en.wikipedia.org/wiki/Static_analysis static-analysis] tools for Ruby.

==References==

#Wikipedia.org, Metaprogramming, http://en.wikipedia.org/wiki/Metaprogramming
#Wikipedia.org, Dynamic Programming Languages, http://en.wikipedia.org/wiki/Dynamic_programming_language
#Wikipedia.org, Command Pattern, http://en.wikipedia.org/wiki/Command_pattern
#Wikipedia.org, Application Programming Interfaces (API's), http://en.wikipedia.org/wiki/Application_programming_interface
#Wikipedia.org, Static-Analysis, http://en.wikipedia.org/wiki/Static_analysis
#Tratt, L. 2005. Compile-time meta-programming in a dynamically typed OO language. In Proceedings of the 2005 Symposium on Dynamic Languages (San Diego, California, October 18 - 18, 2005). DLS '05. ACM, New York, NY, 49-63. http://doi.acm.org.www.lib.ncsu.edu:2048/10.1145/1146841.1146846
#Madsen, O.L.; Nogaard, C.; , "An object-oriented metaprogramming system," System Sciences, 1988. Vol.II. Software Track, Proceedings of the Twenty-First Annual Hawaii International Conference on , vol.2, no., pp.406-415, 5-8 Jan 1988, http://ieeexplore.ieee.org.www.lib.ncsu.edu:2048/stamp/stamp.jsp?tp=&arnumber=11831&isnumber=538

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-21T01:08:13Z

Mlwiles: /* Putting it all together */

'''Metaprogramming in dynamically typed languages'''

----

==Introduction==
In the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2010/ch4_4f previous article for which the link does not exist yet], we learn that [http://en.wikipedia.org/wiki/Command_pattern 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 [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming]. In this article we take a closer look at metaprogramming in [http://en.wikipedia.org/wiki/Dynamic_programming_language 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 and plan for growth. Metaprogramming is ideal for several scenarios to include the use of [http://en.wikipedia.org/wiki/Application_programming_interface 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. Ideally metaprogramming has one main objective, to allow for new features.

==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') // Open the file for writing
f.write('#!/usr/bin/python \n')
for i in range(1, 100):
f.write('print' + i + '\n') // Write the string to a file
f.closed // Close the file

===JavaScript===
f = fopen('outputfile.js', 3); // Open the file for writing
if(f!=-1) { // If the file has been successfully opened
for (i=0;i<=100;i++) {
str = 'document.write' + i;
fwrite(f, str); // Write the string to a file
}
fclose(f); // Close the file
}

===Ruby===
f = File.open(outputfile.rb, 'w') // Open the file for writing
1.upto 100 do |i|
f.write("puts #{i}") // Write the string to a file
end
f.close // Close the file

==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 usage. 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.

==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 one of the other characteristics of metaprogramming: Manipulate itself at runtime. Each of the following will take a class (SomeClassThatAlreadyExists) that was already defined and add an new method (some_method) to it.

===Python===
class SomeClassThatAlreadyExists
def some_method
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

==Putting it all together==
How does metaprogamming work with dynamic typed languages?

#Interpreted Languages
Most dynamic languages are interpreted, not compiled. The basic idea here is for the code to be interpreted at run-time, allows generic objects to dynamically interact with each other. This interaction in itself is potentially manipulating the behavior of the program as it is executing. Generic objects are not the only uniqueness of an interpreted language, the eval statement is something else to consider. The ability to evaluate an expression via the eval statement allows for the program to redefine functions at runtime. These two capabilities for dynamic languages have become immensely valuable to programmers.

#everything is an object
#extensible type system
#dynamic methods
#singletons and open classes
#method_missing
#introspection
#lazy loading
#declarative code
#method aliasing
#evaluation techniques (evaluation code at runtime, in instance and scope classes)

==Conclusion==
Dynamic languages are increasingly recognized for playing a major role in software development, specifically for quick prototyping because of the forgiveness of the languages letting requirements evolve. These languages are historically looked at as scripting languages that are inexpensive and not scalable. Allowing for these types of behavior comes at a price. The price is the potential for poor performance since the code is runtime optimized. Another downfall is that rapid development is great but the flexibility allowed between type conversions means that there is a higher probability for runtime errors. While understanding these limitation and accepting the risks, these languages can be very powerful specifically in the area of Metaprogramming.

==What’s Next?==
In the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2010/ch4_4h next article for which the link does not exist yet], we will look at [http://en.wikipedia.org/wiki/Static_analysis static-analysis] tools for Ruby.

==References==

#Wikipedia.org, Metaprogramming, http://en.wikipedia.org/wiki/Metaprogramming
#Wikipedia.org, Dynamic Programming Languages, http://en.wikipedia.org/wiki/Dynamic_programming_language
#Wikipedia.org, Command Pattern, http://en.wikipedia.org/wiki/Command_pattern
#Wikipedia.org, Application Programming Interfaces (API's), http://en.wikipedia.org/wiki/Application_programming_interface
#Wikipedia.org, Static-Analysis, http://en.wikipedia.org/wiki/Static_analysis
#Tratt, L. 2005. Compile-time meta-programming in a dynamically typed OO language. In Proceedings of the 2005 Symposium on Dynamic Languages (San Diego, California, October 18 - 18, 2005). DLS '05. ACM, New York, NY, 49-63. http://doi.acm.org.www.lib.ncsu.edu:2048/10.1145/1146841.1146846
#Madsen, O.L.; Nogaard, C.; , "An object-oriented metaprogramming system," System Sciences, 1988. Vol.II. Software Track, Proceedings of the Twenty-First Annual Hawaii International Conference on , vol.2, no., pp.406-415, 5-8 Jan 1988, http://ieeexplore.ieee.org.www.lib.ncsu.edu:2048/stamp/stamp.jsp?tp=&arnumber=11831&isnumber=538

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-20T05:02:00Z

Mlwiles: /* Putting it all together */

'''Metaprogramming in dynamically typed languages'''

----

==Introduction==
In the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2010/ch4_4f previous article for which the link does not exist yet], we learn that [http://en.wikipedia.org/wiki/Command_pattern 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 [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming]. In this article we take a closer look at metaprogramming in [http://en.wikipedia.org/wiki/Dynamic_programming_language 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 and plan for growth. Metaprogramming is ideal for several scenarios to include the use of [http://en.wikipedia.org/wiki/Application_programming_interface 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. Ideally metaprogramming has one main objective, to allow for new features.

==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') // Open the file for writing
f.write('#!/usr/bin/python \n')
for i in range(1, 100):
f.write('print' + i + '\n') // Write the string to a file
f.closed // Close the file

===JavaScript===
f = fopen('outputfile.js', 3); // Open the file for writing
if(f!=-1) { // If the file has been successfully opened
for (i=0;i<=100;i++) {
str = 'document.write' + i;
fwrite(f, str); // Write the string to a file
}
fclose(f); // Close the file
}

===Ruby===
f = File.open(outputfile.rb, 'w') // Open the file for writing
1.upto 100 do |i|
f.write("puts #{i}") // Write the string to a file
end
f.close // Close the file

==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 usage. 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.

==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 one of the other characteristics of metaprogramming: Manipulate itself at runtime. Each of the following will take a class (SomeClassThatAlreadyExists) that was already defined and add an new method (some_method) to it.

===Python===
class SomeClassThatAlreadyExists
def some_method
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

==Putting it all together==
How does metaprogamming work with dynamic typed languages?

#interpreted, not compiled - Compilation of dynamic languages is very difficult. There is mostly the eval statement to consider, which is used extensively in Javascript and Ruby. we still need a run-time interpreter to handle evals.
#everything is an object
#extensible type system
#dynamic methods
#singletons and open classes
#method_missing
#introspection
#lazy loading
#declarative code
#method aliasing
#evaluation techniques (evaluation code at runtime, in instance and scope classes)

==Conclusion==
Dynamic languages are increasingly recognized for playing a major role in software development, specifically for quick prototyping because of the forgiveness of the languages letting requirements evolve. These languages are historically looked at as scripting languages that are inexpensive and not scalable. Allowing for these types of behavior comes at a price. The price is the potential for poor performance since the code is runtime optimized. Another downfall is that rapid development is great but the flexibility allowed between type conversions means that there is a higher probability for runtime errors. While understanding these limitation and accepting the risks, these languages can be very powerful specifically in the area of Metaprogramming.

==What’s Next?==
In the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2010/ch4_4h next article for which the link does not exist yet], we will look at [http://en.wikipedia.org/wiki/Static_analysis static-analysis] tools for Ruby.

==References==

#Wikipedia.org, Metaprogramming, http://en.wikipedia.org/wiki/Metaprogramming
#Wikipedia.org, Dynamic Programming Languages, http://en.wikipedia.org/wiki/Dynamic_programming_language
#Wikipedia.org, Command Pattern, http://en.wikipedia.org/wiki/Command_pattern
#Wikipedia.org, Application Programming Interfaces (API's), http://en.wikipedia.org/wiki/Application_programming_interface
#Wikipedia.org, Static-Analysis, http://en.wikipedia.org/wiki/Static_analysis
#Tratt, L. 2005. Compile-time meta-programming in a dynamically typed OO language. In Proceedings of the 2005 Symposium on Dynamic Languages (San Diego, California, October 18 - 18, 2005). DLS '05. ACM, New York, NY, 49-63. http://doi.acm.org.www.lib.ncsu.edu:2048/10.1145/1146841.1146846
#Madsen, O.L.; Nogaard, C.; , "An object-oriented metaprogramming system," System Sciences, 1988. Vol.II. Software Track, Proceedings of the Twenty-First Annual Hawaii International Conference on , vol.2, no., pp.406-415, 5-8 Jan 1988, http://ieeexplore.ieee.org.www.lib.ncsu.edu:2048/stamp/stamp.jsp?tp=&arnumber=11831&isnumber=538

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-20T04:52:41Z

Mlwiles: /* Putting it all together */

'''Metaprogramming in dynamically typed languages'''

----

==Introduction==
In the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2010/ch4_4f previous article for which the link does not exist yet], we learn that [http://en.wikipedia.org/wiki/Command_pattern 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 [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming]. In this article we take a closer look at metaprogramming in [http://en.wikipedia.org/wiki/Dynamic_programming_language 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 and plan for growth. Metaprogramming is ideal for several scenarios to include the use of [http://en.wikipedia.org/wiki/Application_programming_interface 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. Ideally metaprogramming has one main objective, to allow for new features.

==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') // Open the file for writing
f.write('#!/usr/bin/python \n')
for i in range(1, 100):
f.write('print' + i + '\n') // Write the string to a file
f.closed // Close the file

===JavaScript===
f = fopen('outputfile.js', 3); // Open the file for writing
if(f!=-1) { // If the file has been successfully opened
for (i=0;i<=100;i++) {
str = 'document.write' + i;
fwrite(f, str); // Write the string to a file
}
fclose(f); // Close the file
}

===Ruby===
f = File.open(outputfile.rb, 'w') // Open the file for writing
1.upto 100 do |i|
f.write("puts #{i}") // Write the string to a file
end
f.close // Close the file

==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 usage. 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.

==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 one of the other characteristics of metaprogramming: Manipulate itself at runtime. Each of the following will take a class (SomeClassThatAlreadyExists) that was already defined and add an new method (some_method) to it.

===Python===
class SomeClassThatAlreadyExists
def some_method
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

==Putting it all together==
How does metaprogamming work with dynamic typed languages?

Natural fit:
#interpreted, not compiled - Compilation of dynamic languages is very difficult. There is mostly the eval statement to consider, which is used extensively in Javascript and Ruby. we still need a run-time interpreter to handle evals.
#everything is an object
#extensible type system
#dynamic methods
#singletons and open classes
#method_missing
#introspection
#lazy loading
#declarative code
#method aliasing
#evaluation techniques (evaluation code at runtime, in instance and scope classes)

==Conclusion==
Dynamic languages are increasingly recognized for playing a major role in software development, specifically for quick prototyping because of the forgiveness of the languages letting requirements evolve. These languages are historically looked at as scripting languages that are inexpensive and not scalable. Allowing for these types of behavior comes at a price. The price is the potential for poor performance since the code is runtime optimized. Another downfall is that rapid development is great but the flexibility allowed between type conversions means that there is a higher probability for runtime errors. While understanding these limitation and accepting the risks, these languages can be very powerful specifically in the area of Metaprogramming.

==What’s Next?==
In the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2010/ch4_4h next article for which the link does not exist yet], we will look at [http://en.wikipedia.org/wiki/Static_analysis static-analysis] tools for Ruby.

==References==

#Wikipedia.org, Metaprogramming, http://en.wikipedia.org/wiki/Metaprogramming
#Wikipedia.org, Dynamic Programming Languages, http://en.wikipedia.org/wiki/Dynamic_programming_language
#Wikipedia.org, Command Pattern, http://en.wikipedia.org/wiki/Command_pattern
#Wikipedia.org, Application Programming Interfaces (API's), http://en.wikipedia.org/wiki/Application_programming_interface
#Wikipedia.org, Static-Analysis, http://en.wikipedia.org/wiki/Static_analysis
#Tratt, L. 2005. Compile-time meta-programming in a dynamically typed OO language. In Proceedings of the 2005 Symposium on Dynamic Languages (San Diego, California, October 18 - 18, 2005). DLS '05. ACM, New York, NY, 49-63. http://doi.acm.org.www.lib.ncsu.edu:2048/10.1145/1146841.1146846
#Madsen, O.L.; Nogaard, C.; , "An object-oriented metaprogramming system," System Sciences, 1988. Vol.II. Software Track, Proceedings of the Twenty-First Annual Hawaii International Conference on , vol.2, no., pp.406-415, 5-8 Jan 1988, http://ieeexplore.ieee.org.www.lib.ncsu.edu:2048/stamp/stamp.jsp?tp=&arnumber=11831&isnumber=538

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-20T04:39:07Z

Mlwiles: /* Putting it all together */

'''Metaprogramming in dynamically typed languages'''

----

==Introduction==
In the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2010/ch4_4f previous article for which the link does not exist yet], we learn that [http://en.wikipedia.org/wiki/Command_pattern 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 [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming]. In this article we take a closer look at metaprogramming in [http://en.wikipedia.org/wiki/Dynamic_programming_language 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 and plan for growth. Metaprogramming is ideal for several scenarios to include the use of [http://en.wikipedia.org/wiki/Application_programming_interface 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. Ideally metaprogramming has one main objective, to allow for new features.

==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') // Open the file for writing
f.write('#!/usr/bin/python \n')
for i in range(1, 100):
f.write('print' + i + '\n') // Write the string to a file
f.closed // Close the file

===JavaScript===
f = fopen('outputfile.js', 3); // Open the file for writing
if(f!=-1) { // If the file has been successfully opened
for (i=0;i<=100;i++) {
str = 'document.write' + i;
fwrite(f, str); // Write the string to a file
}
fclose(f); // Close the file
}

===Ruby===
f = File.open(outputfile.rb, 'w') // Open the file for writing
1.upto 100 do |i|
f.write("puts #{i}") // Write the string to a file
end
f.close // Close the file

==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 usage. 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.

==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 one of the other characteristics of metaprogramming: Manipulate itself at runtime. Each of the following will take a class (SomeClassThatAlreadyExists) that was already defined and add an new method (some_method) to it.

===Python===
class SomeClassThatAlreadyExists
def some_method
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

==Putting it all together==
How does metaprogamming work with dynamic typed languages?

Natural fit:
#interpreted, not compiled
#everything is an object
#extensible type system
#dynamic methods
#singletons and open classes
#method_missing
#introspection
#lazy loading
#declarative code
#method aliasing
#evaluation techniques (evaluation code at runtime, in instance and scope classes)

==Conclusion==
Dynamic languages are increasingly recognized for playing a major role in software development, specifically for quick prototyping because of the forgiveness of the languages letting requirements evolve. These languages are historically looked at as scripting languages that are inexpensive and not scalable. Allowing for these types of behavior comes at a price. The price is the potential for poor performance since the code is runtime optimized. Another downfall is that rapid development is great but the flexibility allowed between type conversions means that there is a higher probability for runtime errors. While understanding these limitation and accepting the risks, these languages can be very powerful specifically in the area of Metaprogramming.

==What’s Next?==
In the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2010/ch4_4h next article for which the link does not exist yet], we will look at [http://en.wikipedia.org/wiki/Static_analysis static-analysis] tools for Ruby.

==References==

#Wikipedia.org, Metaprogramming, http://en.wikipedia.org/wiki/Metaprogramming
#Wikipedia.org, Dynamic Programming Languages, http://en.wikipedia.org/wiki/Dynamic_programming_language
#Wikipedia.org, Command Pattern, http://en.wikipedia.org/wiki/Command_pattern
#Wikipedia.org, Application Programming Interfaces (API's), http://en.wikipedia.org/wiki/Application_programming_interface
#Wikipedia.org, Static-Analysis, http://en.wikipedia.org/wiki/Static_analysis
#Tratt, L. 2005. Compile-time meta-programming in a dynamically typed OO language. In Proceedings of the 2005 Symposium on Dynamic Languages (San Diego, California, October 18 - 18, 2005). DLS '05. ACM, New York, NY, 49-63. http://doi.acm.org.www.lib.ncsu.edu:2048/10.1145/1146841.1146846
#Madsen, O.L.; Nogaard, C.; , "An object-oriented metaprogramming system," System Sciences, 1988. Vol.II. Software Track, Proceedings of the Twenty-First Annual Hawaii International Conference on , vol.2, no., pp.406-415, 5-8 Jan 1988, http://ieeexplore.ieee.org.www.lib.ncsu.edu:2048/stamp/stamp.jsp?tp=&arnumber=11831&isnumber=538

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-20T04:36:28Z

Mlwiles: /* Putting it all together */

'''Metaprogramming in dynamically typed languages'''

----

==Introduction==
In the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2010/ch4_4f previous article for which the link does not exist yet], we learn that [http://en.wikipedia.org/wiki/Command_pattern 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 [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming]. In this article we take a closer look at metaprogramming in [http://en.wikipedia.org/wiki/Dynamic_programming_language 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 and plan for growth. Metaprogramming is ideal for several scenarios to include the use of [http://en.wikipedia.org/wiki/Application_programming_interface 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. Ideally metaprogramming has one main objective, to allow for new features.

==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') // Open the file for writing
f.write('#!/usr/bin/python \n')
for i in range(1, 100):
f.write('print' + i + '\n') // Write the string to a file
f.closed // Close the file

===JavaScript===
f = fopen('outputfile.js', 3); // Open the file for writing
if(f!=-1) { // If the file has been successfully opened
for (i=0;i<=100;i++) {
str = 'document.write' + i;
fwrite(f, str); // Write the string to a file
}
fclose(f); // Close the file
}

===Ruby===
f = File.open(outputfile.rb, 'w') // Open the file for writing
1.upto 100 do |i|
f.write("puts #{i}") // Write the string to a file
end
f.close // Close the file

==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 usage. 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.

==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 one of the other characteristics of metaprogramming: Manipulate itself at runtime. Each of the following will take a class (SomeClassThatAlreadyExists) that was already defined and add an new method (some_method) to it.

===Python===
class SomeClassThatAlreadyExists
def some_method
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

==Putting it all together==
How does metaprogamming work with dynamic typed languages?

Natural fit:
interpreted, not compiled
everything is an object
extensible type system
dynamic methods
singletons and open classes
method_missing
introspection
lazy loading
declarative code
method aliasing
evaluation techniques (evaluation code at runtime, in instance and scope classes)

==Conclusion==
Dynamic languages are increasingly recognized for playing a major role in software development, specifically for quick prototyping because of the forgiveness of the languages letting requirements evolve. These languages are historically looked at as scripting languages that are inexpensive and not scalable. Allowing for these types of behavior comes at a price. The price is the potential for poor performance since the code is runtime optimized. Another downfall is that rapid development is great but the flexibility allowed between type conversions means that there is a higher probability for runtime errors. While understanding these limitation and accepting the risks, these languages can be very powerful specifically in the area of Metaprogramming.

==What’s Next?==
In the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2010/ch4_4h next article for which the link does not exist yet], we will look at [http://en.wikipedia.org/wiki/Static_analysis static-analysis] tools for Ruby.

==References==

#Wikipedia.org, Metaprogramming, http://en.wikipedia.org/wiki/Metaprogramming
#Wikipedia.org, Dynamic Programming Languages, http://en.wikipedia.org/wiki/Dynamic_programming_language
#Wikipedia.org, Command Pattern, http://en.wikipedia.org/wiki/Command_pattern
#Wikipedia.org, Application Programming Interfaces (API's), http://en.wikipedia.org/wiki/Application_programming_interface
#Wikipedia.org, Static-Analysis, http://en.wikipedia.org/wiki/Static_analysis
#Tratt, L. 2005. Compile-time meta-programming in a dynamically typed OO language. In Proceedings of the 2005 Symposium on Dynamic Languages (San Diego, California, October 18 - 18, 2005). DLS '05. ACM, New York, NY, 49-63. http://doi.acm.org.www.lib.ncsu.edu:2048/10.1145/1146841.1146846
#Madsen, O.L.; Nogaard, C.; , "An object-oriented metaprogramming system," System Sciences, 1988. Vol.II. Software Track, Proceedings of the Twenty-First Annual Hawaii International Conference on , vol.2, no., pp.406-415, 5-8 Jan 1988, http://ieeexplore.ieee.org.www.lib.ncsu.edu:2048/stamp/stamp.jsp?tp=&arnumber=11831&isnumber=538

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-18T19:30:38Z

Mlwiles:

'''Metaprogramming in dynamically typed languages'''

----

==Introduction==
In the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2010/ch4_4f previous article for which the link does not exist yet], we learn that [http://en.wikipedia.org/wiki/Command_pattern 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 [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming]. In this article we take a closer look at metaprogramming in [http://en.wikipedia.org/wiki/Dynamic_programming_language 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 and plan for growth. Metaprogramming is ideal for several scenarios to include the use of [http://en.wikipedia.org/wiki/Application_programming_interface 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. Ideally metaprogramming has one main objective, to allow for new features.

==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') // Open the file for writing
f.write('#!/usr/bin/python \n')
for i in range(1, 100):
f.write('print' + i + '\n') // Write the string to a file
f.closed // Close the file

===JavaScript===
f = fopen('outputfile.js', 3); // Open the file for writing
if(f!=-1) { // If the file has been successfully opened
for (i=0;i<=100;i++) {
str = 'document.write' + i;
fwrite(f, str); // Write the string to a file
}
fclose(f); // Close the file
}

===Ruby===
f = File.open(outputfile.rb, 'w') // Open the file for writing
1.upto 100 do |i|
f.write("puts #{i}") // Write the string to a file
end
f.close // Close the file

==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 usage. 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.

==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 one of the other characteristics of metaprogramming: Manipulate itself at runtime. Each of the following will take a class (SomeClassThatAlreadyExists) that was already defined and add an new method (some_method) to it.

===Python===
class SomeClassThatAlreadyExists
def some_method
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

==Putting it all together==
How does metaprogamming work with dynamic typed languages?

==Conclusion==
Dynamic languages are increasingly recognized for playing a major role in software development, specifically for quick prototyping because of the forgiveness of the languages letting requirements evolve. These languages are historically looked at as scripting languages that are inexpensive and not scalable. Allowing for these types of behavior comes at a price. The price is the potential for poor performance since the code is runtime optimized. Another downfall is that rapid development is great but the flexibility allowed between type conversions means that there is a higher probability for runtime errors. While understanding these limitation and accepting the risks, these languages can be very powerful specifically in the area of Metaprogramming.

==What’s Next?==
In the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2010/ch4_4h next article for which the link does not exist yet], we will look at [http://en.wikipedia.org/wiki/Static_analysis static-analysis] tools for Ruby.

==References==

#Wikipedia.org, Metaprogramming, http://en.wikipedia.org/wiki/Metaprogramming
#Wikipedia.org, Dynamic Programming Languages, http://en.wikipedia.org/wiki/Dynamic_programming_language
#Wikipedia.org, Command Pattern, http://en.wikipedia.org/wiki/Command_pattern
#Wikipedia.org, Application Programming Interfaces (API's), http://en.wikipedia.org/wiki/Application_programming_interface
#Wikipedia.org, Static-Analysis, http://en.wikipedia.org/wiki/Static_analysis
#Tratt, L. 2005. Compile-time meta-programming in a dynamically typed OO language. In Proceedings of the 2005 Symposium on Dynamic Languages (San Diego, California, October 18 - 18, 2005). DLS '05. ACM, New York, NY, 49-63. http://doi.acm.org.www.lib.ncsu.edu:2048/10.1145/1146841.1146846
#Madsen, O.L.; Nogaard, C.; , "An object-oriented metaprogramming system," System Sciences, 1988. Vol.II. Software Track, Proceedings of the Twenty-First Annual Hawaii International Conference on , vol.2, no., pp.406-415, 5-8 Jan 1988, http://ieeexplore.ieee.org.www.lib.ncsu.edu:2048/stamp/stamp.jsp?tp=&arnumber=11831&isnumber=538

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-18T17:05:03Z

Mlwiles: /* Metaprogramming in some Dynamic Languages */

'''Metaprogramming in dynamically typed languages'''

----

==Introduction==
In the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2010/ch4_4f previous article for which the link does not exist yet], we learn that [http://en.wikipedia.org/wiki/Command_pattern 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 [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming]. In this article we take a closer look at metaprogramming in [http://en.wikipedia.org/wiki/Dynamic_programming_language 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 and plan for growth. Metaprogramming is ideal for several scenarios to include the use of [http://en.wikipedia.org/wiki/Application_programming_interface 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. Ideally metaprogramming has one main objective, to allow for new features.

==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') // Open the file for writing
f.write('#!/usr/bin/python \n')
for i in range(1, 100):
f.write('print' + i + '\n') // Write the string to a file
f.closed // Close the file

===JavaScript===
f = fopen('outputfile.js', 3); // Open the file for writing
if(f!=-1) { // If the file has been successfully opened
for (i=0;i<=100;i++) {
str = 'document.write' + i;
fwrite(f, str); // Write the string to a file
}
fclose(f); // Close the file
}

===Ruby===
f = File.open(outputfile.rb, 'w') // Open the file for writing
1.upto 100 do |i|
f.write("puts #{i}") // Write the string to a file
end
f.close // Close the file

==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 usage. 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 one of the other characteristics of metaprogramming: Manipulate itself at runtime. Each of the following will take a class (SomeClassThatAlreadyExists) that was already defined and add an new method (some_method) to it.

===Python===
class SomeClassThatAlreadyExists
def some_method
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

==Conclusion==
Dynamic languages are increasingly recognized for playing a major role in software development, specifically for quick prototyping because of the forgiveness of the languages letting requirements evolve. These languages are historically looked at as scripting languages that are inexpensive and not scalable. Allowing for these types of behavior comes at a price. The price is the potential for poor performance since the code is runtime optimized. Another downfall is that rapid development is great but the flexibility allowed between type conversions means that there is a higher probability for runtime errors. While understanding these limitation and accepting the risks, these languages can be very powerful specifically in the area of Metaprogramming.

==What’s Next?==
In the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2010/ch4_4h next article for which the link does not exist yet], we will look at [http://en.wikipedia.org/wiki/Static_analysis static-analysis] tools for Ruby.

==References==

#Wikipedia.org, Metaprogramming, http://en.wikipedia.org/wiki/Metaprogramming
#Wikipedia.org, Dynamic Programming Languages, http://en.wikipedia.org/wiki/Dynamic_programming_language
#Wikipedia.org, Command Pattern, http://en.wikipedia.org/wiki/Command_pattern
#Wikipedia.org, Application Programming Interfaces (API's), http://en.wikipedia.org/wiki/Application_programming_interface
#Wikipedia.org, Static-Analysis, http://en.wikipedia.org/wiki/Static_analysis
#Tratt, L. 2005. Compile-time meta-programming in a dynamically typed OO language. In Proceedings of the 2005 Symposium on Dynamic Languages (San Diego, California, October 18 - 18, 2005). DLS '05. ACM, New York, NY, 49-63. http://doi.acm.org.www.lib.ncsu.edu:2048/10.1145/1146841.1146846
#Madsen, O.L.; Nogaard, C.; , "An object-oriented metaprogramming system," System Sciences, 1988. Vol.II. Software Track, Proceedings of the Twenty-First Annual Hawaii International Conference on , vol.2, no., pp.406-415, 5-8 Jan 1988, http://ieeexplore.ieee.org.www.lib.ncsu.edu:2048/stamp/stamp.jsp?tp=&arnumber=11831&isnumber=538

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-18T17:03:54Z

Mlwiles: /* Metaprogramming in some Dynamic Languages */

'''Metaprogramming in dynamically typed languages'''

----

==Introduction==
In the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2010/ch4_4f previous article for which the link does not exist yet], we learn that [http://en.wikipedia.org/wiki/Command_pattern 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 [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming]. In this article we take a closer look at metaprogramming in [http://en.wikipedia.org/wiki/Dynamic_programming_language 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 and plan for growth. Metaprogramming is ideal for several scenarios to include the use of [http://en.wikipedia.org/wiki/Application_programming_interface 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. Ideally metaprogramming has one main objective, to allow for new features.

==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') // Open the file for writing
f.write('#!/usr/bin/python \n')
for i in range(1, 100):
f.write('print' + i + '\n') // Write the string to a file
f.closed // Close the file

===JavaScript===
f = fopen('outputfile.js', 3); // Open the file for writing
if(f!=-1) { // If the file has been successfully opened
for (i=0;i<=100;i++) {
str = 'document.write' + i;
fwrite(f, str); // Write the string to a file
}
fclose(f); // Close the file
}

===Ruby===
f = File.open(outputfile.rb, 'w') // Open the file for writing
1.upto 100 do |i|
f.write("puts #{i}") // Write the string to a file
end
f.close // Close the file

==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 usage. 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 one 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

==Conclusion==
Dynamic languages are increasingly recognized for playing a major role in software development, specifically for quick prototyping because of the forgiveness of the languages letting requirements evolve. These languages are historically looked at as scripting languages that are inexpensive and not scalable. Allowing for these types of behavior comes at a price. The price is the potential for poor performance since the code is runtime optimized. Another downfall is that rapid development is great but the flexibility allowed between type conversions means that there is a higher probability for runtime errors. While understanding these limitation and accepting the risks, these languages can be very powerful specifically in the area of Metaprogramming.

==What’s Next?==
In the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2010/ch4_4h next article for which the link does not exist yet], we will look at [http://en.wikipedia.org/wiki/Static_analysis static-analysis] tools for Ruby.

==References==

#Wikipedia.org, Metaprogramming, http://en.wikipedia.org/wiki/Metaprogramming
#Wikipedia.org, Dynamic Programming Languages, http://en.wikipedia.org/wiki/Dynamic_programming_language
#Wikipedia.org, Command Pattern, http://en.wikipedia.org/wiki/Command_pattern
#Wikipedia.org, Application Programming Interfaces (API's), http://en.wikipedia.org/wiki/Application_programming_interface
#Wikipedia.org, Static-Analysis, http://en.wikipedia.org/wiki/Static_analysis
#Tratt, L. 2005. Compile-time meta-programming in a dynamically typed OO language. In Proceedings of the 2005 Symposium on Dynamic Languages (San Diego, California, October 18 - 18, 2005). DLS '05. ACM, New York, NY, 49-63. http://doi.acm.org.www.lib.ncsu.edu:2048/10.1145/1146841.1146846
#Madsen, O.L.; Nogaard, C.; , "An object-oriented metaprogramming system," System Sciences, 1988. Vol.II. Software Track, Proceedings of the Twenty-First Annual Hawaii International Conference on , vol.2, no., pp.406-415, 5-8 Jan 1988, http://ieeexplore.ieee.org.www.lib.ncsu.edu:2048/stamp/stamp.jsp?tp=&arnumber=11831&isnumber=538

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-18T17:02:50Z

Mlwiles: /* Dynamic Typed Programming Languages */

'''Metaprogramming in dynamically typed languages'''

----

==Introduction==
In the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2010/ch4_4f previous article for which the link does not exist yet], we learn that [http://en.wikipedia.org/wiki/Command_pattern 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 [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming]. In this article we take a closer look at metaprogramming in [http://en.wikipedia.org/wiki/Dynamic_programming_language 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 and plan for growth. Metaprogramming is ideal for several scenarios to include the use of [http://en.wikipedia.org/wiki/Application_programming_interface 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. Ideally metaprogramming has one main objective, to allow for new features.

==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') // Open the file for writing
f.write('#!/usr/bin/python \n')
for i in range(1, 100):
f.write('print' + i + '\n') // Write the string to a file
f.closed // Close the file

===JavaScript===
f = fopen('outputfile.js', 3); // Open the file for writing
if(f!=-1) { // If the file has been successfully opened
for (i=0;i<=100;i++) {
str = 'document.write' + i;
fwrite(f, str); // Write the string to a file
}
fclose(f); // Close the file
}

===Ruby===
f = File.open(outputfile.rb, 'w') // Open the file for writing
1.upto 100 do |i|
f.write("puts #{i}") // Write the string to a file
end
f.close // Close the file

==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 usage. 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

==Conclusion==
Dynamic languages are increasingly recognized for playing a major role in software development, specifically for quick prototyping because of the forgiveness of the languages letting requirements evolve. These languages are historically looked at as scripting languages that are inexpensive and not scalable. Allowing for these types of behavior comes at a price. The price is the potential for poor performance since the code is runtime optimized. Another downfall is that rapid development is great but the flexibility allowed between type conversions means that there is a higher probability for runtime errors. While understanding these limitation and accepting the risks, these languages can be very powerful specifically in the area of Metaprogramming.

==What’s Next?==
In the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2010/ch4_4h next article for which the link does not exist yet], we will look at [http://en.wikipedia.org/wiki/Static_analysis static-analysis] tools for Ruby.

==References==

#Wikipedia.org, Metaprogramming, http://en.wikipedia.org/wiki/Metaprogramming
#Wikipedia.org, Dynamic Programming Languages, http://en.wikipedia.org/wiki/Dynamic_programming_language
#Wikipedia.org, Command Pattern, http://en.wikipedia.org/wiki/Command_pattern
#Wikipedia.org, Application Programming Interfaces (API's), http://en.wikipedia.org/wiki/Application_programming_interface
#Wikipedia.org, Static-Analysis, http://en.wikipedia.org/wiki/Static_analysis
#Tratt, L. 2005. Compile-time meta-programming in a dynamically typed OO language. In Proceedings of the 2005 Symposium on Dynamic Languages (San Diego, California, October 18 - 18, 2005). DLS '05. ACM, New York, NY, 49-63. http://doi.acm.org.www.lib.ncsu.edu:2048/10.1145/1146841.1146846
#Madsen, O.L.; Nogaard, C.; , "An object-oriented metaprogramming system," System Sciences, 1988. Vol.II. Software Track, Proceedings of the Twenty-First Annual Hawaii International Conference on , vol.2, no., pp.406-415, 5-8 Jan 1988, http://ieeexplore.ieee.org.www.lib.ncsu.edu:2048/stamp/stamp.jsp?tp=&arnumber=11831&isnumber=538

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-18T16:40:13Z

Mlwiles: /* References */

'''Metaprogramming in dynamically typed languages'''

----

==Introduction==
In the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2010/ch4_4f previous article for which the link does not exist yet], we learn that [http://en.wikipedia.org/wiki/Command_pattern 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 [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming]. In this article we take a closer look at metaprogramming in [http://en.wikipedia.org/wiki/Dynamic_programming_language 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 and plan for growth. Metaprogramming is ideal for several scenarios to include the use of [http://en.wikipedia.org/wiki/Application_programming_interface 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. Ideally metaprogramming has one main objective, to allow for new features.

==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') // Open the file for writing
f.write('#!/usr/bin/python \n')
for i in range(1, 100):
f.write('print' + i + '\n') // Write the string to a file
f.closed // Close the file

===JavaScript===
f = fopen('outputfile.js', 3); // Open the file for writing
if(f!=-1) { // If the file has been successfully opened
for (i=0;i<=100;i++) {
str = 'document.write' + i;
fwrite(f, str); // Write the string to a file
}
fclose(f); // Close the file
}

===Ruby===
f = File.open(outputfile.rb, 'w') // Open the file for writing
1.upto 100 do |i|
f.write("puts #{i}") // Write the string to a file
end
f.close // Close the file

==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

==Conclusion==
Dynamic languages are increasingly recognized for playing a major role in software development, specifically for quick prototyping because of the forgiveness of the languages letting requirements evolve. These languages are historically looked at as scripting languages that are inexpensive and not scalable. Allowing for these types of behavior comes at a price. The price is the potential for poor performance since the code is runtime optimized. Another downfall is that rapid development is great but the flexibility allowed between type conversions means that there is a higher probability for runtime errors. While understanding these limitation and accepting the risks, these languages can be very powerful specifically in the area of Metaprogramming.

==What’s Next?==
In the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2010/ch4_4h next article for which the link does not exist yet], we will look at [http://en.wikipedia.org/wiki/Static_analysis static-analysis] tools for Ruby.

==References==

#Wikipedia.org, Metaprogramming, http://en.wikipedia.org/wiki/Metaprogramming
#Wikipedia.org, Dynamic Programming Languages, http://en.wikipedia.org/wiki/Dynamic_programming_language
#Wikipedia.org, Command Pattern, http://en.wikipedia.org/wiki/Command_pattern
#Wikipedia.org, Application Programming Interfaces (API's), http://en.wikipedia.org/wiki/Application_programming_interface
#Wikipedia.org, Static-Analysis, http://en.wikipedia.org/wiki/Static_analysis
#Tratt, L. 2005. Compile-time meta-programming in a dynamically typed OO language. In Proceedings of the 2005 Symposium on Dynamic Languages (San Diego, California, October 18 - 18, 2005). DLS '05. ACM, New York, NY, 49-63. http://doi.acm.org.www.lib.ncsu.edu:2048/10.1145/1146841.1146846
#Madsen, O.L.; Nogaard, C.; , "An object-oriented metaprogramming system," System Sciences, 1988. Vol.II. Software Track, Proceedings of the Twenty-First Annual Hawaii International Conference on , vol.2, no., pp.406-415, 5-8 Jan 1988, http://ieeexplore.ieee.org.www.lib.ncsu.edu:2048/stamp/stamp.jsp?tp=&arnumber=11831&isnumber=538

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-18T16:38:55Z

Mlwiles: /* References */

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-18T16:38:41Z

Mlwiles: /* References */

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-18T16:36:50Z

Mlwiles: /* References */

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-18T16:27:35Z

Mlwiles: /* Conclusion */

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-18T16:20:54Z

Mlwiles: /* What is Metaprogramming? */

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-18T15:35:28Z

Mlwiles:

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-18T15:32:22Z

Mlwiles: /* Metaprogramming in some Dynamic Languages */

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-18T15:32:10Z

Mlwiles: /* What’s Next? */

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-18T15:25:28Z

Mlwiles: /* Conclusion */

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-18T15:16:25Z

Mlwiles: /* Example of Metaprogramming */

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-18T15:07:14Z

Mlwiles: /* JavaScript */

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-18T15:05:54Z

Mlwiles: /* Python */

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-18T03:37:24Z

Mlwiles: /* Metaprogramming in some Dynamic Languages */

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-18T03:24:51Z

Mlwiles: /* Metaprogramming in some Dynamic Languages */

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-18T03:24:11Z

Mlwiles: /* Metaprogramming in some Dynamic Languages */

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-18T03:18:00Z

Mlwiles: /* Metaprogramming in some Dynamic Languages */

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-18T02:57:06Z

Mlwiles: /* Example of Metaprogramming */

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-18T02:14:51Z

Mlwiles: /* Metaprogramming in some Dynamic Languages */

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-18T02:10:16Z

Mlwiles: /* Python */

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-18T02:08:13Z

Mlwiles: /* Python */

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-18T01:58:54Z

Mlwiles: /* Dynamic Typed Programming Languages */

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-18T01:54:58Z

Mlwiles: /* Dynamic Typed Programming Languages */

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-18T00:57:32Z

Mlwiles: /* Metaprogramming in some languages */

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-18T00:22:05Z

Mlwiles: /* Metaprogramming in some languages */

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-18T00:21:08Z

Mlwiles: /* JavaScript */

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-18T00:17:41Z

Mlwiles: /* Ruby */

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-18T00:17:29Z

Mlwiles: /* Python */

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-18T00:15:52Z

Mlwiles: /* Ruby */

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-18T00:15:34Z

Mlwiles: /* Example of Metaprogramming */

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-18T00:13:12Z

Mlwiles: /* Conclusion */

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-18T00:02:46Z

Mlwiles: /* Dynamic Programming Languages */

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-18T00:01:55Z

Mlwiles: /* Dynamic Programming Languages */

CSC/ECE 517 Fall 2010/ch4 4g km

2010-10-17T23:56:56Z

Mlwiles: /* What is Metaprogramming? */