Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Spring 2013/OSS E605A

2013-03-21T00:31:48Z

Drhowar5: added information about changes made to the copy method

=Expertiza Questionnaire Refactoring=

__TOC__

=Introduction=

This project involved refactoring the questionnaire portion of Expertiza. This part of the Expertiza project deals with the creation and management of questionnaires that are used during project review and feedback. It also allows for the creation of advice on what each score in a question should represent (a 5 being excellent, 3 being average, etc.). The majority of the refactoring took place in the file questionnaire_controller.rb, as it contains the CRUD functionality for questionnaires. Some refactoring also took place on the questionnaire.rb model, along with various different kinds of questionnaires that were represented as subclasses of questionnaire.rb.

=List of Changes=

Following is a list of the changes made during refactoring, along with the design principles and patterns that were upheld by making these changes.

==Pulled up get_weighted_score==

Each of the questionnaire subclasses had a get_weighted_score method that tallied up the points for a completed questionnaire. These methods were all identical, so we pulled the method up to the questionnaire superclass (questionnaire.rb). The following subclasses had the method and were refactored accordingly:

* author_feedback_questionnaire.rb
* metareview_questionnaire.rb
* review_questionnaire.rb
* teammate_review_questionnaire.rb
* questionnaire.rb (superclass that the method was moved to)

The main design principle that influenced this refactor was DRY. As the same functionality was used in multiple places, moving it to the superclass made the code easier to understand by showing that all of the subclasses were able to use the function in the same way.

==Renamed create_questionnaire and save_questionnaire==

The questionnaire_controller (questionnaire_controller.rb) contained CRUD functionality for several types of objects. Naturally, one of these objects was a questionnaire. For clarity, its methods had been named create_questionnaire and save_questionnaire. However, proper Ruby design emphasizes convention over configuration. Since the methods were in the questionnaire controller, the convention is to name them create and save, as the fact that they affect a questionnaire is implied. Therefore create_questionnaire (on line 156) was changed to create and save_questionnaire (on line 214) was changed to save.

==Pulled methods from edit==

The edit method in questionnaire_controller.rb did not need to be renamed, but it had another problem; the method was too long. Keeping methods short (around 25 lines or less) is another design principle that increases the readability of code. Therefore, we looked for chunks of the method that would make sense if pulled out as a separate method. Part of the edit method involved exporting and importing questionnaires. These chunks of code were well contained, with clear start and stop points, so we pulled them into separate methods. This resulted in creating an export method from lines 102-108 of the old edit method, and an import method from lines 110-125 of the old method. By doing this, the edit method was shortened to an acceptable length.

==Created advice_controller==

As mentioned above, the questionnaire controller contained some CRUD methods that dealt with another type of object besides questionnaires. This was the advice object, which is used to type notes regarding what score should be given on a question. Again, this violated the Ruby principle of convention over configuration, since these advice methods were in the questionnaire controller. Therefore, a new advice controller (advice_controller.rb) was created, and the edit_advice and save_advice methods were moved from the questionnaire controller to it.

==Removed delete_question_type==

The questionnaire_controller had a delete_question_type method that was only used when destroying the questions of a questionnaire. As it only consisted of two lines, and was only used in one place, we felt that having it in a separate method caused a minor, but unnecessary, case of the Ping-Pong effect. Since the code of the method was rather self-explanatory (simply finding the question type of the question to be deleted and destroying it), moving the functionality back into the delete_questions method and removing the delete_question_type method reduced the complexity of the code without affecting its readability or DRYness.

==Changes to the Copy Method==

The copy method was initially 78 lines long. After refactoring, the copy method is only 9 lines. We extracted 2 methods: getInstructorId, and cloneQuestionnaireDetails.

The getInstructorId method determines whether the person calling the copy method is a TA or an instructor. Then it returns the relevant instructor ID. This code was formerly implemented as a conditional statement within the copy method. Now it is one line of code that uses the ternary operator. The code is now easier to read, and easier to follow.

The cloneQuestionnaireDetails method loops through the questions and advice of the questionnaire that is being copied. Each question and its advice are copied over into the newly created questionnaire. This method is still a little long, but it was hard to break it down any smaller, without removing functionality that is essential to the method.

=References=

* [https://www.youtube.com/watch?v=XZzKb_PM07A Project Screencast]
* [https://github.com/expertiza/expertiza Main Expertiza Repository]
* [https://github.com/mlhall3/expertiza Refactored Expertiza Fork]

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-26T04:22:06Z

Drhowar5:

*Here is a [https://docs.google.com/a/ncsu.edu/document/d/1aER6f9EDFJaUMgSpK7g5nYPiMNoUjZzwQxzY0jMW8mI/edit link] to the writing assignment for this topic.
*Here is a [[CSC/ECE_517_Fall_2011/ch4_4g_as|link]] to previous work on this topic.
*The main purpose of this wiki entry is to provide insight into Dr. Gehringer's lecture on Metaprogramming in Ruby found at this [http://courses.ncsu.edu/csc517/common/media/08/Metaprogramming/Metaprogramming.html link]

== A Basic Definition of Metaprogramming ==

The most basic definition of metaprogramming is: ''writing code that writes or manipulates code.''
<ref name="Video Lecture on Metaprogramming by Dr. Gehringer">[http://courses.ncsu.edu/csc517/common/media/08/Metaprogramming/Metaprogramming.html Video]</ref>
<ref name="wiki metaprogramming">[http://en.wikipedia.org/wiki/Metaprogramming Wikipedia Article on Metaprogramming]</ref>

A metaprogram can either manipulate itself, or it can manipulate some other program.

:Below are three ''important terms'' associated with a metaprogramming<ref name="wiki metaprogramming">[http://en.wikipedia.org/wiki/Metaprogramming Wikipedia Article on Metaprogramming]</ref>:
::* [http://en.wikipedia.org/wiki/Metalanguage metalanguage] - the language in which a metaprogram is written
::* [http://en.wikipedia.org/wiki/Object_language object language] - the language of the program that is being manipulated by a metaprogram
::* [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflection] - the ability of a programming language to be its own metalanguage (also known as ''reflexivity'')

== Uses of Metaprogramming ==

Metaprogramming can allow programmers to write code that is more
concise and more flexible. It can be more concise because a program that can write code is able to generate more code than it is initially given. It can be more flexible, because it can allow the program to change the way it behaves without having to recompile.

:One of the best examples of metaprogramming is that of the [http://en.wikipedia.org/wiki/Compiler compiler]<ref>[http://c2.com/cgi/wiki?MetaProgramming Overview of Metaprogramming]</ref>. A compiler uses code written in one language in order to generate code that can be executed by a computer.

:Metaprogramming is also used for building frameworks such as [http://rubyonrails.org/ Ruby on Rails]. In this case, the use of [http://en.wikipedia.org/wiki/Convention_over_configuration convention over configuration] allows developers to write more concise and consistent code. Following specific conventions, developers write a relatively small amount of code. The Ruby on Rails [http://en.wikipedia.org/wiki/Scaffold_(programming) scaffold] uses the code the code written by the developer to generate code that is expansive, interconnected, and standardized.

:One of the most powerful uses for metaprogramming, is the ability to change a program during runtime. In languages such as Ruby and [http://groovy.codehaus.org/ Groovy], programmers can<ref>[http://blog.adaptivesoftware.biz/2009/02/what-is-metaprogramming.html Coding Insights Blog]</ref>:
::*Create a new class at runtime
::*Create new methods at runtime
::*Modify existing classes and/or methods at runtime
::*Respond to calls made on non-existent methods

== Features in Ruby that Enable Metaprogramming ==

*Ruby is a [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamically typed language]

::In dynamically typed languages, the majority of its type checking is performed at run-time, as opposed to compile time.<ref>[http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing Wikipedia Article on the Type System]</ref> Because variables are not type-checked until they are used in program execution, it is possible to use types that are created during program execution.

*Ruby is an [http://en.wikipedia.org/wiki/Interpreted_language interpreted language]
::Interpreted languages avoid explicit compilation<ref>[http://en.wikipedia.org/wiki/Interpreted_language Wikipeida Article on Interpreted Language]</ref>. Because Ruby is being interpreted as it is being executed, it is possible to create new classes and methods during program execution.

*Ruby classes are [http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle open]

::Most object-oriented programming languages adhere to the [http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle open/closed principle]<ref>[http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle Wikipedia Article on the Open/Closed Principle]</ref>. This means that the core components that are part of the language cannot be modified. In Ruby, the classes are open, meaning that all of the classes and methods be changed.

== Examples of Metaprogramming in Ruby ==

=== Creating a New Class at Runtime ===
Below is an example of creating a new class at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>3.times do
class MyClass
puts "MyClass defined"
end
end</code>
In example shown above, the <tt>times</tt> method is invoked on the <tt>3</tt> object. Inside of the <tt>times</tt> method call, the class <tt>MyClass</tt> is defined. <tt>MyClass</tt> is actually defined three times, once for each of the three iterations. Even though the class is defined three times, it has the same effect as only defining it once. The important thing to note here, is that a new class is defined at runtime, inside of a method call.

=== Modifying a Class at Runtime ===
Below is an example of modifying a class, and and example of creating a new method at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>3.times do
class MyClass
def one
puts "one"
end
end</code>
In the example shown above, the class <tt>MyClass</tt> is modified again to include a new method. This method, the <tt>one</tt> method is defined three times, just like the class is defined three times. Even though it has been defined three times, it has the same effect as only defining it once. The important thing to note here is that a new method is defined at runtime.

=== Creating a Method at Runtime ===
Below is an additional example of modifying a class at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>class MyClass
def two
puts "two"
end</code>
In the example shown above, the class<tt>MyClass</tt> is reopened and the <tt>two</tt> method is added to it.

Below is an example of what happens when the code written above is executed:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>
mc = MyClass.new
mc.one
mc.two
</code>
The output of the code will be:
<code>one
two</code>

=== Modifying a Method at Runtime ===

Below is an additional example of modifying a method at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>class MyClass
def two
puts "one two"
end</code>
In the example shown above, the <tt>two</tt> method is reopened and modified.

Below is an example of what happens when the modified code written above is executed:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>
mc = MyClass.new
mc.one
mc.two
</code>
The output of the code will be:
<code>one
one two</code>

=== Responding to a Non-Existent Method Call ===
Whenever a call to an undefined method is made on an object, Ruby provides an option to intercept the call. This is done by implementing the method method_missing within the class definition. Ruby passes, as parameters, the name of the method called and the arguments passed to it.

Define a module (or class) Roman. This class contains a method_missing method that intercepts calls to “class methods” that are undefined. It then tries to interpret the method name as a Roman numeral.
For example,
*evaluating Roman.xix calls the xix,method of module Roman.
*Roman has no xix method, so method_missing is invoked with xix as the argument.
*The id2name method of class Symbol is invoked on :xix, returning "xix".
*The "xix" is then parsed according to the rules for evaluating Roman numerals, and evaluates to 19.

class Roman
DIGITS = {
'I' => 1,
'V' => 5,
'X' => 10,
'L' => 50,
'C' => 100,
'D' => 500,
'M' => 1000,
}
def roman_to_integer(roman_string)
last = nil

roman_string.to_s.upcase.split(//).reverse.inject(0) do
|memo, digit|
if digit_value = DIGITS[digit]
if last && last > digit_value
memo -= digit_value
else
memo += digit_value
end
last = digit_value
end
memo
end
end
def method_missing(method)
str = method.id2name
roman_to_integer(str)
end

== Metaprogramming in Other Languages ==
===The C preprocessor (CPP)<ref>[http://www.ibm.com/developerworks/library/l-metaprog1/index.html The Art of Metaprogramming]</ref>===
First let's look at metaprogramming that involves textual macro languages. Textual macros are macros that directly affect the text of the programming language without knowing about or dealing with the meaning of the language.
=====The SWAP macro: =====
#define SWAP(a, b, type) {
type __tmp_c; c = b; b = a; a = c;
}

This macro allows you to swap the two values of the given type. A macro is effective in this situation because:
*A function call would take too much overhead for a simple operation
*The functions would require variables' addresses to be passed which is messier and prevents the compiler from keeping the values in registers.
*A different function would need to be coded for each type of item you wanted to swap.

#define SWAP(a, b, type) { type __tmp_c; c = b; b = a; a = c; }
int main()
{
int a = 3;
int b = 5;
printf("a is %d and b is %d\n", a, b);
SWAP(a, b, int);
printf("a is now %d and b is now %d\n", a, b);
return 0;
}

===Meta Programming in Java<ref>[http://www.cs.tut.fi/~kk/webstuff/MetaProgrammingJavaKalvot.pdf Metaprogramming in Java]</ref>===

The generics can be used in classes, interfaces, methods and constructors.
Two new types:
*Parametrized types
*Type variables
A type variable is an unqualified identifier.
Class and interface declarations can have type arguments (type variables)
*Metalevel: Class implements GenericsDeclaration
Method and constructors definitions can have type arguments (type variables)
*Metalevel: Method, Constructor implements GenericsDeclaration

public interface List<E> {
void add(E x);
Iterator<E> iterator();
}
public interface Iterator<E> {
E next();
boolean hasNext();
}
List<String> anExample;
anExample.add(”sdfdfss”);
anExample.add(new Object()); // compile time error
String aTest = anExample.iterator().next();

== References ==
<references/>

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-26T04:11:10Z

Drhowar5: removed abrupt content change

*Here is a [https://docs.google.com/a/ncsu.edu/document/d/1aER6f9EDFJaUMgSpK7g5nYPiMNoUjZzwQxzY0jMW8mI/edit link] to the writing assignment for this topic.
*Here is a [[CSC/ECE_517_Fall_2011/ch4_4g_as|link]] to previous work on this topic.

== A Basic Definition of Metaprogramming ==

The most basic definition of metaprogramming is: ''writing code that writes or manipulates code.''
<ref>[http://courses.ncsu.edu/csc517/common/media/08/Metaprogramming/Metaprogramming.html Video Lecture on Metaprogramming by Dr. Gehringer]</ref>
<ref name="wiki metaprogramming">[http://en.wikipedia.org/wiki/Metaprogramming Wikipedia Article on Metaprogramming]</ref>

A metaprogram can either manipulate itself, or it can manipulate some other program.

:Below are three ''important terms'' associated with a metaprogramming<ref name="wiki metaprogramming">[http://en.wikipedia.org/wiki/Metaprogramming Wikipedia Article on Metaprogramming]</ref>:
::* [http://en.wikipedia.org/wiki/Metalanguage metalanguage] - the language in which a metaprogram is written
::* [http://en.wikipedia.org/wiki/Object_language object language] - the language of the program that is being manipulated by a metaprogram
::* [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflection] - the ability of a programming language to be its own metalanguage (also known as ''reflexivity'')

== Uses of Metaprogramming ==

Metaprogramming can allow programmers to write code that is more
concise and more flexible. It can be more concise because a program that can write code is able to generate more code than it is initially given. It can be more flexible, because it can allow the program to change the way it behaves without having to recompile.

:One of the best examples of metaprogramming is that of the [http://en.wikipedia.org/wiki/Compiler compiler]<ref>[http://c2.com/cgi/wiki?MetaProgramming Overview of Metaprogramming]</ref>. A compiler uses code written in one language in order to generate code that can be executed by a computer.

:Metaprogramming is also used for building frameworks such as [http://rubyonrails.org/ Ruby on Rails]. In this case, the use of [http://en.wikipedia.org/wiki/Convention_over_configuration convention over configuration] allows developers to write more concise and consistent code. Following specific conventions, developers write a relatively small amount of code. The Ruby on Rails [http://en.wikipedia.org/wiki/Scaffold_(programming) scaffold] uses the code the code written by the developer to generate code that is expansive, interconnected, and standardized.

:One of the most powerful uses for metaprogramming, is the ability to change a program during runtime. In languages such as Ruby and [http://groovy.codehaus.org/ Groovy], programmers can<ref>[http://blog.adaptivesoftware.biz/2009/02/what-is-metaprogramming.html Coding Insights Blog]</ref>:
::*Create a new class at runtime
::*Create new methods at runtime
::*Modify existing classes and/or methods at runtime
::*Respond to calls made on non-existent methods

== Features in Ruby that Enable Metaprogramming ==

*Ruby is a [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamically typed language]

::In dynamically typed languages, the majority of its type checking is performed at run-time, as opposed to compile time.<ref>[http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing Wikipedia Article on the Type System]</ref> Because variables are not type-checked until they are used in program execution, it is possible to use types that are created during program execution.

*Ruby is an [http://en.wikipedia.org/wiki/Interpreted_language interpreted language]
::Interpreted languages avoid explicit compilation<ref>[http://en.wikipedia.org/wiki/Interpreted_language Wikipeida Article on Interpreted Language]</ref>. Because Ruby is being interpreted as it is being executed, it is possible to create new classes and methods during program execution.

*Ruby classes are [http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle open]

::Most object-oriented programming languages adhere to the [http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle open/closed principle]<ref>[http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle Wikipedia Article on the Open/Closed Principle]</ref>. This means that the core components that are part of the language cannot be modified. In Ruby, the classes are open, meaning that all of the classes and methods be changed.

== Examples of Metaprogramming in Ruby ==

=== Creating a New Class at Runtime ===
Below is an example of creating a new class at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>3.times do
class MyClass
puts "MyClass defined"
end
end</code>
In example shown above, the <tt>times</tt> method is invoked on the <tt>3</tt> object. Inside of the <tt>times</tt> method call, the class <tt>MyClass</tt> is defined. <tt>MyClass</tt> is actually defined three times, once for each of the three iterations. Even though the class is defined three times, it has the same effect as only defining it once. The important thing to note here, is that a new class is defined at runtime, inside of a method call.

=== Modifying a Class at Runtime ===
Below is an example of modifying a class, and and example of creating a new method at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>3.times do
class MyClass
def one
puts "one"
end
end</code>
In the example shown above, the class <tt>MyClass</tt> is modified again to include a new method. This method, the <tt>one</tt> method is defined three times, just like the class is defined three times. Even though it has been defined three times, it has the same effect as only defining it once. The important thing to note here is that a new method is defined at runtime.

=== Creating a Method at Runtime ===
Below is an additional example of modifying a class at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>class MyClass
def two
puts "two"
end</code>
In the example shown above, the class<tt>MyClass</tt> is reopened and the <tt>two</tt> method is added to it.

Below is an example of what happens when the code written above is executed:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>
mc = MyClass.new
mc.one
mc.two
</code>
The output of the code will be:
<code>one
two</code>

=== Modifying a Method at Runtime ===

Below is an additional example of modifying a method at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>class MyClass
def two
puts "one two"
end</code>
In the example shown above, the <tt>two</tt> method is reopened and modified.

Below is an example of what happens when the modified code written above is executed:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>
mc = MyClass.new
mc.one
mc.two
</code>
The output of the code will be:
<code>one
one two</code>

=== Responding to a Non-Existent Method Call ===
Whenever a call to an undefined method is made on an object, Ruby provides an option to intercept the call. This is done by implementing the method method_missing within the class definition. Ruby passes, as parameters, the name of the method called and the arguments passed to it.

Define a module (or class) Roman. This class contains a method_missing method that intercepts calls to “class methods” that are undefined. It then tries to interpret the method name as a Roman numeral.
For example,
*evaluating Roman.xix calls the xix,method of module Roman.
*Roman has no xix method, so method_missing is invoked with xix as the argument.
*The id2name method of class Symbol is invoked on :xix, returning "xix".
*The "xix" is then parsed according to the rules for evaluating Roman numerals, and evaluates to 19.

class Roman
DIGITS = {
'I' => 1,
'V' => 5,
'X' => 10,
'L' => 50,
'C' => 100,
'D' => 500,
'M' => 1000,
}
def roman_to_integer(roman_string)
last = nil

roman_string.to_s.upcase.split(//).reverse.inject(0) do
|memo, digit|
if digit_value = DIGITS[digit]
if last && last > digit_value
memo -= digit_value
else
memo += digit_value
end
last = digit_value
end
memo
end
end
def method_missing(method)
str = method.id2name
roman_to_integer(str)
end

== Metaprogramming in Other Languages ==
===The C preprocessor (CPP)<ref>[http://www.ibm.com/developerworks/library/l-metaprog1/index.html The Art of Metaprogramming]</ref>===
First let's look at metaprogramming that involves textual macro languages. Textual macros are macros that directly affect the text of the programming language without knowing about or dealing with the meaning of the language.
=====The SWAP macro: =====
#define SWAP(a, b, type) {
type __tmp_c; c = b; b = a; a = c;
}

This macro allows you to swap the two values of the given type. A macro is effective in this situation because:
*A function call would take too much overhead for a simple operation
*The functions would require variables' addresses to be passed which is messier and prevents the compiler from keeping the values in registers.
*A different function would need to be coded for each type of item you wanted to swap.

#define SWAP(a, b, type) { type __tmp_c; c = b; b = a; a = c; }
int main()
{
int a = 3;
int b = 5;
printf("a is %d and b is %d\n", a, b);
SWAP(a, b, int);
printf("a is now %d and b is now %d\n", a, b);
return 0;
}

===Meta Programming in Java<ref>[http://www.cs.tut.fi/~kk/webstuff/MetaProgrammingJavaKalvot.pdf Metaprogramming in Java]</ref>===

The generics can be used in classes, interfaces, methods and constructors.
Two new types:
*Parametrized types
*Type variables
A type variable is an unqualified identifier.
Class and interface declarations can have type arguments (type variables)
*Metalevel: Class implements GenericsDeclaration
Method and constructors definitions can have type arguments (type variables)
*Metalevel: Method, Constructor implements GenericsDeclaration

public interface List<E> {
void add(E x);
Iterator<E> iterator();
}
public interface Iterator<E> {
E next();
boolean hasNext();
}
List<String> anExample;
anExample.add(”sdfdfss”);
anExample.add(new Object()); // compile time error
String aTest = anExample.iterator().next();

== References ==
<references/>

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-21T04:20:29Z

Drhowar5: /* Metaprogramming in Other Languages */

*Here is a [https://docs.google.com/a/ncsu.edu/document/d/1aER6f9EDFJaUMgSpK7g5nYPiMNoUjZzwQxzY0jMW8mI/edit link] to the writing assignment for this topic.
*Here is a [[CSC/ECE_517_Fall_2011/ch4_4g_as|link]] to previous work on this topic.

== A Basic Definition of Metaprogramming ==

The most basic definition of metaprogramming is: ''writing code that writes or manipulates code.''
<ref>[http://courses.ncsu.edu/csc517/common/media/08/Metaprogramming/Metaprogramming.html Video Lecture on Metaprogramming by Dr. Gehringer]</ref>
<ref name="wiki metaprogramming">[http://en.wikipedia.org/wiki/Metaprogramming Wikipedia Article on Metaprogramming]</ref>

A metaprogram can either manipulate itself, or it can manipulate some other program.

:Below are three ''important terms'' associated with a metaprogramming<ref name="wiki metaprogramming">[http://en.wikipedia.org/wiki/Metaprogramming Wikipedia Article on Metaprogramming]</ref>:
::* [http://en.wikipedia.org/wiki/Metalanguage metalanguage] - the language in which a metaprogram is written
::* [http://en.wikipedia.org/wiki/Object_language object language] - the language of the program that is being manipulated by a metaprogram
::* [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflection] - the ability of a programming language to be its own metalanguage (also known as ''reflexivity'')

== Uses of Metaprogramming ==

Metaprogramming can allow programmers to write code that is more
concise and more flexible. It can be more concise because a program that can write code is able to generate more code than it is initially given. It can be more flexible, because it can allow the program to change the way it behaves without having to recompile.

:One of the best examples of metaprogramming is that of the [http://en.wikipedia.org/wiki/Compiler compiler]<ref>[http://c2.com/cgi/wiki?MetaProgramming Overview of Metaprogramming]</ref>. A compiler uses code written in one language in order to generate code that can be executed by a computer.

:Metaprogramming is also used for building frameworks such as [http://rubyonrails.org/ Ruby on Rails]. In this case, the use of [http://en.wikipedia.org/wiki/Convention_over_configuration convention over configuration] allows developers to write more concise and consistent code. Following specific conventions, developers write a relatively small amount of code. The Ruby on Rails [http://en.wikipedia.org/wiki/Scaffold_(programming) scaffold] uses the code the code written by the developer to generate code that is expansive, interconnected, and standardized.

:One of the most powerful uses for metaprogramming, is the ability to change a program during runtime. In languages such as Ruby and [http://groovy.codehaus.org/ Groovy], programmers can<ref>[http://blog.adaptivesoftware.biz/2009/02/what-is-metaprogramming.html Coding Insights Blog]</ref>:
::*Create a new class at runtime
::*Create new methods at runtime
::*Modify existing classes and/or methods at runtime
::*Respond to calls made on non-existent methods

== Features in Ruby that Enable Metaprogramming ==

*Ruby is a [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamically typed language]

::In dynamically typed languages, the majority of its type checking is performed at run-time, as opposed to compile time.<ref>[http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing Wikipedia Article on the Type System]</ref> Because variables are not type-checked until they are used in program execution, it is possible to use types that are created during program execution.

*Ruby is an [http://en.wikipedia.org/wiki/Interpreted_language interpreted language]
::Interpreted languages avoid explicit compilation<ref>[http://en.wikipedia.org/wiki/Interpreted_language Wikipeida Article on Interpreted Language]</ref>. Because Ruby is being interpreted as it is being executed, it is possible to create new classes and methods during program execution.

*Ruby classes are [http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle open]

::Most object-oriented programming languages adhere to the [http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle open/closed principle]<ref>[http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle Wikipedia Article on the Open/Closed Principle]</ref>. This means that the core components that are part of the language cannot be modified. In Ruby, the classes are open, meaning that all of the classes and methods be changed.

== Examples of Metaprogramming in Ruby ==

=== Creating a New Class at Runtime ===
Below is an example of creating a new class at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>3.times do
class MyClass
puts "MyClass defined"
end
end</code>
In example shown above, the <tt>times</tt> method is invoked on the <tt>3</tt> object. Inside of the <tt>times</tt> method call, the class <tt>MyClass</tt> is defined. <tt>MyClass</tt> is actually defined three times, once for each of the three iterations. Even though the class is defined three times, it has the same effect as only defining it once. The important thing to note here, is that a new class is defined at runtime, inside of a method call.

=== Modifying a Class at Runtime ===
Below is an example of modifying a class, and and example of creating a new method at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>3.times do
class MyClass
def one
puts "one"
end
end</code>
In the example shown above, the class <tt>MyClass</tt> is modified again to include a new method. This method, the <tt>one</tt> method is defined three times, just like the class is defined three times. Even though it has been defined three times, it has the same effect as only defining it once. The important thing to note here is that a new method is defined at runtime.

=== Creating a Method at Runtime ===
Below is an additional example of modifying a class at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>class MyClass
def two
puts "two"
end</code>
In the example shown above, the class<tt>MyClass</tt> is reopened and the <tt>two</tt> method is added to it.

Below is an example of what happens when the code written above is executed:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>
mc = MyClass.new
mc.one
mc.two
</code>
The output of the code will be:
<code>one
two</code>

=== Modifying a Method at Runtime ===

Below is an additional example of modifying a method at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>class MyClass
def two
puts "one two"
end</code>
In the example shown above, the <tt>two</tt> method is reopened and modified.

Below is an example of what happens when the modified code written above is executed:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>
mc = MyClass.new
mc.one
mc.two
</code>
The output of the code will be:
<code>one
one two</code>

=== Responding to a Non-Existent Method Call ===
Whenever a call to an undefined method is made on an object, Ruby provides an option to intercept the call. This is done by implementing the method method_missing within the class definition. Ruby passes as parameters the name of the method called and the arguments passed to it. Another interesting use of method_missing can be found on the Web by looking for “Roman method_missing”. Define a module (or class) Roman. This class contains a method_missing method that intercepts calls to “class methods” that are undefined. It then tries to interpret the method name as a Roman numeral.
For example,
*evaluating Roman.xix calls the xix,method of module Roman.
*Roman has no xix method, so method_missing is invoked with xix as the argument.
*The id2name method of class Symbol is invoked on :xix, returning "xix".
*The "xix" is then parsed according to the rules for evaluating Roman numerals, and evaluates to 19.

class Roman
DIGITS = {
'I' => 1,
'V' => 5,
'X' => 10,
'L' => 50,
'C' => 100,
'D' => 500,
'M' => 1000,
}
def roman_to_integer(roman_string)
last = nil

roman_string.to_s.upcase.split(//).reverse.inject(0) do
|memo, digit|
if digit_value = DIGITS[digit]
if last && last > digit_value
memo -= digit_value
else
memo += digit_value
end
last = digit_value
end
memo
end
end
def method_missing(method)
str = method.id2name
roman_to_integer(str)
end

=== Additional Examples of Ruby Metaprogramming ===

Ruby has several metaprogramming facilities. One can create new class and add methods to it using "define_method"<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
c = Class.new
c.class_eval do
define_method :hi do
puts "Hey"
end
c.new.hi
>>Hey

This technique allows you to add any type of new code and modify behavior of a program at run time.
Another example, adding attr_accessor to all classes:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
Object.class_eval do
class << self
def attribute_accessor( *instance_variables )
instance_variables.each do |instance_variable|
class_eval %Q?
def #{instance_variable}
@#{instance_variable}
end
def #{instance_variable}=( new_value )
@#{instance_variable} = new_value
end
?
end
end
end
end

== Metaprogramming in Other Languages ==
===The C preprocessor (CPP)<ref>[http://www.ibm.com/developerworks/library/l-metaprog1/index.html The Art of Metaprogramming]</ref>===
First let's look at metaprogramming that involves textual macro languages. Textual macros are macros that directly affect the text of the programming language without knowing about or dealing with the meaning of the language.
=====The SWAP macro: =====
#define SWAP(a, b, type) {
type __tmp_c; c = b; b = a; a = c;
}

This macro allows you to swap the two values of the given type. A macro is effective in this situation because:
*A function call would take too much overhead for a simple operation
*The functions would require variables' addresses to be passed which is messier and prevents the compiler from keeping the values in registers.
*A different function would need to be coded for each type of item you wanted to swap.

#define SWAP(a, b, type) { type __tmp_c; c = b; b = a; a = c; }
int main()
{
int a = 3;
int b = 5;
printf("a is %d and b is %d\n", a, b);
SWAP(a, b, int);
printf("a is now %d and b is now %d\n", a, b);
return 0;
}

=====The MIN macro: =====
#define MIN(x, y) ((x) > (y) ? (y) : (x))

This macro returns the the minimum of two values.

===Meta Programming in Java<ref>[http://www.cs.tut.fi/~kk/webstuff/MetaProgrammingJavaKalvot.pdf Metaprogramming in Java]</ref>===

The generics can be used in classes, interfaces, methods and constructors.
Two new types:
*Parametrized types
*Type variables
A type variable is an unqualified identifier.
Class and interface declarations can have type arguments (type variables)
*Metalevel: Class implements GenericsDeclaration
Method and constructors definitions can have type arguments (type variables)
*Metalevel: Method, Constructor implements GenericsDeclaration

public interface List<E> {
void add(E x);
Iterator<E> iterator();
}
public interface Iterator<E> {
E next();
boolean hasNext();
}
List<String> anExample;
anExample.add(”sdfdfss”);
anExample.add(new Object()); // compile time error
String aTest = anExample.iterator().next();

== References ==
<references/>

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-21T04:20:01Z

Drhowar5: /* Responding to a Non-Existent Method Call */

*Here is a [https://docs.google.com/a/ncsu.edu/document/d/1aER6f9EDFJaUMgSpK7g5nYPiMNoUjZzwQxzY0jMW8mI/edit link] to the writing assignment for this topic.
*Here is a [[CSC/ECE_517_Fall_2011/ch4_4g_as|link]] to previous work on this topic.

== A Basic Definition of Metaprogramming ==

The most basic definition of metaprogramming is: ''writing code that writes or manipulates code.''
<ref>[http://courses.ncsu.edu/csc517/common/media/08/Metaprogramming/Metaprogramming.html Video Lecture on Metaprogramming by Dr. Gehringer]</ref>
<ref name="wiki metaprogramming">[http://en.wikipedia.org/wiki/Metaprogramming Wikipedia Article on Metaprogramming]</ref>

A metaprogram can either manipulate itself, or it can manipulate some other program.

:Below are three ''important terms'' associated with a metaprogramming<ref name="wiki metaprogramming">[http://en.wikipedia.org/wiki/Metaprogramming Wikipedia Article on Metaprogramming]</ref>:
::* [http://en.wikipedia.org/wiki/Metalanguage metalanguage] - the language in which a metaprogram is written
::* [http://en.wikipedia.org/wiki/Object_language object language] - the language of the program that is being manipulated by a metaprogram
::* [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflection] - the ability of a programming language to be its own metalanguage (also known as ''reflexivity'')

== Uses of Metaprogramming ==

Metaprogramming can allow programmers to write code that is more
concise and more flexible. It can be more concise because a program that can write code is able to generate more code than it is initially given. It can be more flexible, because it can allow the program to change the way it behaves without having to recompile.

:One of the best examples of metaprogramming is that of the [http://en.wikipedia.org/wiki/Compiler compiler]<ref>[http://c2.com/cgi/wiki?MetaProgramming Overview of Metaprogramming]</ref>. A compiler uses code written in one language in order to generate code that can be executed by a computer.

:Metaprogramming is also used for building frameworks such as [http://rubyonrails.org/ Ruby on Rails]. In this case, the use of [http://en.wikipedia.org/wiki/Convention_over_configuration convention over configuration] allows developers to write more concise and consistent code. Following specific conventions, developers write a relatively small amount of code. The Ruby on Rails [http://en.wikipedia.org/wiki/Scaffold_(programming) scaffold] uses the code the code written by the developer to generate code that is expansive, interconnected, and standardized.

:One of the most powerful uses for metaprogramming, is the ability to change a program during runtime. In languages such as Ruby and [http://groovy.codehaus.org/ Groovy], programmers can<ref>[http://blog.adaptivesoftware.biz/2009/02/what-is-metaprogramming.html Coding Insights Blog]</ref>:
::*Create a new class at runtime
::*Create new methods at runtime
::*Modify existing classes and/or methods at runtime
::*Respond to calls made on non-existent methods

== Features in Ruby that Enable Metaprogramming ==

*Ruby is a [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamically typed language]

::In dynamically typed languages, the majority of its type checking is performed at run-time, as opposed to compile time.<ref>[http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing Wikipedia Article on the Type System]</ref> Because variables are not type-checked until they are used in program execution, it is possible to use types that are created during program execution.

*Ruby is an [http://en.wikipedia.org/wiki/Interpreted_language interpreted language]
::Interpreted languages avoid explicit compilation<ref>[http://en.wikipedia.org/wiki/Interpreted_language Wikipeida Article on Interpreted Language]</ref>. Because Ruby is being interpreted as it is being executed, it is possible to create new classes and methods during program execution.

*Ruby classes are [http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle open]

::Most object-oriented programming languages adhere to the [http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle open/closed principle]<ref>[http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle Wikipedia Article on the Open/Closed Principle]</ref>. This means that the core components that are part of the language cannot be modified. In Ruby, the classes are open, meaning that all of the classes and methods be changed.

== Examples of Metaprogramming in Ruby ==

=== Creating a New Class at Runtime ===
Below is an example of creating a new class at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>3.times do
class MyClass
puts "MyClass defined"
end
end</code>
In example shown above, the <tt>times</tt> method is invoked on the <tt>3</tt> object. Inside of the <tt>times</tt> method call, the class <tt>MyClass</tt> is defined. <tt>MyClass</tt> is actually defined three times, once for each of the three iterations. Even though the class is defined three times, it has the same effect as only defining it once. The important thing to note here, is that a new class is defined at runtime, inside of a method call.

=== Modifying a Class at Runtime ===
Below is an example of modifying a class, and and example of creating a new method at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>3.times do
class MyClass
def one
puts "one"
end
end</code>
In the example shown above, the class <tt>MyClass</tt> is modified again to include a new method. This method, the <tt>one</tt> method is defined three times, just like the class is defined three times. Even though it has been defined three times, it has the same effect as only defining it once. The important thing to note here is that a new method is defined at runtime.

=== Creating a Method at Runtime ===
Below is an additional example of modifying a class at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>class MyClass
def two
puts "two"
end</code>
In the example shown above, the class<tt>MyClass</tt> is reopened and the <tt>two</tt> method is added to it.

Below is an example of what happens when the code written above is executed:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>
mc = MyClass.new
mc.one
mc.two
</code>
The output of the code will be:
<code>one
two</code>

=== Modifying a Method at Runtime ===

Below is an additional example of modifying a method at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>class MyClass
def two
puts "one two"
end</code>
In the example shown above, the <tt>two</tt> method is reopened and modified.

Below is an example of what happens when the modified code written above is executed:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>
mc = MyClass.new
mc.one
mc.two
</code>
The output of the code will be:
<code>one
one two</code>

=== Responding to a Non-Existent Method Call ===
Whenever a call to an undefined method is made on an object, Ruby provides an option to intercept the call. This is done by implementing the method method_missing within the class definition. Ruby passes as parameters the name of the method called and the arguments passed to it. Another interesting use of method_missing can be found on the Web by looking for “Roman method_missing”. Define a module (or class) Roman. This class contains a method_missing method that intercepts calls to “class methods” that are undefined. It then tries to interpret the method name as a Roman numeral.
For example,
*evaluating Roman.xix calls the xix,method of module Roman.
*Roman has no xix method, so method_missing is invoked with xix as the argument.
*The id2name method of class Symbol is invoked on :xix, returning "xix".
*The "xix" is then parsed according to the rules for evaluating Roman numerals, and evaluates to 19.

class Roman
DIGITS = {
'I' => 1,
'V' => 5,
'X' => 10,
'L' => 50,
'C' => 100,
'D' => 500,
'M' => 1000,
}
def roman_to_integer(roman_string)
last = nil

roman_string.to_s.upcase.split(//).reverse.inject(0) do
|memo, digit|
if digit_value = DIGITS[digit]
if last && last > digit_value
memo -= digit_value
else
memo += digit_value
end
last = digit_value
end
memo
end
end
def method_missing(method)
str = method.id2name
roman_to_integer(str)
end

=== Additional Examples of Ruby Metaprogramming ===

Ruby has several metaprogramming facilities. One can create new class and add methods to it using "define_method"<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
c = Class.new
c.class_eval do
define_method :hi do
puts "Hey"
end
c.new.hi
>>Hey

This technique allows you to add any type of new code and modify behavior of a program at run time.
Another example, adding attr_accessor to all classes:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
Object.class_eval do
class << self
def attribute_accessor( *instance_variables )
instance_variables.each do |instance_variable|
class_eval %Q?
def #{instance_variable}
@#{instance_variable}
end
def #{instance_variable}=( new_value )
@#{instance_variable} = new_value
end
?
end
end
end
end

== Metaprogramming in Other Languages ==
===The C preprocessor (CPP)<ref>[http://www.ibm.com/developerworks/library/l-metaprog1/index.html The Art of Metaprogramming]</ref>===
First let's look at metaprogramming that involves textual macro languages. Textual macros are macros that directly affect the text of the programming language without knowing about or dealing with the meaning of the language.
=====The SWAP macro: =====
#define SWAP(a, b, type) {
type __tmp_c; c = b; b = a; a = c;
}

This macro allows you to swap the two values of the given type. A macro is effective in this situation because:
*A function call would take too much overhead for a simple operation
*The functions would require variables' addresses to be passed which is messier and prevents the compiler from keeping the values in registers.
*A different function would need to be coded for each type of item you wanted to swap.

#define SWAP(a, b, type) { type __tmp_c; c = b; b = a; a = c; }
int main()
{
int a = 3;
int b = 5;
printf("a is %d and b is %d\n", a, b);
SWAP(a, b, int);
printf("a is now %d and b is now %d\n", a, b);
return 0;
}

=====The MIN macro: =====
#define MIN(x, y) ((x) > (y) ? (y) : (x))

This macro returns the the minimum of two values.

===Meta Programming in Java<ref>[http://www.cs.tut.fi/~kk/webstuff/MetaProgrammingJavaKalvot.pdf Metaprogramming in Java]</ref>===

The generics can be used in classes, interfaces, methods and constructors.
Two new types:
*Parametrized types
*Type variables
A type variable is an unqualified identifier.
Class and interface declarations can have type arguments (type variables)
*Metalevel: Class implements GenericsDeclaration
Method and constructors definitions can have type arguments (type variables)
*Metalevel: Method, Constructor implements GenericsDeclaration

public interface List<E> {
void add(E x);
Iterator<E> iterator();
}
public interface Iterator<E> {
E next();
boolean hasNext();
}
List<String> anExample;
anExample.add(”sdfdfss”);
anExample.add(new Object()); // compile time error
String aTest = anExample.iterator().next();

== References ==
<references/>

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-21T03:38:59Z

Drhowar5: /* Responding to a Non-Existent Method Call */

*Here is a [https://docs.google.com/a/ncsu.edu/document/d/1aER6f9EDFJaUMgSpK7g5nYPiMNoUjZzwQxzY0jMW8mI/edit link] to the writing assignment for this topic.
*Here is a [[CSC/ECE_517_Fall_2011/ch4_4g_as|link]] to previous work on this topic.

== A Basic Definition of Metaprogramming ==

The most basic definition of metaprogramming is: ''writing code that writes or manipulates code.''
<ref>[http://courses.ncsu.edu/csc517/common/media/08/Metaprogramming/Metaprogramming.html Video Lecture on Metaprogramming by Dr. Gehringer]</ref>
<ref name="wiki metaprogramming">[http://en.wikipedia.org/wiki/Metaprogramming Wikipedia Article on Metaprogramming]</ref>

A metaprogram can either manipulate itself, or it can manipulate some other program.

:Below are three ''important terms'' associated with a metaprogramming<ref name="wiki metaprogramming">[http://en.wikipedia.org/wiki/Metaprogramming Wikipedia Article on Metaprogramming]</ref>:
::* [http://en.wikipedia.org/wiki/Metalanguage metalanguage] - the language in which a metaprogram is written
::* [http://en.wikipedia.org/wiki/Object_language object language] - the language of the program that is being manipulated by a metaprogram
::* [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflection] - the ability of a programming language to be its own metalanguage (also known as ''reflexivity'')

== Uses of Metaprogramming ==

Metaprogramming can allow programmers to write code that is more
concise and more flexible. It can be more concise because a program that can write code is able to generate more code than it is initially given. It can be more flexible, because it can allow the program to change the way it behaves without having to recompile.

:One of the best examples of metaprogramming is that of the [http://en.wikipedia.org/wiki/Compiler compiler]<ref>[http://c2.com/cgi/wiki?MetaProgramming Overview of Metaprogramming]</ref>. A compiler uses code written in one language in order to generate code that can be executed by a computer.

:Metaprogramming is also used for building frameworks such as [http://rubyonrails.org/ Ruby on Rails]. In this case, the use of [http://en.wikipedia.org/wiki/Convention_over_configuration convention over configuration] allows developers to write more concise and consistent code. Following specific conventions, developers write a relatively small amount of code. The Ruby on Rails [http://en.wikipedia.org/wiki/Scaffold_(programming) scaffold] uses the code the code written by the developer to generate code that is expansive, interconnected, and standardized.

:One of the most powerful uses for metaprogramming, is the ability to change a program during runtime. In languages such as Ruby and [http://groovy.codehaus.org/ Groovy], programmers can<ref>[http://blog.adaptivesoftware.biz/2009/02/what-is-metaprogramming.html Coding Insights Blog]</ref>:
::*Create a new class at runtime
::*Create new methods at runtime
::*Modify existing classes and/or methods at runtime
::*Respond to calls made on non-existent methods

== Features in Ruby that Enable Metaprogramming ==

*Ruby is a [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamically typed language]

::In dynamically typed languages, the majority of its type checking is performed at run-time, as opposed to compile time.<ref>[http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing Wikipedia Article on the Type System]</ref> Because variables are not type-checked until they are used in program execution, it is possible to use types that are created during program execution.

*Ruby is an [http://en.wikipedia.org/wiki/Interpreted_language interpreted language]
::Interpreted languages avoid explicit compilation<ref>[http://en.wikipedia.org/wiki/Interpreted_language Wikipeida Article on Interpreted Language]</ref>. Because Ruby is being interpreted as it is being executed, it is possible to create new classes and methods during program execution.

*Ruby classes are [http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle open]

::Most object-oriented programming languages adhere to the [http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle open/closed principle]<ref>[http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle Wikipedia Article on the Open/Closed Principle]</ref>. This means that the core components that are part of the language cannot be modified. In Ruby, the classes are open, meaning that all of the classes and methods be changed.

== Examples of Metaprogramming in Ruby ==

=== Creating a New Class at Runtime ===
Below is an example of creating a new class at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>3.times do
class MyClass
puts "MyClass defined"
end
end</code>
In example shown above, the <tt>times</tt> method is invoked on the <tt>3</tt> object. Inside of the <tt>times</tt> method call, the class <tt>MyClass</tt> is defined. <tt>MyClass</tt> is actually defined three times, once for each of the three iterations. Even though the class is defined three times, it has the same effect as only defining it once. The important thing to note here, is that a new class is defined at runtime, inside of a method call.

=== Modifying a Class at Runtime ===
Below is an example of modifying a class, and and example of creating a new method at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>3.times do
class MyClass
def one
puts "one"
end
end</code>
In the example shown above, the class <tt>MyClass</tt> is modified again to include a new method. This method, the <tt>one</tt> method is defined three times, just like the class is defined three times. Even though it has been defined three times, it has the same effect as only defining it once. The important thing to note here is that a new method is defined at runtime.

=== Creating a Method at Runtime ===
Below is an additional example of modifying a class at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>class MyClass
def two
puts "two"
end</code>
In the example shown above, the class<tt>MyClass</tt> is reopened and the <tt>two</tt> method is added to it.

Below is an example of what happens when the code written above is executed:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>
mc = MyClass.new
mc.one
mc.two
</code>
The output of the code will be:
<code>one
two</code>

=== Modifying a Method at Runtime ===

Below is an additional example of modifying a method at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>class MyClass
def two
puts "one two"
end</code>
In the example shown above, the <tt>two</tt> method is reopened and modified.

Below is an example of what happens when the modified code written above is executed:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>
mc = MyClass.new
mc.one
mc.two
</code>
The output of the code will be:
<code>one
one two</code>

=== Responding to a Non-Existent Method Call ===

Ruby has several metaprogramming facilities. One can create new class and add methods to it using "define_method"<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
c = Class.new
c.class_eval do
define_method :hi do
puts "Hey"
end
c.new.hi
>>Hey

This technique allows you to add any type of new code and modify behavior of a program at run time.
Another example, adding attr_accessor to all classes:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
Object.class_eval do
class << self
def attribute_accessor( *instance_variables )
instance_variables.each do |instance_variable|
class_eval %Q?
def #{instance_variable}
@#{instance_variable}
end
def #{instance_variable}=( new_value )
@#{instance_variable} = new_value
end
?
end
end
end
end

== Metaprogramming in Other Languages ==
===The C preprocessor (CPP)<ref>[http://www.ibm.com/developerworks/library/l-metaprog1/index.html The Art of Metaprogramming]</ref>===
First let's look at metaprogramming that involves textual macro languages. Textual macros are macros that directly affect the text of the programming language without knowing about or dealing with the meaning of the language.
=====The SWAP macro: =====
#define SWAP(a, b, type) {
type __tmp_c; c = b; b = a; a = c;
}

This macro allows you to swap the two values of the given type. A macro is effective in this situation because:
*A function call would take too much overhead for a simple operation
*The functions would require variables' addresses to be passed which is messier and prevents the compiler from keeping the values in registers.
*A different function would need to be coded for each type of item you wanted to swap.

#define SWAP(a, b, type) { type __tmp_c; c = b; b = a; a = c; }
int main()
{
int a = 3;
int b = 5;
printf("a is %d and b is %d\n", a, b);
SWAP(a, b, int);
printf("a is now %d and b is now %d\n", a, b);
return 0;
}

=====The MIN macro: =====
#define MIN(x, y) ((x) > (y) ? (y) : (x))

This macro returns the the minimum of two values.

== References ==
<references/>

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-21T03:38:44Z

Drhowar5: /* Modifying a Method at Runtime */

*Here is a [https://docs.google.com/a/ncsu.edu/document/d/1aER6f9EDFJaUMgSpK7g5nYPiMNoUjZzwQxzY0jMW8mI/edit link] to the writing assignment for this topic.
*Here is a [[CSC/ECE_517_Fall_2011/ch4_4g_as|link]] to previous work on this topic.

== A Basic Definition of Metaprogramming ==

The most basic definition of metaprogramming is: ''writing code that writes or manipulates code.''
<ref>[http://courses.ncsu.edu/csc517/common/media/08/Metaprogramming/Metaprogramming.html Video Lecture on Metaprogramming by Dr. Gehringer]</ref>
<ref name="wiki metaprogramming">[http://en.wikipedia.org/wiki/Metaprogramming Wikipedia Article on Metaprogramming]</ref>

A metaprogram can either manipulate itself, or it can manipulate some other program.

:Below are three ''important terms'' associated with a metaprogramming<ref name="wiki metaprogramming">[http://en.wikipedia.org/wiki/Metaprogramming Wikipedia Article on Metaprogramming]</ref>:
::* [http://en.wikipedia.org/wiki/Metalanguage metalanguage] - the language in which a metaprogram is written
::* [http://en.wikipedia.org/wiki/Object_language object language] - the language of the program that is being manipulated by a metaprogram
::* [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflection] - the ability of a programming language to be its own metalanguage (also known as ''reflexivity'')

== Uses of Metaprogramming ==

Metaprogramming can allow programmers to write code that is more
concise and more flexible. It can be more concise because a program that can write code is able to generate more code than it is initially given. It can be more flexible, because it can allow the program to change the way it behaves without having to recompile.

:One of the best examples of metaprogramming is that of the [http://en.wikipedia.org/wiki/Compiler compiler]<ref>[http://c2.com/cgi/wiki?MetaProgramming Overview of Metaprogramming]</ref>. A compiler uses code written in one language in order to generate code that can be executed by a computer.

:Metaprogramming is also used for building frameworks such as [http://rubyonrails.org/ Ruby on Rails]. In this case, the use of [http://en.wikipedia.org/wiki/Convention_over_configuration convention over configuration] allows developers to write more concise and consistent code. Following specific conventions, developers write a relatively small amount of code. The Ruby on Rails [http://en.wikipedia.org/wiki/Scaffold_(programming) scaffold] uses the code the code written by the developer to generate code that is expansive, interconnected, and standardized.

:One of the most powerful uses for metaprogramming, is the ability to change a program during runtime. In languages such as Ruby and [http://groovy.codehaus.org/ Groovy], programmers can<ref>[http://blog.adaptivesoftware.biz/2009/02/what-is-metaprogramming.html Coding Insights Blog]</ref>:
::*Create a new class at runtime
::*Create new methods at runtime
::*Modify existing classes and/or methods at runtime
::*Respond to calls made on non-existent methods

== Features in Ruby that Enable Metaprogramming ==

*Ruby is a [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamically typed language]

::In dynamically typed languages, the majority of its type checking is performed at run-time, as opposed to compile time.<ref>[http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing Wikipedia Article on the Type System]</ref> Because variables are not type-checked until they are used in program execution, it is possible to use types that are created during program execution.

*Ruby is an [http://en.wikipedia.org/wiki/Interpreted_language interpreted language]
::Interpreted languages avoid explicit compilation<ref>[http://en.wikipedia.org/wiki/Interpreted_language Wikipeida Article on Interpreted Language]</ref>. Because Ruby is being interpreted as it is being executed, it is possible to create new classes and methods during program execution.

*Ruby classes are [http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle open]

::Most object-oriented programming languages adhere to the [http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle open/closed principle]<ref>[http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle Wikipedia Article on the Open/Closed Principle]</ref>. This means that the core components that are part of the language cannot be modified. In Ruby, the classes are open, meaning that all of the classes and methods be changed.

== Examples of Metaprogramming in Ruby ==

=== Creating a New Class at Runtime ===
Below is an example of creating a new class at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>3.times do
class MyClass
puts "MyClass defined"
end
end</code>
In example shown above, the <tt>times</tt> method is invoked on the <tt>3</tt> object. Inside of the <tt>times</tt> method call, the class <tt>MyClass</tt> is defined. <tt>MyClass</tt> is actually defined three times, once for each of the three iterations. Even though the class is defined three times, it has the same effect as only defining it once. The important thing to note here, is that a new class is defined at runtime, inside of a method call.

=== Modifying a Class at Runtime ===
Below is an example of modifying a class, and and example of creating a new method at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>3.times do
class MyClass
def one
puts "one"
end
end</code>
In the example shown above, the class <tt>MyClass</tt> is modified again to include a new method. This method, the <tt>one</tt> method is defined three times, just like the class is defined three times. Even though it has been defined three times, it has the same effect as only defining it once. The important thing to note here is that a new method is defined at runtime.

=== Creating a Method at Runtime ===
Below is an additional example of modifying a class at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>class MyClass
def two
puts "two"
end</code>
In the example shown above, the class<tt>MyClass</tt> is reopened and the <tt>two</tt> method is added to it.

Below is an example of what happens when the code written above is executed:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>
mc = MyClass.new
mc.one
mc.two
</code>
The output of the code will be:
<code>one
two</code>

=== Modifying a Method at Runtime ===

Below is an additional example of modifying a method at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>class MyClass
def two
puts "one two"
end</code>
In the example shown above, the <tt>two</tt> method is reopened and modified.

Below is an example of what happens when the modified code written above is executed:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>
mc = MyClass.new
mc.one
mc.two
</code>
The output of the code will be:
<code>one
one two</code>

=== Responding to a Non-Existent Method Call ===

Ruby has several metaprogramming facilities. One can create new class and add methods to it using "define_method"<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
c = Class.new
c.class_eval do
define_method :hi do
puts "Hey"
end
c.new.hi
>>Hey

This technique allows you to add any type of new code and modify behavior of a program at run time.
Another example, adding attr_accessor to all classes:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
Object.class_eval do
class << self
def attribute_accessor( *instance_variables )
instance_variables.each do |instance_variable|
class_eval %Q?
def #{instance_variable}
@#{instance_variable}
end
def #{instance_variable}=( new_value )
@#{instance_variable} = new_value
end
?
end
end
end
end

== Metaprogramming in Other Languages ==
===The C preprocessor (CPP)<ref>[http://www.ibm.com/developerworks/library/l-metaprog1/index.html The Art of Metaprogramming]</ref>===
First let's look at metaprogramming that involves textual macro languages. Textual macros are macros that directly affect the text of the programming language without knowing about or dealing with the meaning of the language.
=====The SWAP macro: =====
#define SWAP(a, b, type) {
type __tmp_c; c = b; b = a; a = c;
}

This macro allows you to swap the two values of the given type. A macro is effective in this situation because:
*A function call would take too much overhead for a simple operation
*The functions would require variables' addresses to be passed which is messier and prevents the compiler from keeping the values in registers.
*A different function would need to be coded for each type of item you wanted to swap.

#define SWAP(a, b, type) { type __tmp_c; c = b; b = a; a = c; }
int main()
{
int a = 3;
int b = 5;
printf("a is %d and b is %d\n", a, b);
SWAP(a, b, int);
printf("a is now %d and b is now %d\n", a, b);
return 0;
}

=====The MIN macro: =====
#define MIN(x, y) ((x) > (y) ? (y) : (x))

This macro returns the the minimum of two values.

== References ==
<references/>

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-21T03:38:26Z

Drhowar5: /* Creating a Method at Runtime */

*Here is a [https://docs.google.com/a/ncsu.edu/document/d/1aER6f9EDFJaUMgSpK7g5nYPiMNoUjZzwQxzY0jMW8mI/edit link] to the writing assignment for this topic.
*Here is a [[CSC/ECE_517_Fall_2011/ch4_4g_as|link]] to previous work on this topic.

== A Basic Definition of Metaprogramming ==

The most basic definition of metaprogramming is: ''writing code that writes or manipulates code.''
<ref>[http://courses.ncsu.edu/csc517/common/media/08/Metaprogramming/Metaprogramming.html Video Lecture on Metaprogramming by Dr. Gehringer]</ref>
<ref name="wiki metaprogramming">[http://en.wikipedia.org/wiki/Metaprogramming Wikipedia Article on Metaprogramming]</ref>

A metaprogram can either manipulate itself, or it can manipulate some other program.

:Below are three ''important terms'' associated with a metaprogramming<ref name="wiki metaprogramming">[http://en.wikipedia.org/wiki/Metaprogramming Wikipedia Article on Metaprogramming]</ref>:
::* [http://en.wikipedia.org/wiki/Metalanguage metalanguage] - the language in which a metaprogram is written
::* [http://en.wikipedia.org/wiki/Object_language object language] - the language of the program that is being manipulated by a metaprogram
::* [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflection] - the ability of a programming language to be its own metalanguage (also known as ''reflexivity'')

== Uses of Metaprogramming ==

Metaprogramming can allow programmers to write code that is more
concise and more flexible. It can be more concise because a program that can write code is able to generate more code than it is initially given. It can be more flexible, because it can allow the program to change the way it behaves without having to recompile.

:One of the best examples of metaprogramming is that of the [http://en.wikipedia.org/wiki/Compiler compiler]<ref>[http://c2.com/cgi/wiki?MetaProgramming Overview of Metaprogramming]</ref>. A compiler uses code written in one language in order to generate code that can be executed by a computer.

:Metaprogramming is also used for building frameworks such as [http://rubyonrails.org/ Ruby on Rails]. In this case, the use of [http://en.wikipedia.org/wiki/Convention_over_configuration convention over configuration] allows developers to write more concise and consistent code. Following specific conventions, developers write a relatively small amount of code. The Ruby on Rails [http://en.wikipedia.org/wiki/Scaffold_(programming) scaffold] uses the code the code written by the developer to generate code that is expansive, interconnected, and standardized.

:One of the most powerful uses for metaprogramming, is the ability to change a program during runtime. In languages such as Ruby and [http://groovy.codehaus.org/ Groovy], programmers can<ref>[http://blog.adaptivesoftware.biz/2009/02/what-is-metaprogramming.html Coding Insights Blog]</ref>:
::*Create a new class at runtime
::*Create new methods at runtime
::*Modify existing classes and/or methods at runtime
::*Respond to calls made on non-existent methods

== Features in Ruby that Enable Metaprogramming ==

*Ruby is a [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamically typed language]

::In dynamically typed languages, the majority of its type checking is performed at run-time, as opposed to compile time.<ref>[http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing Wikipedia Article on the Type System]</ref> Because variables are not type-checked until they are used in program execution, it is possible to use types that are created during program execution.

*Ruby is an [http://en.wikipedia.org/wiki/Interpreted_language interpreted language]
::Interpreted languages avoid explicit compilation<ref>[http://en.wikipedia.org/wiki/Interpreted_language Wikipeida Article on Interpreted Language]</ref>. Because Ruby is being interpreted as it is being executed, it is possible to create new classes and methods during program execution.

*Ruby classes are [http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle open]

::Most object-oriented programming languages adhere to the [http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle open/closed principle]<ref>[http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle Wikipedia Article on the Open/Closed Principle]</ref>. This means that the core components that are part of the language cannot be modified. In Ruby, the classes are open, meaning that all of the classes and methods be changed.

== Examples of Metaprogramming in Ruby ==

=== Creating a New Class at Runtime ===
Below is an example of creating a new class at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>3.times do
class MyClass
puts "MyClass defined"
end
end</code>
In example shown above, the <tt>times</tt> method is invoked on the <tt>3</tt> object. Inside of the <tt>times</tt> method call, the class <tt>MyClass</tt> is defined. <tt>MyClass</tt> is actually defined three times, once for each of the three iterations. Even though the class is defined three times, it has the same effect as only defining it once. The important thing to note here, is that a new class is defined at runtime, inside of a method call.

=== Modifying a Class at Runtime ===
Below is an example of modifying a class, and and example of creating a new method at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>3.times do
class MyClass
def one
puts "one"
end
end</code>
In the example shown above, the class <tt>MyClass</tt> is modified again to include a new method. This method, the <tt>one</tt> method is defined three times, just like the class is defined three times. Even though it has been defined three times, it has the same effect as only defining it once. The important thing to note here is that a new method is defined at runtime.

=== Creating a Method at Runtime ===
Below is an additional example of modifying a class at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>class MyClass
def two
puts "two"
end</code>
In the example shown above, the class<tt>MyClass</tt> is reopened and the <tt>two</tt> method is added to it.

Below is an example of what happens when the code written above is executed:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>
mc = MyClass.new
mc.one
mc.two
</code>
The output of the code will be:
<code>one
two</code>

=== Modifying a Method at Runtime ===

Below is an additional example of modifying a method at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>class MyClass
def two
puts "one two"
end</code>
In the example shown above, the <tt>two</tt> method is reopened and modified.

Below is an example of what happens when the modified code written above is executed:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>
mc = MyClass.new
mc.one
mc.two
</code>
The output of the code will be:
<code>one
one two</code>

=== Responding to a Non-Existent Method Call ===

Ruby has several metaprogramming facilities. One can create new class and add methods to it using "define_method"<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
c = Class.new
c.class_eval do
define_method :hi do
puts "Hey"
end
c.new.hi
>>Hey

This technique allows you to add any type of new code and modify behavior of a program at run time.
Another example, adding attr_accessor to all classes:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
Object.class_eval do
class << self
def attribute_accessor( *instance_variables )
instance_variables.each do |instance_variable|
class_eval %Q?
def #{instance_variable}
@#{instance_variable}
end
def #{instance_variable}=( new_value )
@#{instance_variable} = new_value
end
?
end
end
end
end

== Metaprogramming in Other Languages ==
===The C preprocessor (CPP)<ref>[http://www.ibm.com/developerworks/library/l-metaprog1/index.html The Art of Metaprogramming]</ref>===
First let's look at metaprogramming that involves textual macro languages. Textual macros are macros that directly affect the text of the programming language without knowing about or dealing with the meaning of the language.
=====The SWAP macro: =====
#define SWAP(a, b, type) {
type __tmp_c; c = b; b = a; a = c;
}

This macro allows you to swap the two values of the given type. A macro is effective in this situation because:
*A function call would take too much overhead for a simple operation
*The functions would require variables' addresses to be passed which is messier and prevents the compiler from keeping the values in registers.
*A different function would need to be coded for each type of item you wanted to swap.

#define SWAP(a, b, type) { type __tmp_c; c = b; b = a; a = c; }
int main()
{
int a = 3;
int b = 5;
printf("a is %d and b is %d\n", a, b);
SWAP(a, b, int);
printf("a is now %d and b is now %d\n", a, b);
return 0;
}

=====The MIN macro: =====
#define MIN(x, y) ((x) > (y) ? (y) : (x))

This macro returns the the minimum of two values.

== References ==
<references/>

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-21T03:38:11Z

Drhowar5: /* Creating a Method at Runtime */

*Here is a [https://docs.google.com/a/ncsu.edu/document/d/1aER6f9EDFJaUMgSpK7g5nYPiMNoUjZzwQxzY0jMW8mI/edit link] to the writing assignment for this topic.
*Here is a [[CSC/ECE_517_Fall_2011/ch4_4g_as|link]] to previous work on this topic.

== A Basic Definition of Metaprogramming ==

The most basic definition of metaprogramming is: ''writing code that writes or manipulates code.''
<ref>[http://courses.ncsu.edu/csc517/common/media/08/Metaprogramming/Metaprogramming.html Video Lecture on Metaprogramming by Dr. Gehringer]</ref>
<ref name="wiki metaprogramming">[http://en.wikipedia.org/wiki/Metaprogramming Wikipedia Article on Metaprogramming]</ref>

A metaprogram can either manipulate itself, or it can manipulate some other program.

:Below are three ''important terms'' associated with a metaprogramming<ref name="wiki metaprogramming">[http://en.wikipedia.org/wiki/Metaprogramming Wikipedia Article on Metaprogramming]</ref>:
::* [http://en.wikipedia.org/wiki/Metalanguage metalanguage] - the language in which a metaprogram is written
::* [http://en.wikipedia.org/wiki/Object_language object language] - the language of the program that is being manipulated by a metaprogram
::* [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflection] - the ability of a programming language to be its own metalanguage (also known as ''reflexivity'')

== Uses of Metaprogramming ==

Metaprogramming can allow programmers to write code that is more
concise and more flexible. It can be more concise because a program that can write code is able to generate more code than it is initially given. It can be more flexible, because it can allow the program to change the way it behaves without having to recompile.

:One of the best examples of metaprogramming is that of the [http://en.wikipedia.org/wiki/Compiler compiler]<ref>[http://c2.com/cgi/wiki?MetaProgramming Overview of Metaprogramming]</ref>. A compiler uses code written in one language in order to generate code that can be executed by a computer.

:Metaprogramming is also used for building frameworks such as [http://rubyonrails.org/ Ruby on Rails]. In this case, the use of [http://en.wikipedia.org/wiki/Convention_over_configuration convention over configuration] allows developers to write more concise and consistent code. Following specific conventions, developers write a relatively small amount of code. The Ruby on Rails [http://en.wikipedia.org/wiki/Scaffold_(programming) scaffold] uses the code the code written by the developer to generate code that is expansive, interconnected, and standardized.

:One of the most powerful uses for metaprogramming, is the ability to change a program during runtime. In languages such as Ruby and [http://groovy.codehaus.org/ Groovy], programmers can<ref>[http://blog.adaptivesoftware.biz/2009/02/what-is-metaprogramming.html Coding Insights Blog]</ref>:
::*Create a new class at runtime
::*Create new methods at runtime
::*Modify existing classes and/or methods at runtime
::*Respond to calls made on non-existent methods

== Features in Ruby that Enable Metaprogramming ==

*Ruby is a [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamically typed language]

::In dynamically typed languages, the majority of its type checking is performed at run-time, as opposed to compile time.<ref>[http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing Wikipedia Article on the Type System]</ref> Because variables are not type-checked until they are used in program execution, it is possible to use types that are created during program execution.

*Ruby is an [http://en.wikipedia.org/wiki/Interpreted_language interpreted language]
::Interpreted languages avoid explicit compilation<ref>[http://en.wikipedia.org/wiki/Interpreted_language Wikipeida Article on Interpreted Language]</ref>. Because Ruby is being interpreted as it is being executed, it is possible to create new classes and methods during program execution.

*Ruby classes are [http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle open]

::Most object-oriented programming languages adhere to the [http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle open/closed principle]<ref>[http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle Wikipedia Article on the Open/Closed Principle]</ref>. This means that the core components that are part of the language cannot be modified. In Ruby, the classes are open, meaning that all of the classes and methods be changed.

== Examples of Metaprogramming in Ruby ==

=== Creating a New Class at Runtime ===
Below is an example of creating a new class at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>3.times do
class MyClass
puts "MyClass defined"
end
end</code>
In example shown above, the <tt>times</tt> method is invoked on the <tt>3</tt> object. Inside of the <tt>times</tt> method call, the class <tt>MyClass</tt> is defined. <tt>MyClass</tt> is actually defined three times, once for each of the three iterations. Even though the class is defined three times, it has the same effect as only defining it once. The important thing to note here, is that a new class is defined at runtime, inside of a method call.

=== Modifying a Class at Runtime ===
Below is an example of modifying a class, and and example of creating a new method at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>3.times do
class MyClass
def one
puts "one"
end
end</code>
In the example shown above, the class <tt>MyClass</tt> is modified again to include a new method. This method, the <tt>one</tt> method is defined three times, just like the class is defined three times. Even though it has been defined three times, it has the same effect as only defining it once. The important thing to note here is that a new method is defined at runtime.

=== Creating a Method at Runtime ===
Below is an additional example of modifying a class at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>class MyClass
def two
puts "two"
end</code>
In the example shown above, the class<tt>MyClass</tt> is reopened and the <tt>two</tt> method is added to it.

Below is an example of what happens when the code written above is executed:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>
mc = MyClass.new
mc.one
mc.two
</code>
The output of the code will be:
<code>one
two</code>

=== Modifying a Method at Runtime ===

Below is an additional example of modifying a method at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>class MyClass
def two
puts "one two"
end</code>
In the example shown above, the <tt>two</tt> method is reopened and modified.

Below is an example of what happens when the modified code written above is executed:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>
mc = MyClass.new
mc.one
mc.two
</code>
The output of the code will be:
<code>one
one two</code>

=== Responding to a Non-Existent Method Call ===

Ruby has several metaprogramming facilities. One can create new class and add methods to it using "define_method"<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
c = Class.new
c.class_eval do
define_method :hi do
puts "Hey"
end
c.new.hi
>>Hey

This technique allows you to add any type of new code and modify behavior of a program at run time.
Another example, adding attr_accessor to all classes:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
Object.class_eval do
class << self
def attribute_accessor( *instance_variables )
instance_variables.each do |instance_variable|
class_eval %Q?
def #{instance_variable}
@#{instance_variable}
end
def #{instance_variable}=( new_value )
@#{instance_variable} = new_value
end
?
end
end
end
end

== Metaprogramming in Other Languages ==
===The C preprocessor (CPP)<ref>[http://www.ibm.com/developerworks/library/l-metaprog1/index.html The Art of Metaprogramming]</ref>===
First let's look at metaprogramming that involves textual macro languages. Textual macros are macros that directly affect the text of the programming language without knowing about or dealing with the meaning of the language.
=====The SWAP macro: =====
#define SWAP(a, b, type) {
type __tmp_c; c = b; b = a; a = c;
}

This macro allows you to swap the two values of the given type. A macro is effective in this situation because:
*A function call would take too much overhead for a simple operation
*The functions would require variables' addresses to be passed which is messier and prevents the compiler from keeping the values in registers.
*A different function would need to be coded for each type of item you wanted to swap.

#define SWAP(a, b, type) { type __tmp_c; c = b; b = a; a = c; }
int main()
{
int a = 3;
int b = 5;
printf("a is %d and b is %d\n", a, b);
SWAP(a, b, int);
printf("a is now %d and b is now %d\n", a, b);
return 0;
}

=====The MIN macro: =====
#define MIN(x, y) ((x) > (y) ? (y) : (x))

This macro returns the the minimum of two values.

== References ==
<references/>

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-21T03:37:56Z

Drhowar5: /* Modifying a Class at Runtime */

*Here is a [https://docs.google.com/a/ncsu.edu/document/d/1aER6f9EDFJaUMgSpK7g5nYPiMNoUjZzwQxzY0jMW8mI/edit link] to the writing assignment for this topic.
*Here is a [[CSC/ECE_517_Fall_2011/ch4_4g_as|link]] to previous work on this topic.

== A Basic Definition of Metaprogramming ==

The most basic definition of metaprogramming is: ''writing code that writes or manipulates code.''
<ref>[http://courses.ncsu.edu/csc517/common/media/08/Metaprogramming/Metaprogramming.html Video Lecture on Metaprogramming by Dr. Gehringer]</ref>
<ref name="wiki metaprogramming">[http://en.wikipedia.org/wiki/Metaprogramming Wikipedia Article on Metaprogramming]</ref>

A metaprogram can either manipulate itself, or it can manipulate some other program.

:Below are three ''important terms'' associated with a metaprogramming<ref name="wiki metaprogramming">[http://en.wikipedia.org/wiki/Metaprogramming Wikipedia Article on Metaprogramming]</ref>:
::* [http://en.wikipedia.org/wiki/Metalanguage metalanguage] - the language in which a metaprogram is written
::* [http://en.wikipedia.org/wiki/Object_language object language] - the language of the program that is being manipulated by a metaprogram
::* [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflection] - the ability of a programming language to be its own metalanguage (also known as ''reflexivity'')

== Uses of Metaprogramming ==

Metaprogramming can allow programmers to write code that is more
concise and more flexible. It can be more concise because a program that can write code is able to generate more code than it is initially given. It can be more flexible, because it can allow the program to change the way it behaves without having to recompile.

:One of the best examples of metaprogramming is that of the [http://en.wikipedia.org/wiki/Compiler compiler]<ref>[http://c2.com/cgi/wiki?MetaProgramming Overview of Metaprogramming]</ref>. A compiler uses code written in one language in order to generate code that can be executed by a computer.

:Metaprogramming is also used for building frameworks such as [http://rubyonrails.org/ Ruby on Rails]. In this case, the use of [http://en.wikipedia.org/wiki/Convention_over_configuration convention over configuration] allows developers to write more concise and consistent code. Following specific conventions, developers write a relatively small amount of code. The Ruby on Rails [http://en.wikipedia.org/wiki/Scaffold_(programming) scaffold] uses the code the code written by the developer to generate code that is expansive, interconnected, and standardized.

:One of the most powerful uses for metaprogramming, is the ability to change a program during runtime. In languages such as Ruby and [http://groovy.codehaus.org/ Groovy], programmers can<ref>[http://blog.adaptivesoftware.biz/2009/02/what-is-metaprogramming.html Coding Insights Blog]</ref>:
::*Create a new class at runtime
::*Create new methods at runtime
::*Modify existing classes and/or methods at runtime
::*Respond to calls made on non-existent methods

== Features in Ruby that Enable Metaprogramming ==

*Ruby is a [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamically typed language]

::In dynamically typed languages, the majority of its type checking is performed at run-time, as opposed to compile time.<ref>[http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing Wikipedia Article on the Type System]</ref> Because variables are not type-checked until they are used in program execution, it is possible to use types that are created during program execution.

*Ruby is an [http://en.wikipedia.org/wiki/Interpreted_language interpreted language]
::Interpreted languages avoid explicit compilation<ref>[http://en.wikipedia.org/wiki/Interpreted_language Wikipeida Article on Interpreted Language]</ref>. Because Ruby is being interpreted as it is being executed, it is possible to create new classes and methods during program execution.

*Ruby classes are [http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle open]

::Most object-oriented programming languages adhere to the [http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle open/closed principle]<ref>[http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle Wikipedia Article on the Open/Closed Principle]</ref>. This means that the core components that are part of the language cannot be modified. In Ruby, the classes are open, meaning that all of the classes and methods be changed.

== Examples of Metaprogramming in Ruby ==

=== Creating a New Class at Runtime ===
Below is an example of creating a new class at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>3.times do
class MyClass
puts "MyClass defined"
end
end</code>
In example shown above, the <tt>times</tt> method is invoked on the <tt>3</tt> object. Inside of the <tt>times</tt> method call, the class <tt>MyClass</tt> is defined. <tt>MyClass</tt> is actually defined three times, once for each of the three iterations. Even though the class is defined three times, it has the same effect as only defining it once. The important thing to note here, is that a new class is defined at runtime, inside of a method call.

=== Modifying a Class at Runtime ===
Below is an example of modifying a class, and and example of creating a new method at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>3.times do
class MyClass
def one
puts "one"
end
end</code>
In the example shown above, the class <tt>MyClass</tt> is modified again to include a new method. This method, the <tt>one</tt> method is defined three times, just like the class is defined three times. Even though it has been defined three times, it has the same effect as only defining it once. The important thing to note here is that a new method is defined at runtime.

=== Creating a Method at Runtime ===
Below is an additional example of modifying a class at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>class MyClass
def two
puts "two"
end</code>
In the example shown above, the class<tt>MyClass</tt> is reopened and the <tt>two</tt> method is added to it.

Below is an example of what happens when the code written above is executed:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>
mc = MyClass.new
mc.one
mc.two
</code>
The output of the code will be:
<code>one
two</code>

=== Modifying a Method at Runtime ===

Below is an additional example of modifying a method at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>class MyClass
def two
puts "one two"
end</code>
In the example shown above, the <tt>two</tt> method is reopened and modified.

Below is an example of what happens when the modified code written above is executed:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>
mc = MyClass.new
mc.one
mc.two
</code>
The output of the code will be:
<code>one
one two</code>

=== Responding to a Non-Existent Method Call ===

Ruby has several metaprogramming facilities. One can create new class and add methods to it using "define_method"<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
c = Class.new
c.class_eval do
define_method :hi do
puts "Hey"
end
c.new.hi
>>Hey

This technique allows you to add any type of new code and modify behavior of a program at run time.
Another example, adding attr_accessor to all classes:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
Object.class_eval do
class << self
def attribute_accessor( *instance_variables )
instance_variables.each do |instance_variable|
class_eval %Q?
def #{instance_variable}
@#{instance_variable}
end
def #{instance_variable}=( new_value )
@#{instance_variable} = new_value
end
?
end
end
end
end

== Metaprogramming in Other Languages ==
===The C preprocessor (CPP)<ref>[http://www.ibm.com/developerworks/library/l-metaprog1/index.html The Art of Metaprogramming]</ref>===
First let's look at metaprogramming that involves textual macro languages. Textual macros are macros that directly affect the text of the programming language without knowing about or dealing with the meaning of the language.
=====The SWAP macro: =====
#define SWAP(a, b, type) {
type __tmp_c; c = b; b = a; a = c;
}

This macro allows you to swap the two values of the given type. A macro is effective in this situation because:
*A function call would take too much overhead for a simple operation
*The functions would require variables' addresses to be passed which is messier and prevents the compiler from keeping the values in registers.
*A different function would need to be coded for each type of item you wanted to swap.

#define SWAP(a, b, type) { type __tmp_c; c = b; b = a; a = c; }
int main()
{
int a = 3;
int b = 5;
printf("a is %d and b is %d\n", a, b);
SWAP(a, b, int);
printf("a is now %d and b is now %d\n", a, b);
return 0;
}

=====The MIN macro: =====
#define MIN(x, y) ((x) > (y) ? (y) : (x))

This macro returns the the minimum of two values.

== References ==
<references/>

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-21T03:37:42Z

Drhowar5: /* Examples of Metaprogramming in Ruby */

*Here is a [https://docs.google.com/a/ncsu.edu/document/d/1aER6f9EDFJaUMgSpK7g5nYPiMNoUjZzwQxzY0jMW8mI/edit link] to the writing assignment for this topic.
*Here is a [[CSC/ECE_517_Fall_2011/ch4_4g_as|link]] to previous work on this topic.

== A Basic Definition of Metaprogramming ==

The most basic definition of metaprogramming is: ''writing code that writes or manipulates code.''
<ref>[http://courses.ncsu.edu/csc517/common/media/08/Metaprogramming/Metaprogramming.html Video Lecture on Metaprogramming by Dr. Gehringer]</ref>
<ref name="wiki metaprogramming">[http://en.wikipedia.org/wiki/Metaprogramming Wikipedia Article on Metaprogramming]</ref>

A metaprogram can either manipulate itself, or it can manipulate some other program.

:Below are three ''important terms'' associated with a metaprogramming<ref name="wiki metaprogramming">[http://en.wikipedia.org/wiki/Metaprogramming Wikipedia Article on Metaprogramming]</ref>:
::* [http://en.wikipedia.org/wiki/Metalanguage metalanguage] - the language in which a metaprogram is written
::* [http://en.wikipedia.org/wiki/Object_language object language] - the language of the program that is being manipulated by a metaprogram
::* [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflection] - the ability of a programming language to be its own metalanguage (also known as ''reflexivity'')

== Uses of Metaprogramming ==

Metaprogramming can allow programmers to write code that is more
concise and more flexible. It can be more concise because a program that can write code is able to generate more code than it is initially given. It can be more flexible, because it can allow the program to change the way it behaves without having to recompile.

:One of the best examples of metaprogramming is that of the [http://en.wikipedia.org/wiki/Compiler compiler]<ref>[http://c2.com/cgi/wiki?MetaProgramming Overview of Metaprogramming]</ref>. A compiler uses code written in one language in order to generate code that can be executed by a computer.

:Metaprogramming is also used for building frameworks such as [http://rubyonrails.org/ Ruby on Rails]. In this case, the use of [http://en.wikipedia.org/wiki/Convention_over_configuration convention over configuration] allows developers to write more concise and consistent code. Following specific conventions, developers write a relatively small amount of code. The Ruby on Rails [http://en.wikipedia.org/wiki/Scaffold_(programming) scaffold] uses the code the code written by the developer to generate code that is expansive, interconnected, and standardized.

:One of the most powerful uses for metaprogramming, is the ability to change a program during runtime. In languages such as Ruby and [http://groovy.codehaus.org/ Groovy], programmers can<ref>[http://blog.adaptivesoftware.biz/2009/02/what-is-metaprogramming.html Coding Insights Blog]</ref>:
::*Create a new class at runtime
::*Create new methods at runtime
::*Modify existing classes and/or methods at runtime
::*Respond to calls made on non-existent methods

== Features in Ruby that Enable Metaprogramming ==

*Ruby is a [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamically typed language]

::In dynamically typed languages, the majority of its type checking is performed at run-time, as opposed to compile time.<ref>[http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing Wikipedia Article on the Type System]</ref> Because variables are not type-checked until they are used in program execution, it is possible to use types that are created during program execution.

*Ruby is an [http://en.wikipedia.org/wiki/Interpreted_language interpreted language]
::Interpreted languages avoid explicit compilation<ref>[http://en.wikipedia.org/wiki/Interpreted_language Wikipeida Article on Interpreted Language]</ref>. Because Ruby is being interpreted as it is being executed, it is possible to create new classes and methods during program execution.

*Ruby classes are [http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle open]

::Most object-oriented programming languages adhere to the [http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle open/closed principle]<ref>[http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle Wikipedia Article on the Open/Closed Principle]</ref>. This means that the core components that are part of the language cannot be modified. In Ruby, the classes are open, meaning that all of the classes and methods be changed.

== Examples of Metaprogramming in Ruby ==

=== Creating a New Class at Runtime ===
Below is an example of creating a new class at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>3.times do
class MyClass
puts "MyClass defined"
end
end</code>
In example shown above, the <tt>times</tt> method is invoked on the <tt>3</tt> object. Inside of the <tt>times</tt> method call, the class <tt>MyClass</tt> is defined. <tt>MyClass</tt> is actually defined three times, once for each of the three iterations. Even though the class is defined three times, it has the same effect as only defining it once. The important thing to note here, is that a new class is defined at runtime, inside of a method call.

=== Modifying a Class at Runtime ===
Below is an example of modifying a class, and and example of creating a new method at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>3.times do
class MyClass
def one
puts "one"
end
end</code>
In the example shown above, the class <tt>MyClass</tt> is modified again to include a new method. This method, the <tt>one</tt> method is defined three times, just like the class is defined three times. Even though it has been defined three times, it has the same effect as only defining it once. The important thing to note here is that a new method is defined at runtime.

=== Creating a Method at Runtime ===
Below is an additional example of modifying a class at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>class MyClass
def two
puts "two"
end</code>
In the example shown above, the class<tt>MyClass</tt> is reopened and the <tt>two</tt> method is added to it.

Below is an example of what happens when the code written above is executed:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>
mc = MyClass.new
mc.one
mc.two
</code>
The output of the code will be:
<code>one
two</code>

=== Modifying a Method at Runtime ===

Below is an additional example of modifying a method at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>class MyClass
def two
puts "one two"
end</code>
In the example shown above, the <tt>two</tt> method is reopened and modified.

Below is an example of what happens when the modified code written above is executed:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>
mc = MyClass.new
mc.one
mc.two
</code>
The output of the code will be:
<code>one
one two</code>

=== Responding to a Non-Existent Method Call ===

Ruby has several metaprogramming facilities. One can create new class and add methods to it using "define_method"<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
c = Class.new
c.class_eval do
define_method :hi do
puts "Hey"
end
c.new.hi
>>Hey

This technique allows you to add any type of new code and modify behavior of a program at run time.
Another example, adding attr_accessor to all classes:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
Object.class_eval do
class << self
def attribute_accessor( *instance_variables )
instance_variables.each do |instance_variable|
class_eval %Q?
def #{instance_variable}
@#{instance_variable}
end
def #{instance_variable}=( new_value )
@#{instance_variable} = new_value
end
?
end
end
end
end

== Metaprogramming in Other Languages ==
===The C preprocessor (CPP)<ref>[http://www.ibm.com/developerworks/library/l-metaprog1/index.html The Art of Metaprogramming]</ref>===
First let's look at metaprogramming that involves textual macro languages. Textual macros are macros that directly affect the text of the programming language without knowing about or dealing with the meaning of the language.
=====The SWAP macro: =====
#define SWAP(a, b, type) {
type __tmp_c; c = b; b = a; a = c;
}

This macro allows you to swap the two values of the given type. A macro is effective in this situation because:
*A function call would take too much overhead for a simple operation
*The functions would require variables' addresses to be passed which is messier and prevents the compiler from keeping the values in registers.
*A different function would need to be coded for each type of item you wanted to swap.

#define SWAP(a, b, type) { type __tmp_c; c = b; b = a; a = c; }
int main()
{
int a = 3;
int b = 5;
printf("a is %d and b is %d\n", a, b);
SWAP(a, b, int);
printf("a is now %d and b is now %d\n", a, b);
return 0;
}

=====The MIN macro: =====
#define MIN(x, y) ((x) > (y) ? (y) : (x))

This macro returns the the minimum of two values.

== References ==
<references/>

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-21T03:37:31Z

Drhowar5: /* Features in Ruby that Enable Metaprogramming */

*Here is a [https://docs.google.com/a/ncsu.edu/document/d/1aER6f9EDFJaUMgSpK7g5nYPiMNoUjZzwQxzY0jMW8mI/edit link] to the writing assignment for this topic.
*Here is a [[CSC/ECE_517_Fall_2011/ch4_4g_as|link]] to previous work on this topic.

== A Basic Definition of Metaprogramming ==

The most basic definition of metaprogramming is: ''writing code that writes or manipulates code.''
<ref>[http://courses.ncsu.edu/csc517/common/media/08/Metaprogramming/Metaprogramming.html Video Lecture on Metaprogramming by Dr. Gehringer]</ref>
<ref name="wiki metaprogramming">[http://en.wikipedia.org/wiki/Metaprogramming Wikipedia Article on Metaprogramming]</ref>

A metaprogram can either manipulate itself, or it can manipulate some other program.

:Below are three ''important terms'' associated with a metaprogramming<ref name="wiki metaprogramming">[http://en.wikipedia.org/wiki/Metaprogramming Wikipedia Article on Metaprogramming]</ref>:
::* [http://en.wikipedia.org/wiki/Metalanguage metalanguage] - the language in which a metaprogram is written
::* [http://en.wikipedia.org/wiki/Object_language object language] - the language of the program that is being manipulated by a metaprogram
::* [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflection] - the ability of a programming language to be its own metalanguage (also known as ''reflexivity'')

== Uses of Metaprogramming ==

Metaprogramming can allow programmers to write code that is more
concise and more flexible. It can be more concise because a program that can write code is able to generate more code than it is initially given. It can be more flexible, because it can allow the program to change the way it behaves without having to recompile.

:One of the best examples of metaprogramming is that of the [http://en.wikipedia.org/wiki/Compiler compiler]<ref>[http://c2.com/cgi/wiki?MetaProgramming Overview of Metaprogramming]</ref>. A compiler uses code written in one language in order to generate code that can be executed by a computer.

:Metaprogramming is also used for building frameworks such as [http://rubyonrails.org/ Ruby on Rails]. In this case, the use of [http://en.wikipedia.org/wiki/Convention_over_configuration convention over configuration] allows developers to write more concise and consistent code. Following specific conventions, developers write a relatively small amount of code. The Ruby on Rails [http://en.wikipedia.org/wiki/Scaffold_(programming) scaffold] uses the code the code written by the developer to generate code that is expansive, interconnected, and standardized.

:One of the most powerful uses for metaprogramming, is the ability to change a program during runtime. In languages such as Ruby and [http://groovy.codehaus.org/ Groovy], programmers can<ref>[http://blog.adaptivesoftware.biz/2009/02/what-is-metaprogramming.html Coding Insights Blog]</ref>:
::*Create a new class at runtime
::*Create new methods at runtime
::*Modify existing classes and/or methods at runtime
::*Respond to calls made on non-existent methods

== Features in Ruby that Enable Metaprogramming ==

*Ruby is a [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamically typed language]

::In dynamically typed languages, the majority of its type checking is performed at run-time, as opposed to compile time.<ref>[http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing Wikipedia Article on the Type System]</ref> Because variables are not type-checked until they are used in program execution, it is possible to use types that are created during program execution.

*Ruby is an [http://en.wikipedia.org/wiki/Interpreted_language interpreted language]
::Interpreted languages avoid explicit compilation<ref>[http://en.wikipedia.org/wiki/Interpreted_language Wikipeida Article on Interpreted Language]</ref>. Because Ruby is being interpreted as it is being executed, it is possible to create new classes and methods during program execution.

*Ruby classes are [http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle open]

::Most object-oriented programming languages adhere to the [http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle open/closed principle]<ref>[http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle Wikipedia Article on the Open/Closed Principle]</ref>. This means that the core components that are part of the language cannot be modified. In Ruby, the classes are open, meaning that all of the classes and methods be changed.

== Examples of Metaprogramming in Ruby ==

=== Creating a New Class at Runtime ===
Below is an example of creating a new class at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>3.times do
class MyClass
puts "MyClass defined"
end
end</code>
In example shown above, the <tt>times</tt> method is invoked on the <tt>3</tt> object. Inside of the <tt>times</tt> method call, the class <tt>MyClass</tt> is defined. <tt>MyClass</tt> is actually defined three times, once for each of the three iterations. Even though the class is defined three times, it has the same effect as only defining it once. The important thing to note here, is that a new class is defined at runtime, inside of a method call.

=== Modifying a Class at Runtime ===
Below is an example of modifying a class, and and example of creating a new method at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>3.times do
class MyClass
def one
puts "one"
end
end</code>
In the example shown above, the class <tt>MyClass</tt> is modified again to include a new method. This method, the <tt>one</tt> method is defined three times, just like the class is defined three times. Even though it has been defined three times, it has the same effect as only defining it once. The important thing to note here is that a new method is defined at runtime.

=== Creating a Method at Runtime ===
Below is an additional example of modifying a class at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>class MyClass
def two
puts "two"
end</code>
In the example shown above, the class<tt>MyClass</tt> is reopened and the <tt>two</tt> method is added to it.

Below is an example of what happens when the code written above is executed:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>
mc = MyClass.new
mc.one
mc.two
</code>
The output of the code will be:
<code>one
two</code>

=== Modifying a Method at Runtime ===

Below is an additional example of modifying a method at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>class MyClass
def two
puts "one two"
end</code>
In the example shown above, the <tt>two</tt> method is reopened and modified.

Below is an example of what happens when the modified code written above is executed:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>
mc = MyClass.new
mc.one
mc.two
</code>
The output of the code will be:
<code>one
one two</code>

=== Responding to a Non-Existent Method Call ===

Ruby has several metaprogramming facilities. One can create new class and add methods to it using "define_method"<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
c = Class.new
c.class_eval do
define_method :hi do
puts "Hey"
end
c.new.hi
>>Hey

This technique allows you to add any type of new code and modify behavior of a program at run time.
Another example, adding attr_accessor to all classes:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
Object.class_eval do
class << self
def attribute_accessor( *instance_variables )
instance_variables.each do |instance_variable|
class_eval %Q?
def #{instance_variable}
@#{instance_variable}
end
def #{instance_variable}=( new_value )
@#{instance_variable} = new_value
end
?
end
end
end
end

== Metaprogramming in Other Languages ==
===The C preprocessor (CPP)<ref>[http://www.ibm.com/developerworks/library/l-metaprog1/index.html The Art of Metaprogramming]</ref>===
First let's look at metaprogramming that involves textual macro languages. Textual macros are macros that directly affect the text of the programming language without knowing about or dealing with the meaning of the language.
=====The SWAP macro: =====
#define SWAP(a, b, type) {
type __tmp_c; c = b; b = a; a = c;
}

This macro allows you to swap the two values of the given type. A macro is effective in this situation because:
*A function call would take too much overhead for a simple operation
*The functions would require variables' addresses to be passed which is messier and prevents the compiler from keeping the values in registers.
*A different function would need to be coded for each type of item you wanted to swap.

#define SWAP(a, b, type) { type __tmp_c; c = b; b = a; a = c; }
int main()
{
int a = 3;
int b = 5;
printf("a is %d and b is %d\n", a, b);
SWAP(a, b, int);
printf("a is now %d and b is now %d\n", a, b);
return 0;
}

=====The MIN macro: =====
#define MIN(x, y) ((x) > (y) ? (y) : (x))

This macro returns the the minimum of two values.

== References ==
<references/>

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-21T03:37:19Z

Drhowar5: /* Creating a Method at Runtime */

*Here is a [https://docs.google.com/a/ncsu.edu/document/d/1aER6f9EDFJaUMgSpK7g5nYPiMNoUjZzwQxzY0jMW8mI/edit link] to the writing assignment for this topic.
*Here is a [[CSC/ECE_517_Fall_2011/ch4_4g_as|link]] to previous work on this topic.

== A Basic Definition of Metaprogramming ==

The most basic definition of metaprogramming is: ''writing code that writes or manipulates code.''
<ref>[http://courses.ncsu.edu/csc517/common/media/08/Metaprogramming/Metaprogramming.html Video Lecture on Metaprogramming by Dr. Gehringer]</ref>
<ref name="wiki metaprogramming">[http://en.wikipedia.org/wiki/Metaprogramming Wikipedia Article on Metaprogramming]</ref>

A metaprogram can either manipulate itself, or it can manipulate some other program.

:Below are three ''important terms'' associated with a metaprogramming<ref name="wiki metaprogramming">[http://en.wikipedia.org/wiki/Metaprogramming Wikipedia Article on Metaprogramming]</ref>:
::* [http://en.wikipedia.org/wiki/Metalanguage metalanguage] - the language in which a metaprogram is written
::* [http://en.wikipedia.org/wiki/Object_language object language] - the language of the program that is being manipulated by a metaprogram
::* [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflection] - the ability of a programming language to be its own metalanguage (also known as ''reflexivity'')

== Uses of Metaprogramming ==

Metaprogramming can allow programmers to write code that is more
concise and more flexible. It can be more concise because a program that can write code is able to generate more code than it is initially given. It can be more flexible, because it can allow the program to change the way it behaves without having to recompile.

:One of the best examples of metaprogramming is that of the [http://en.wikipedia.org/wiki/Compiler compiler]<ref>[http://c2.com/cgi/wiki?MetaProgramming Overview of Metaprogramming]</ref>. A compiler uses code written in one language in order to generate code that can be executed by a computer.

:Metaprogramming is also used for building frameworks such as [http://rubyonrails.org/ Ruby on Rails]. In this case, the use of [http://en.wikipedia.org/wiki/Convention_over_configuration convention over configuration] allows developers to write more concise and consistent code. Following specific conventions, developers write a relatively small amount of code. The Ruby on Rails [http://en.wikipedia.org/wiki/Scaffold_(programming) scaffold] uses the code the code written by the developer to generate code that is expansive, interconnected, and standardized.

:One of the most powerful uses for metaprogramming, is the ability to change a program during runtime. In languages such as Ruby and [http://groovy.codehaus.org/ Groovy], programmers can<ref>[http://blog.adaptivesoftware.biz/2009/02/what-is-metaprogramming.html Coding Insights Blog]</ref>:
::*Create a new class at runtime
::*Create new methods at runtime
::*Modify existing classes and/or methods at runtime
::*Respond to calls made on non-existent methods

== Features in Ruby that Enable Metaprogramming ==

*Ruby is a [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamically typed language]

::In dynamically typed languages, the majority of its type checking is performed at run-time, as opposed to compile time.<ref>[http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing Wikipedia Article on the Type System]</ref> Because variables are not type-checked until they are used in program execution, it is possible to use types that are created during program execution.

*Ruby is an [http://en.wikipedia.org/wiki/Interpreted_language interpreted language]
::Interpreted languages avoid explicit compilation<ref>[http://en.wikipedia.org/wiki/Interpreted_language Wikipeida Article on Interpreted Language]</ref>. Because Ruby is being interpreted as it is being executed, it is possible to create new classes and methods during program execution.

*Ruby classes are [http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle open]

::Most object-oriented programming languages adhere to the [http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle open/closed principle]<ref>[http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle Wikipedia Article on the Open/Closed Principle]</ref>. This means that the core components that are part of the language cannot be modified. In Ruby, the classes are open, meaning that all of the classes and methods be changed.
== Examples of Metaprogramming in Ruby ==

=== Creating a New Class at Runtime ===
Below is an example of creating a new class at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>3.times do
class MyClass
puts "MyClass defined"
end
end</code>
In example shown above, the <tt>times</tt> method is invoked on the <tt>3</tt> object. Inside of the <tt>times</tt> method call, the class <tt>MyClass</tt> is defined. <tt>MyClass</tt> is actually defined three times, once for each of the three iterations. Even though the class is defined three times, it has the same effect as only defining it once. The important thing to note here, is that a new class is defined at runtime, inside of a method call.

=== Modifying a Class at Runtime ===
Below is an example of modifying a class, and and example of creating a new method at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>3.times do
class MyClass
def one
puts "one"
end
end</code>
In the example shown above, the class <tt>MyClass</tt> is modified again to include a new method. This method, the <tt>one</tt> method is defined three times, just like the class is defined three times. Even though it has been defined three times, it has the same effect as only defining it once. The important thing to note here is that a new method is defined at runtime.

=== Creating a Method at Runtime ===
Below is an additional example of modifying a class at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>class MyClass
def two
puts "two"
end</code>
In the example shown above, the class<tt>MyClass</tt> is reopened and the <tt>two</tt> method is added to it.

Below is an example of what happens when the code written above is executed:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>
mc = MyClass.new
mc.one
mc.two
</code>
The output of the code will be:
<code>one
two</code>

=== Modifying a Method at Runtime ===

Below is an additional example of modifying a method at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>class MyClass
def two
puts "one two"
end</code>
In the example shown above, the <tt>two</tt> method is reopened and modified.

Below is an example of what happens when the modified code written above is executed:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>
mc = MyClass.new
mc.one
mc.two
</code>
The output of the code will be:
<code>one
one two</code>

=== Responding to a Non-Existent Method Call ===

Ruby has several metaprogramming facilities. One can create new class and add methods to it using "define_method"<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
c = Class.new
c.class_eval do
define_method :hi do
puts "Hey"
end
c.new.hi
>>Hey

This technique allows you to add any type of new code and modify behavior of a program at run time.
Another example, adding attr_accessor to all classes:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
Object.class_eval do
class << self
def attribute_accessor( *instance_variables )
instance_variables.each do |instance_variable|
class_eval %Q?
def #{instance_variable}
@#{instance_variable}
end
def #{instance_variable}=( new_value )
@#{instance_variable} = new_value
end
?
end
end
end
end

== Metaprogramming in Other Languages ==
===The C preprocessor (CPP)<ref>[http://www.ibm.com/developerworks/library/l-metaprog1/index.html The Art of Metaprogramming]</ref>===
First let's look at metaprogramming that involves textual macro languages. Textual macros are macros that directly affect the text of the programming language without knowing about or dealing with the meaning of the language.
=====The SWAP macro: =====
#define SWAP(a, b, type) {
type __tmp_c; c = b; b = a; a = c;
}

This macro allows you to swap the two values of the given type. A macro is effective in this situation because:
*A function call would take too much overhead for a simple operation
*The functions would require variables' addresses to be passed which is messier and prevents the compiler from keeping the values in registers.
*A different function would need to be coded for each type of item you wanted to swap.

#define SWAP(a, b, type) { type __tmp_c; c = b; b = a; a = c; }
int main()
{
int a = 3;
int b = 5;
printf("a is %d and b is %d\n", a, b);
SWAP(a, b, int);
printf("a is now %d and b is now %d\n", a, b);
return 0;
}

=====The MIN macro: =====
#define MIN(x, y) ((x) > (y) ? (y) : (x))

This macro returns the the minimum of two values.

== References ==
<references/>

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-21T02:17:12Z

Drhowar5:

*Here is a [https://docs.google.com/a/ncsu.edu/document/d/1aER6f9EDFJaUMgSpK7g5nYPiMNoUjZzwQxzY0jMW8mI/edit link] to the writing assignment for this topic.
*Here is a [[CSC/ECE_517_Fall_2011/ch4_4g_as|link]] to previous work on this topic.

== A Basic Definition of Metaprogramming ==

The most basic definition of metaprogramming is: ''writing code that writes or manipulates code.''
<ref>[http://courses.ncsu.edu/csc517/common/media/08/Metaprogramming/Metaprogramming.html Video Lecture on Metaprogramming by Dr. Gehringer]</ref>
<ref name="wiki metaprogramming">[http://en.wikipedia.org/wiki/Metaprogramming Wikipedia Article on Metaprogramming]</ref>

A metaprogram can either manipulate itself, or it can manipulate some other program.

:Below are three ''important terms'' associated with a metaprogramming<ref name="wiki metaprogramming">[http://en.wikipedia.org/wiki/Metaprogramming Wikipedia Article on Metaprogramming]</ref>:
::* [http://en.wikipedia.org/wiki/Metalanguage metalanguage] - the language in which a metaprogram is written
::* [http://en.wikipedia.org/wiki/Object_language object language] - the language of the program that is being manipulated by a metaprogram
::* [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflection] - the ability of a programming language to be its own metalanguage (also known as ''reflexivity'')

== Uses of Metaprogramming ==

Metaprogramming can allow programmers to write code that is more
concise and more flexible. It can be more concise because a program that can write code is able to generate more code than it is initially given. It can be more flexible, because it can allow the program to change the way it behaves without having to recompile.

:One of the best examples of metaprogramming is that of the [http://en.wikipedia.org/wiki/Compiler compiler]<ref>[http://c2.com/cgi/wiki?MetaProgramming Overview of Metaprogramming]</ref>. A compiler uses code written in one language in order to generate code that can be executed by a computer.

:Metaprogramming is also used for building frameworks such as [http://rubyonrails.org/ Ruby on Rails]. In this case, the use of [http://en.wikipedia.org/wiki/Convention_over_configuration convention over configuration] allows developers to write more concise and consistent code. Following specific conventions, developers write a relatively small amount of code. The Ruby on Rails [http://en.wikipedia.org/wiki/Scaffold_(programming) scaffold] uses the code the code written by the developer to generate code that is expansive, interconnected, and standardized.

:One of the most powerful uses for metaprogramming, is the ability to change a program during runtime. In languages such as Ruby and [http://groovy.codehaus.org/ Groovy], programmers can<ref>[http://blog.adaptivesoftware.biz/2009/02/what-is-metaprogramming.html Coding Insights Blog]</ref>:
::*Create a new class at runtime
::*Create new methods at runtime
::*Modify existing classes and/or methods at runtime
::*Respond to calls made on non-existent methods

== Features in Ruby that Enable Metaprogramming ==

*Ruby is a [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamically typed language]

::In dynamically typed languages, the majority of its type checking is performed at run-time, as opposed to compile time.<ref>[http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing Wikipedia Article on the Type System]</ref> Because variables are not type-checked until they are used in program execution, it is possible to use types that are created during program execution.

*Ruby is an [http://en.wikipedia.org/wiki/Interpreted_language interpreted language]
::Interpreted languages avoid explicit compilation<ref>[http://en.wikipedia.org/wiki/Interpreted_language Wikipeida Article on Interpreted Language]</ref>. Because Ruby is being interpreted as it is being executed, it is possible to create new classes and methods during program execution.

*Ruby classes are [http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle open]

::Most object-oriented programming languages adhere to the [http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle open/closed principle]<ref>[http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle Wikipedia Article on the Open/Closed Principle]</ref>. This means that the core components that are part of the language cannot be modified. In Ruby, the classes are open, meaning that all of the classes and methods be changed.
== Examples of Metaprogramming in Ruby ==

=== Creating a New Class at Runtime ===
Below is an example of creating a new class at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>3.times do
class MyClass
puts "MyClass defined"
end
end</code>
In example shown above, the <tt>times</tt> method is invoked on the <tt>3</tt> object. Inside of the <tt>times</tt> method call, the class <tt>MyClass</tt> is defined. <tt>MyClass</tt> is actually defined three times, once for each of the three iterations. Even though the class is defined three times, it has the same effect as only defining it once. The important thing to note here, is that a new class is defined at runtime, inside of a method call.

=== Modifying a Class at Runtime ===
Below is an example of modifying a class, and and example of creating a new method at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>3.times do
class MyClass
def one
puts "one"
end
end</code>
In the example shown above, the class <tt>MyClass</tt> is modified again to include a new method. This method, the <tt>one</tt> method is defined three times, just like the class is defined three times. Even though it has been defined three times, it has the same effect as only defining it once. The important thing to note here is that a new method is defined at runtime.

=== Creating a Method at Runtime ===
Below is an additional example of modifying a class at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>class MyClass
def two
puts "two"
end</code>
In the example shown above, the class<tt>MyClass</tt> is reopened and the <tt>two</tt> method is added to it.

Below is an example of what happens when the code written above is executed:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>
mc = MyClass.new
mc.one
mc.two
</code>
The output of the code will be:
<code>one
two</code>

=== Modifying a Method at Runtime ===

Below is an additional example of modifying a method at runtime:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>class MyClass
def two
puts "one two"
end</code>
In the example shown above, the <tt>two</tt> method is reopened and modified.

Below is an example of what happens when the modified code written above is executed:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
<code>
mc = MyClass.new
mc.one
mc.two
</code>
The output of the code will be:
<code>one
one two</code>

=== Responding to a Non-Existent Method Call ===

Ruby has several metaprogramming facilities. One can create new class and add methods to it using "define_method"<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
c = Class.new
c.class_eval do
define_method :hi do
puts "Hey"
end
c.new.hi
>>Hey

This technique allows you to add any type of new code and modify behavior of a program at run time.
Another example, adding attr_accessor to all classes:<ref name="DrGCodeNotes">[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf Dr. Gehrenger's notes on Metaprogramming]</ref>
Object.class_eval do
class << self
def attribute_accessor( *instance_variables )
instance_variables.each do |instance_variable|
class_eval %Q?
def #{instance_variable}
@#{instance_variable}
end
def #{instance_variable}=( new_value )
@#{instance_variable} = new_value
end
?
end
end
end
end

== Metaprogramming in Other Languages ==
===The C preprocessor (CPP)<ref>[http://www.ibm.com/developerworks/library/l-metaprog1/index.html The Art of Metaprogramming]</ref>===
First let's look at metaprogramming that involves textual macro languages. Textual macros are macros that directly affect the text of the programming language without knowing about or dealing with the meaning of the language.
=====The SWAP macro: =====
#define SWAP(a, b, type) {
type __tmp_c; c = b; b = a; a = c;
}

This macro allows you to swap the two values of the given type. A macro is effective in this situation because:
*A function call would take too much overhead for a simple operation
*The functions would require variables' addresses to be passed which is messier and prevents the compiler from keeping the values in registers.
*A different function would need to be coded for each type of item you wanted to swap.

#define SWAP(a, b, type) { type __tmp_c; c = b; b = a; a = c; }
int main()
{
int a = 3;
int b = 5;
printf("a is %d and b is %d\n", a, b);
SWAP(a, b, int);
printf("a is now %d and b is now %d\n", a, b);
return 0;
}

=====The MIN macro: =====
#define MIN(x, y) ((x) > (y) ? (y) : (x))

This macro returns the the minimum of two values.

== References ==
<references/>

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-21T02:12:40Z

Drhowar5: /* Modifying a Method at Runtime */

*Here is a [https://docs.google.com/a/ncsu.edu/document/d/1aER6f9EDFJaUMgSpK7g5nYPiMNoUjZzwQxzY0jMW8mI/edit link] to the writing assignment for this topic.
*Here is a [[CSC/ECE_517_Fall_2011/ch4_4g_as|link]] to previous work on this topic.

== A Basic Definition of Metaprogramming ==

The most basic definition of metaprogramming is: ''writing code that writes or manipulates code.''
<ref>[http://courses.ncsu.edu/csc517/common/media/08/Metaprogramming/Metaprogramming.html Video Lecture on Metaprogramming by Dr. Gehringer]</ref>
<ref name="wiki metaprogramming">[http://en.wikipedia.org/wiki/Metaprogramming Wikipedia Article on Metaprogramming]</ref>

A metaprogram can either manipulate itself, or it can manipulate some other program.

:Below are three ''important terms'' associated with a metaprogramming<ref name="wiki metaprogramming">[http://en.wikipedia.org/wiki/Metaprogramming Wikipedia Article on Metaprogramming]</ref>:
::* [http://en.wikipedia.org/wiki/Metalanguage metalanguage] - the language in which a metaprogram is written
::* [http://en.wikipedia.org/wiki/Object_language object language] - the language of the program that is being manipulated by a metaprogram
::* [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflection] - the ability of a programming language to be its own metalanguage (also known as ''reflexivity'')

== Uses of Metaprogramming ==

Metaprogramming can allow programmers to write code that is more
concise and more flexible. It can be more concise because a program that can write code is able to generate more code than it is initially given. It can be more flexible, because it can allow the program to change the way it behaves without having to recompile.

:One of the best examples of metaprogramming is that of the [http://en.wikipedia.org/wiki/Compiler compiler]<ref>[http://c2.com/cgi/wiki?MetaProgramming Overview of Metaprogramming]</ref>. A compiler uses code written in one language in order to generate code that can be executed by a computer.

:Metaprogramming is also used for building frameworks such as [http://rubyonrails.org/ Ruby on Rails]. In this case, the use of [http://en.wikipedia.org/wiki/Convention_over_configuration convention over configuration] allows developers to write more concise and consistent code. Following specific conventions, developers write a relatively small amount of code. The Ruby on Rails [http://en.wikipedia.org/wiki/Scaffold_(programming) scaffold] uses the code the code written by the developer to generate code that is expansive, interconnected, and standardized.

:One of the most powerful uses for metaprogramming, is the ability to change a program during runtime. In languages such as Ruby and [http://groovy.codehaus.org/ Groovy], programmers can<ref>[http://blog.adaptivesoftware.biz/2009/02/what-is-metaprogramming.html Coding Insights Blog]</ref>:
::*Create a new class at runtime
::*Create new methods at runtime
::*Modify existing classes and/or methods at runtime
::*Respond to calls made on non-existent methods

== Features in Ruby that Enable Metaprogramming ==

*Ruby is a [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamically typed language]

::In dynamically typed languages, the majority of its type checking is performed at run-time, as opposed to compile time.<ref>[http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing Wikipedia Article on the Type System]</ref> Because variables are not type-checked until they are used in program execution, it is possible to use types that are created during program execution.

*Ruby is an [http://en.wikipedia.org/wiki/Interpreted_language interpreted language]
::Interpreted languages avoid explicit compilation<ref>[http://en.wikipedia.org/wiki/Interpreted_language Wikipeida Article on Interpreted Language]</ref>. Because Ruby is being interpreted as it is being executed, it is possible to create new classes and methods during program execution.

*Ruby classes are [http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle open]

::Most object-oriented programming languages adhere to the [http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle open/closed principle]<ref>[http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle Wikipedia Article on the Open/Closed Principle]</ref>. This means that the core components that are part of the language cannot be modified. In Ruby, the classes are open, meaning that all of the classes and methods be changed.
== Examples of Metaprogramming in Ruby <ref>[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf]Dr. Gehrenger's notes on Metaprogramming</ref>==

=== Creating a New Class at Runtime ===
Below is an example of creating a new class at runtime:
<code>3.times do
class MyClass
puts "MyClass defined"
end
end</code>
In example shown above, the <tt>times</tt> method is invoked on the <tt>3</tt> object. Inside of the <tt>times</tt> method call, the class <tt>MyClass</tt> is defined. <tt>MyClass</tt> is actually defined three times, once for each of the three iterations. Even though the class is defined three times, it has the same effect as only defining it once. The important thing to note here, is that a new class is defined at runtime, inside of a method call.

=== Modifying a Class at Runtime ===
Below is an example of modifying a class, and and example of creating a new method at runtime:
<code>3.times do
class MyClass
def one
puts "one"
end
end</code>
In the example shown above, the class <tt>MyClass</tt> is modified again to include a new method. This method, the <tt>one</tt> method is defined three times, just like the class is defined three times. Even though it has been defined three times, it has the same effect as only defining it once. The important thing to note here is that a new method is defined at runtime.

=== Creating a Method at Runtime ===
Below is an additional example of modifying a class at runtime:
<code>class MyClass
def two
puts "two"
end</code>
In the example shown above, the class<tt>MyClass</tt> is reopened and the <tt>two</tt> method is added to it.

Below is an example of what happens when the code written above is executed:
<code>
mc = MyClass.new
mc.one
mc.two
</code>
The output of the code will be:
<code>one
two</code>

=== Modifying a Method at Runtime ===

Below is an additional example of modifying a method at runtime:
<code>class MyClass
def two
puts "one two"
end</code>
In the example shown above, the <tt>two</tt> method is reopened and modified.

Below is an example of what happens when the modified code written above is executed:
<code>
mc = MyClass.new
mc.one
mc.two
</code>
The output of the code will be:
<code>one
one two</code>

=== Responding to a Non-Existent Method Call ===

Ruby has several metaprogramming facilities. One can create new class and add methods to it using "define_method"
c = Class.new
c.class_eval do
define_method :hi do
puts "Hey"
end
c.new.hi
>>Hey

This technique allows you to add any type of new code and modify behavior of a program at run time.
Another example, adding attr_accessor to all classes:
Object.class_eval do
class << self
def attribute_accessor( *instance_variables )
instance_variables.each do |instance_variable|
class_eval %Q?
def #{instance_variable}
@#{instance_variable}
end
def #{instance_variable}=( new_value )
@#{instance_variable} = new_value
end
?
end
end
end
end

== Metaprogramming in Other Languages ==
===The C preprocessor (CPP)<ref>[http://www.ibm.com/developerworks/library/l-metaprog1/index.html The Art of Metaprogramming]</ref>===
First let's look at metaprogramming that involves textual macro languages. Textual macros are macros that directly affect the text of the programming language without knowing about or dealing with the meaning of the language.
=====The SWAP macro: =====
#define SWAP(a, b, type) {
type __tmp_c; c = b; b = a; a = c;
}

This macro allows you to swap the two values of the given type. A macro is effective in this situation because:
*A function call would take too much overhead for a simple operation
*The functions would require variables' addresses to be passed which is messier and prevents the compiler from keeping the values in registers.
*A different function would need to be coded for each type of item you wanted to swap.

#define SWAP(a, b, type) { type __tmp_c; c = b; b = a; a = c; }
int main()
{
int a = 3;
int b = 5;
printf("a is %d and b is %d\n", a, b);
SWAP(a, b, int);
printf("a is now %d and b is now %d\n", a, b);
return 0;
}

=====The MIN macro: =====
#define MIN(x, y) ((x) > (y) ? (y) : (x))

This macro returns the the minimum of two values.

== References ==
<references/>

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-21T02:11:14Z

Drhowar5: /* Modifying a Class at Runtime */

*Here is a [https://docs.google.com/a/ncsu.edu/document/d/1aER6f9EDFJaUMgSpK7g5nYPiMNoUjZzwQxzY0jMW8mI/edit link] to the writing assignment for this topic.
*Here is a [[CSC/ECE_517_Fall_2011/ch4_4g_as|link]] to previous work on this topic.

== A Basic Definition of Metaprogramming ==

The most basic definition of metaprogramming is: ''writing code that writes or manipulates code.''
<ref>[http://courses.ncsu.edu/csc517/common/media/08/Metaprogramming/Metaprogramming.html Video Lecture on Metaprogramming by Dr. Gehringer]</ref>
<ref name="wiki metaprogramming">[http://en.wikipedia.org/wiki/Metaprogramming Wikipedia Article on Metaprogramming]</ref>

A metaprogram can either manipulate itself, or it can manipulate some other program.

:Below are three ''important terms'' associated with a metaprogramming<ref name="wiki metaprogramming">[http://en.wikipedia.org/wiki/Metaprogramming Wikipedia Article on Metaprogramming]</ref>:
::* [http://en.wikipedia.org/wiki/Metalanguage metalanguage] - the language in which a metaprogram is written
::* [http://en.wikipedia.org/wiki/Object_language object language] - the language of the program that is being manipulated by a metaprogram
::* [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflection] - the ability of a programming language to be its own metalanguage (also known as ''reflexivity'')

== Uses of Metaprogramming ==

Metaprogramming can allow programmers to write code that is more
concise and more flexible. It can be more concise because a program that can write code is able to generate more code than it is initially given. It can be more flexible, because it can allow the program to change the way it behaves without having to recompile.

:One of the best examples of metaprogramming is that of the [http://en.wikipedia.org/wiki/Compiler compiler]<ref>[http://c2.com/cgi/wiki?MetaProgramming Overview of Metaprogramming]</ref>. A compiler uses code written in one language in order to generate code that can be executed by a computer.

:Metaprogramming is also used for building frameworks such as [http://rubyonrails.org/ Ruby on Rails]. In this case, the use of [http://en.wikipedia.org/wiki/Convention_over_configuration convention over configuration] allows developers to write more concise and consistent code. Following specific conventions, developers write a relatively small amount of code. The Ruby on Rails [http://en.wikipedia.org/wiki/Scaffold_(programming) scaffold] uses the code the code written by the developer to generate code that is expansive, interconnected, and standardized.

:One of the most powerful uses for metaprogramming, is the ability to change a program during runtime. In languages such as Ruby and [http://groovy.codehaus.org/ Groovy], programmers can<ref>[http://blog.adaptivesoftware.biz/2009/02/what-is-metaprogramming.html Coding Insights Blog]</ref>:
::*Create a new class at runtime
::*Create new methods at runtime
::*Modify existing classes and/or methods at runtime
::*Respond to calls made on non-existent methods

== Features in Ruby that Enable Metaprogramming ==

*Ruby is a [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamically typed language]

::In dynamically typed languages, the majority of its type checking is performed at run-time, as opposed to compile time.<ref>[http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing Wikipedia Article on the Type System]</ref> Because variables are not type-checked until they are used in program execution, it is possible to use types that are created during program execution.

*Ruby is an [http://en.wikipedia.org/wiki/Interpreted_language interpreted language]
::Interpreted languages avoid explicit compilation<ref>[http://en.wikipedia.org/wiki/Interpreted_language Wikipeida Article on Interpreted Language]</ref>. Because Ruby is being interpreted as it is being executed, it is possible to create new classes and methods during program execution.

*Ruby classes are [http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle open]

::Most object-oriented programming languages adhere to the [http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle open/closed principle]<ref>[http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle Wikipedia Article on the Open/Closed Principle]</ref>. This means that the core components that are part of the language cannot be modified. In Ruby, the classes are open, meaning that all of the classes and methods be changed.
== Examples of Metaprogramming in Ruby <ref>[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf]Dr. Gehrenger's notes on Metaprogramming</ref>==

=== Creating a New Class at Runtime ===
Below is an example of creating a new class at runtime:
<code>3.times do
class MyClass
puts "MyClass defined"
end
end</code>
In example shown above, the <tt>times</tt> method is invoked on the <tt>3</tt> object. Inside of the <tt>times</tt> method call, the class <tt>MyClass</tt> is defined. <tt>MyClass</tt> is actually defined three times, once for each of the three iterations. Even though the class is defined three times, it has the same effect as only defining it once. The important thing to note here, is that a new class is defined at runtime, inside of a method call.

=== Modifying a Class at Runtime ===
Below is an example of modifying a class, and and example of creating a new method at runtime:
<code>3.times do
class MyClass
def one
puts "one"
end
end</code>
In the example shown above, the class <tt>MyClass</tt> is modified again to include a new method. This method, the <tt>one</tt> method is defined three times, just like the class is defined three times. Even though it has been defined three times, it has the same effect as only defining it once. The important thing to note here is that a new method is defined at runtime.

=== Creating a Method at Runtime ===
Below is an additional example of modifying a class at runtime:
<code>class MyClass
def two
puts "two"
end</code>
In the example shown above, the class<tt>MyClass</tt> is reopened and the <tt>two</tt> method is added to it.

Below is an example of what happens when the code written above is executed:
<code>
mc = MyClass.new
mc.one
mc.two
</code>
The output of the code will be:
<code>one
two</code>

=== Modifying a Method at Runtime ===

Below is an additional example of modifying a method at runtime:
<code>class MyClass
def two
puts "one two"
end</code>
In the example shown above, the <tt>two</tt> method is reopened and modified.

Below is an example of what happens when the modified code written above is executed:
<code>
mc = MyClass.new
mc.one
mc.two
</code>
The output of the code will be:
<code>one
one two</code>

Ruby has several metaprogramming facilities. One can create new class and add methods to it using "define_method"
c = Class.new
c.class_eval do
define_method :hi do
puts "Hey"
end
c.new.hi
>>Hey

This technique allows you to add any type of new code and modify behavior of a program at run time.
Another example, adding attr_accessor to all classes:
Object.class_eval do
class << self
def attribute_accessor( *instance_variables )
instance_variables.each do |instance_variable|
class_eval %Q?
def #{instance_variable}
@#{instance_variable}
end
def #{instance_variable}=( new_value )
@#{instance_variable} = new_value
end
?
end
end
end
end

== Metaprogramming in Other Languages ==
===The C preprocessor (CPP)<ref>[http://www.ibm.com/developerworks/library/l-metaprog1/index.html The Art of Metaprogramming]</ref>===
First let's look at metaprogramming that involves textual macro languages. Textual macros are macros that directly affect the text of the programming language without knowing about or dealing with the meaning of the language.
=====The SWAP macro: =====
#define SWAP(a, b, type) {
type __tmp_c; c = b; b = a; a = c;
}

This macro allows you to swap the two values of the given type. A macro is effective in this situation because:
*A function call would take too much overhead for a simple operation
*The functions would require variables' addresses to be passed which is messier and prevents the compiler from keeping the values in registers.
*A different function would need to be coded for each type of item you wanted to swap.

#define SWAP(a, b, type) { type __tmp_c; c = b; b = a; a = c; }
int main()
{
int a = 3;
int b = 5;
printf("a is %d and b is %d\n", a, b);
SWAP(a, b, int);
printf("a is now %d and b is now %d\n", a, b);
return 0;
}

=====The MIN macro: =====
#define MIN(x, y) ((x) > (y) ? (y) : (x))

This macro returns the the minimum of two values.

== References ==
<references/>

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-21T02:09:32Z

Drhowar5: /* Examples of Metaprogramming in Ruby [http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf]Dr. Gehrenger's notes on Metaprogramming */

*Here is a [https://docs.google.com/a/ncsu.edu/document/d/1aER6f9EDFJaUMgSpK7g5nYPiMNoUjZzwQxzY0jMW8mI/edit link] to the writing assignment for this topic.
*Here is a [[CSC/ECE_517_Fall_2011/ch4_4g_as|link]] to previous work on this topic.

== A Basic Definition of Metaprogramming ==

The most basic definition of metaprogramming is: ''writing code that writes or manipulates code.''
<ref>[http://courses.ncsu.edu/csc517/common/media/08/Metaprogramming/Metaprogramming.html Video Lecture on Metaprogramming by Dr. Gehringer]</ref>
<ref name="wiki metaprogramming">[http://en.wikipedia.org/wiki/Metaprogramming Wikipedia Article on Metaprogramming]</ref>

A metaprogram can either manipulate itself, or it can manipulate some other program.

:Below are three ''important terms'' associated with a metaprogramming<ref name="wiki metaprogramming">[http://en.wikipedia.org/wiki/Metaprogramming Wikipedia Article on Metaprogramming]</ref>:
::* [http://en.wikipedia.org/wiki/Metalanguage metalanguage] - the language in which a metaprogram is written
::* [http://en.wikipedia.org/wiki/Object_language object language] - the language of the program that is being manipulated by a metaprogram
::* [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflection] - the ability of a programming language to be its own metalanguage (also known as ''reflexivity'')

== Uses of Metaprogramming ==

Metaprogramming can allow programmers to write code that is more
concise and more flexible. It can be more concise because a program that can write code is able to generate more code than it is initially given. It can be more flexible, because it can allow the program to change the way it behaves without having to recompile.

:One of the best examples of metaprogramming is that of the [http://en.wikipedia.org/wiki/Compiler compiler]<ref>[http://c2.com/cgi/wiki?MetaProgramming Overview of Metaprogramming]</ref>. A compiler uses code written in one language in order to generate code that can be executed by a computer.

:Metaprogramming is also used for building frameworks such as [http://rubyonrails.org/ Ruby on Rails]. In this case, the use of [http://en.wikipedia.org/wiki/Convention_over_configuration convention over configuration] allows developers to write more concise and consistent code. Following specific conventions, developers write a relatively small amount of code. The Ruby on Rails [http://en.wikipedia.org/wiki/Scaffold_(programming) scaffold] uses the code the code written by the developer to generate code that is expansive, interconnected, and standardized.

:One of the most powerful uses for metaprogramming, is the ability to change a program during runtime. In languages such as Ruby and [http://groovy.codehaus.org/ Groovy], programmers can<ref>[http://blog.adaptivesoftware.biz/2009/02/what-is-metaprogramming.html Coding Insights Blog]</ref>:
::*Create a new class at runtime
::*Create new methods at runtime
::*Modify existing classes and/or methods at runtime
::*Respond to calls made on non-existent methods

== Features in Ruby that Enable Metaprogramming ==

*Ruby is a [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamically typed language]

::In dynamically typed languages, the majority of its type checking is performed at run-time, as opposed to compile time.<ref>[http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing Wikipedia Article on the Type System]</ref> Because variables are not type-checked until they are used in program execution, it is possible to use types that are created during program execution.

*Ruby is an [http://en.wikipedia.org/wiki/Interpreted_language interpreted language]
::Interpreted languages avoid explicit compilation<ref>[http://en.wikipedia.org/wiki/Interpreted_language Wikipeida Article on Interpreted Language]</ref>. Because Ruby is being interpreted as it is being executed, it is possible to create new classes and methods during program execution.

*Ruby classes are [http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle open]

::Most object-oriented programming languages adhere to the [http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle open/closed principle]<ref>[http://en.wikipedia.org/wiki/Open/closed_principle#Meyer.27s_Open.2FClosed_Principle Wikipedia Article on the Open/Closed Principle]</ref>. This means that the core components that are part of the language cannot be modified. In Ruby, the classes are open, meaning that all of the classes and methods be changed.
== Examples of Metaprogramming in Ruby <ref>[http://courses.ncsu.edu/csc517/common/lectures/notes/ol5.pdf]Dr. Gehrenger's notes on Metaprogramming</ref>==

=== Creating a New Class at Runtime ===
Below is an example of creating a new class at runtime:
<code>3.times do
class MyClass
puts "MyClass defined"
end
end</code>
In example shown above, the <tt>times</tt> method is invoked on the <tt>3</tt> object. Inside of the <tt>times</tt> method call, the class <tt>MyClass</tt> is defined. <tt>MyClass</tt> is actually defined three times, once for each of the three iterations. Even though the class is defined three times, it has the same effect as only defining it once. The important thing to note here, is that a new class is defined at runtime, inside of a method call.

=== Modifying a Class at Runtime ===
Below is an example of modifying a class, and and example of creating a new method at runtime:
<code>3.times do
class MyClass
def one
puts "one"
end
end</code>
In the example shown above, the class <tt>MyClass</tt> is modified again to include a new method. This method, the <tt>one</tt> method is defined three times, just like the class is defined three times. Even though it has been defined three times, it has the same effect as only defining it once. The important thing to note here is that a new method is defined at runtime.

Below is an additional example of modifying a class at runtime:
<code>class MyClass
def two
puts "two"
end</code>
In the example shown above, the class<tt>MyClass</tt> is reopened and the <tt>two</tt> method is added to it.

Below is an example of what happens when the code written above is executed:
<code>
mc = MyClass.new
mc.one
mc.two
</code>
The output of the code will be:
<code>one
two</code>

=== Modifying a Method at Runtime ===

Below is an additional example of modifying a method at runtime:
<code>class MyClass
def two
puts "one two"
end</code>
In the example shown above, the <tt>two</tt> method is reopened and modified.

Below is an example of what happens when the modified code written above is executed:
<code>
mc = MyClass.new
mc.one
mc.two
</code>
The output of the code will be:
<code>one
one two</code>

Ruby has several metaprogramming facilities. One can create new class and add methods to it using "define_method"
c = Class.new
c.class_eval do
define_method :hi do
puts "Hey"
end
c.new.hi
>>Hey

This technique allows you to add any type of new code and modify behavior of a program at run time.
Another example, adding attr_accessor to all classes:
Object.class_eval do
class << self
def attribute_accessor( *instance_variables )
instance_variables.each do |instance_variable|
class_eval %Q?
def #{instance_variable}
@#{instance_variable}
end
def #{instance_variable}=( new_value )
@#{instance_variable} = new_value
end
?
end
end
end
end

== Metaprogramming in Other Languages ==
===The C preprocessor (CPP)<ref>[http://www.ibm.com/developerworks/library/l-metaprog1/index.html The Art of Metaprogramming]</ref>===
First let's look at metaprogramming that involves textual macro languages. Textual macros are macros that directly affect the text of the programming language without knowing about or dealing with the meaning of the language.
=====The SWAP macro: =====
#define SWAP(a, b, type) {
type __tmp_c; c = b; b = a; a = c;
}

This macro allows you to swap the two values of the given type. A macro is effective in this situation because:
*A function call would take too much overhead for a simple operation
*The functions would require variables' addresses to be passed which is messier and prevents the compiler from keeping the values in registers.
*A different function would need to be coded for each type of item you wanted to swap.

#define SWAP(a, b, type) { type __tmp_c; c = b; b = a; a = c; }
int main()
{
int a = 3;
int b = 5;
printf("a is %d and b is %d\n", a, b);
SWAP(a, b, int);
printf("a is now %d and b is now %d\n", a, b);
return 0;
}

=====The MIN macro: =====
#define MIN(x, y) ((x) > (y) ? (y) : (x))

This macro returns the the minimum of two values.

== References ==
<references/>

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-21T01:37:35Z

Drhowar5: /* Uses of Metaprogramming */ modified list of uses so that it will match up with later examples

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-20T15:55:16Z

Drhowar5: /* Features in Ruby that Enable Metaprogramming */

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-20T15:50:44Z

Drhowar5: /* Features in Ruby that Enable Metaprogramming */ added content to about the three features of Ruby that enable metaprogramming

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-20T04:29:03Z

Drhowar5: /* Features in Ruby that Enable Metaprogramming */

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-19T16:25:30Z

Drhowar5: finished basic outlining of article,

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-19T15:48:02Z

Drhowar5:

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-19T01:29:56Z

Drhowar5: /* Uses of Metaprogramming */

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-19T01:29:02Z

Drhowar5: rearranged existing content

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-19T01:26:48Z

Drhowar5: expanding uses of meta programming

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-18T22:26:07Z

Drhowar5: spelling

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-18T22:25:37Z

Drhowar5: first pass at rewriting some of the introductory material

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-18T21:26:59Z

Drhowar5:

Here is a [https://docs.google.com/a/ncsu.edu/document/d/1aER6f9EDFJaUMgSpK7g5nYPiMNoUjZzwQxzY0jMW8mI/edit link] to the writing assignment for this topic.

Here is a [[CSC/ECE_517_Fall_2011/ch4_4g_as|link]] to previous work on this topic.

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-18T21:26:17Z

Drhowar5:

This is a [https://docs.google.com/a/ncsu.edu/document/d/1aER6f9EDFJaUMgSpK7g5nYPiMNoUjZzwQxzY0jMW8mI/edit link] to the writing assignment for this topic.

This is a [[CSC/ECE_517_Fall_2011/ch4_4g_as|link]] to previous work on this topic.

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-18T16:57:15Z

Drhowar5: finally, I think this is started correctly

This is a [https://docs.google.com/a/ncsu.edu/document/d/1aER6f9EDFJaUMgSpK7g5nYPiMNoUjZzwQxzY0jMW8mI/edit link] to the writing assignment for this topic.

Here is a [[CSC/ECE_517_Fall_2011/ch4_4g_as|link]] to previous work on this topic.

MainPage

2013-02-18T16:45:33Z

Drhowar5: still trying to get the name of the new page right

==Course-Specific Topics==
* [[CSC 216]] learning exercise
* [[CSC 379]]
* [[CSC/ECE 506 Fall 2007]]
* [[ECE506_Main_Page | CSC/ECE 506 Main Portal]]
* [[CSC/ECE 517 Fall 2007]]
* [[CSC/ECE 517 Summer 2008]]
* [[CSC/ECE 517 Fall 2010]]
* [[CSC/ECE 517 Fall 2011]]
* [[CSC/ECE 517 Fall 2012]]
* [[CSC 456 Spring 2011|CSC 456 Spring 2012]]
* [[ECE 633]]
* [[KCU]]
* [[Progress reports]]

==Application Behavior==
* [[Grading]]

==Metaprogramming==
* [[CSC/ECE_517_Spring_2013/ch1b_1k_hf|Lecture on Metaprogramming]]

==Development==
* [[Setting Up a Development Machine]]
* [[Creating a Linux Development Environment for Expertiza - Installation Guide]]
* [[Using git and github for projects]]
* [[Using heroku to deploy your projects]]
* [[How to Begin a Project from the Current Expertiza Repository]]

==Production==
* [[Deploying to Production]]
* [[Accessing the Production Server]]

==Testing==
* [[Using Cucumber with Expertiza]]
* [[Rails Testing Overview]]

==Design==
* [[Object-Oriented Design and Programming]]

MainPage

2013-02-18T16:42:52Z

Drhowar5: trying to properly name the new page

==Course-Specific Topics==
* [[CSC 216]] learning exercise
* [[CSC 379]]
* [[CSC/ECE 506 Fall 2007]]
* [[ECE506_Main_Page | CSC/ECE 506 Main Portal]]
* [[CSC/ECE 517 Fall 2007]]
* [[CSC/ECE 517 Summer 2008]]
* [[CSC/ECE 517 Fall 2010]]
* [[CSC/ECE 517 Fall 2011]]
* [[CSC/ECE 517 Fall 2012]]
* [[CSC 456 Spring 2011|CSC 456 Spring 2012]]
* [[ECE 633]]
* [[KCU]]
* [[Progress reports]]

==Application Behavior==
* [[Grading]]

==Metaprogramming==
* [[ch1b_1k_hf|Lecture on Metaprogramming]]

==Development==
* [[Setting Up a Development Machine]]
* [[Creating a Linux Development Environment for Expertiza - Installation Guide]]
* [[Using git and github for projects]]
* [[Using heroku to deploy your projects]]
* [[How to Begin a Project from the Current Expertiza Repository]]

==Production==
* [[Deploying to Production]]
* [[Accessing the Production Server]]

==Testing==
* [[Using Cucumber with Expertiza]]
* [[Rails Testing Overview]]

==Design==
* [[Object-Oriented Design and Programming]]

Lecture on Metaprogramming

2013-02-18T16:37:36Z

Drhowar5: Created page with "This is a link to the writing assignment for this topic. This is a [[ch4_4g_as..."

This is a [[https://docs.google.com/a/ncsu.edu/document/d/1aER6f9EDFJaUMgSpK7g5nYPiMNoUjZzwQxzY0jMW8mI/edit|link]] to the writing assignment for this topic.
This is a [[ch4_4g_as|link]] to previous work on this topic.

MainPage

2013-02-18T16:18:04Z

Drhowar5: adding a sub category for meta programming

==Course-Specific Topics==
* [[CSC 216]] learning exercise
* [[CSC 379]]
* [[CSC/ECE 506 Fall 2007]]
* [[ECE506_Main_Page | CSC/ECE 506 Main Portal]]
* [[CSC/ECE 517 Fall 2007]]
* [[CSC/ECE 517 Summer 2008]]
* [[CSC/ECE 517 Fall 2010]]
* [[CSC/ECE 517 Fall 2011]]
* [[CSC/ECE 517 Fall 2012]]
* [[CSC 456 Spring 2011|CSC 456 Spring 2012]]
* [[ECE 633]]
* [[KCU]]
* [[Progress reports]]

==Application Behavior==
* [[Grading]]

==Metaprogramming==
* [[Lecture on Metaprogramming]]

==Development==
* [[Setting Up a Development Machine]]
* [[Creating a Linux Development Environment for Expertiza - Installation Guide]]
* [[Using git and github for projects]]
* [[Using heroku to deploy your projects]]
* [[How to Begin a Project from the Current Expertiza Repository]]

==Production==
* [[Deploying to Production]]
* [[Accessing the Production Server]]

==Testing==
* [[Using Cucumber with Expertiza]]
* [[Rails Testing Overview]]

==Design==
* [[Object-Oriented Design and Programming]]

MainPage

2013-02-18T16:16:27Z

Drhowar5: adding a category for metaprogramming

==Course-Specific Topics==
* [[CSC 216]] learning exercise
* [[CSC 379]]
* [[CSC/ECE 506 Fall 2007]]
* [[ECE506_Main_Page | CSC/ECE 506 Main Portal]]
* [[CSC/ECE 517 Fall 2007]]
* [[CSC/ECE 517 Summer 2008]]
* [[CSC/ECE 517 Fall 2010]]
* [[CSC/ECE 517 Fall 2011]]
* [[CSC/ECE 517 Fall 2012]]
* [[CSC 456 Spring 2011|CSC 456 Spring 2012]]
* [[ECE 633]]
* [[KCU]]
* [[Progress reports]]

==Application Behavior==
* [[Grading]]

==Metaprogramming==

==Development==
* [[Setting Up a Development Machine]]
* [[Creating a Linux Development Environment for Expertiza - Installation Guide]]
* [[Using git and github for projects]]
* [[Using heroku to deploy your projects]]
* [[How to Begin a Project from the Current Expertiza Repository]]

==Production==
* [[Deploying to Production]]
* [[Accessing the Production Server]]

==Testing==
* [[Using Cucumber with Expertiza]]
* [[Rails Testing Overview]]

==Design==
* [[Object-Oriented Design and Programming]]