Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Spring 2013/FINAL PROJECT E736 UNDO DELIVERABLE

2013-04-23T22:05:16Z

Twfolsom: /* Classes Modified */

= E736. Undo Functionality for Expertiza =
*Contacts: Ed Gehringer (efg@ncsu.edu) and Andrew Kofink (ajkofink@ncsu.edu)
*[http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Spring_2013/FINAL_PROJECT_E736_UNDO Design Document]
*[https://docs.google.com/a/ncsu.edu/document/d/11YTjxFXFR13vJ769yFBbqn9qOueK2Ktz0Pd-gyS2W5U/ Project Description Doc]
== Team Members ==
*Chun Sing Tsui (ctsui@ncsu.edu)
*Kenny Yarboro (kbyarbor@ncsu.edu)
*Meng Cao (mcao2@ncsu.edu)
*Travis Folsom (twfolsom@ncsu.edu)

== Project Deliverables ==

=== Screencast Video Overview ===
A video overview of the project was created via [http://www.screencast-o-matic.com/ Screencast-O-Matic] and can be found [http://www.youtube.com/watch?v=1DYS5InjBOk here].

=== Overview of Undo Functionality ===
*Undo allows the user to undo their most recent actions for any items that offer the undo functionality.
*The undo of file submissions was not required; it is not implemented in this project.
*If an undo is attempted on an item already modified by another user, a message is displayed stating why undo cannot be performed. Otherwise, the user is able to undo any changes to an item with the undo functionality.
*When multiple actions are performed in one step, the undo functionality groups all of the changes together for the purposes of restoring all items affected by the action previously performed.

=== List of Items Now Supported by Undo Functionality ===
*Add Signup Sheet
**Delete Topic
**Edit Topic
**New Topic
*Assignments
**Add/Remove Participants
**Inherit Participants from Course
**Copy Participants to Course
**Copy
**Create
**Delete
**Edit
*Courses
**Add Participants
**Copy
**Create
**Delete
**Edit
**Toggle Private/Public
*Import
**Import Participants
**Import Teams
**Import Users
*Student Actions
**Create Team
**Edit Team Name
**Leave Team
**Submit Hyperlink
*Questions
**Copy
**Create
**Delete
**Edit
*Questionnaires
**Copy
**Create
**Delete
**Edit
*Teams
**Add
**Create (Manual)
**Create (Random)
**Delete
**Delete All Teams
**Edit

=== Redo Functionality ===
In addition to the Undo functionality being added, the ability to Redo an undone action is also implemented. Whenever an Undo is performed, the user is given an option to Redo the action that was undone. Whenever a Redo is performed, the user is given an option to Undo the action again.

=== Design Patterns and Designs ===
*DRY
**"Don't Repeat Yourself" practice was followed.
**The app/controllers/application_controller.rb file contains all of the Undo functionality code for Expertiza. All other controllers are able to call the necessary undo-related methods to enable the Undo functionality.

=== Framework Leveraged & Enhanced ===
*Paper Trail(https://github.com/airblade/paper_trail)
**Paper Trail allows for tracking changes to model data.
***Good for auditing or versioning.
**Offers many functionalities including:
****Viewing a model at any stage in its lifecycle.
****Reverting a model to any version.
****Undeleting items after they have been destroyed.
**Compatible with Rails-2.3.15, which is the version Expertiza uses.
**There is a [http://railscasts.com/episodes/255-undo-with-paper-trail Railscast] showing how to implement the undo feature with Paper Trail.
**Ranked as the most popular framework for Active Record versioning feature in [https://www.ruby-toolbox.com/categories/Active_Record_Versioning here]
*Enhancement
**Paper Trail only supported undo of the most recent action and did not restore associations.
**Paper Trail customized to add support for restoring associations within the Expertiza system.
***Database transactions paired with timestamps and user ids to group them together.

=== Classes Modified ===
*apps/
**controllers/
***application_controller.rb
***assignment_controller.rb
***course_controller.rb
***import_file_controller.rb
***participants_controller.rb
***sign_up_sheet_controller.rb
***student_team_controller.rb
***team_controller.rb
***teams_users_controller.rb
***versions_controller.rb
**models/
***assignment_participant.rb
***assignment.rb
***course.rb
***participant.rb
***sign_up_topic.rb
***ta_mapping.rb
***team_node.rb
***teams_user.rb

=== Unit & Functional Tests ===
The implementation of the Undo functionality did not afford any testing opportunities applicable to unit or functional tests.

=== Bug Fixes & Other Improvements ===
The following bugs were found within Expertiza and fixed:
*ApplicationController enhanced to rescue from ActiveRecord::RecordNotFound errors and redirect to tree display.
*Copy of Assignment opened Edit page for the original Assignment and now correctly opens the Edit page for the copy of the assignment.

The following general improvements were made:
*Explicitly declared the has_one association between each object and its tree node to eliminate the manual deletion of a related tree node with the object.
*Edited the Copy of Course flash message to be more clear that the copy had already been created and to resolve a misspelling.

=== Problem Areas with Expertiza ===
There were some areas of functionality within Expertiza that did not work. There were some cases in which the undo functionality could not be added due to the inherent problems. These problem areas were:
*Assigning surveys in an assignment.
*Dates in assignments do not show up when the assignment is edited.
*Unable to assign random reviewers.
*Unable to edit advice for questions in questionnaire.
*Unable to remove participants from a course.
*Unable to inherit team from a course

=== Future Recommendations ===
*Add integration tests.
*Add undo functionality to other areas of Expertiza (especially student actions such as review responses)
*Determine appropriate methodology for cleaning up Versions table.

=== Template to Implement Undo Functionality ===
* Install paper_trail gem. Please follow the steps listed on its [https://github.com/airblade/paper_trail official webpage ].
* Add ''has_paper_trail'' to the model you want to have undo functionality
class Foo < ActiveRecord::Base
has_paper_trail
...
end

* Call ''undo_link'' method in the corresponding controller. The argument is a string, which you want to show along with the undo link in flash[:note]. The following is code snippet shows how the undo functionality is implemented for the delete method of FoosController
class FoosController < ApplicationController
def delete
@foo = Foo.find(params[:id])
@foo.destroy
undo_link("Foo \"#{@foo.name}\" has been deleted successfully. ")
redirect_to :back
end
end

CSC/ECE 517 Spring 2013/OSS E605B

2013-03-20T19:45:06Z

Twfolsom: /* List of files changed */

=Testing - questionnaire=

== QuestionnaireController Functional Tests ==

The majority of the tests implemented in this project are functional tests of the questionnaire controller. The test cases were written using the [http://api.rubyonrails.org/classes/ActionController/TestCase.html ActionController::TestCase] framework provided by Rails.

=== Modifications to Existing QuestionnaireController Test ===

There were a few tests already written for the Questionnaire controller, but they were not passing initially. We had to modify several things in the test and questionnaire fixture in order to get things up and running. The setup method contained login code that was outdated, and thus each test would result in a redirect due to the invalid login credential. So we looked through other more up to date functional test files and found the correct way to login as a particular user. We also put this code in a helper method so we can call it more easily in different tests if we so choose (more on this in the "Helper Methods" section).

In addition, we added a new questionnaire fixture (:questionnaire5) to help with our testing. Through debugging the test error messages, we saw that an additional required column called "section" has been added to the "Questionnaire" model, which was contributing to the failures. We added the additional column accordingly in :questionnaire5.

=== Helper Methods ===

There are two methods that assist in setting up and running the tests:

*The setup method
*The login_user method

The setup method assigns three special instance variables that are associated with the ActionController::TestCase (@controller, @request, and @response). In addition to setting these, the @Questionnaire variable is assigned to id of the :questionnaire5 fixture. This is the default questionnaire fixture that is used in a lot of the test cases. You will also notice that the fixture :admin is being logged in as the default user. This is done so that you don't have explicitly log into a user account for each test case. The only time you would need to call the method to log in for a particular test case is if you needed to test something specifically in another user type's account (for example a student account as is done in test_create_questionnaire_with_student.

def setup
@controller = QuestionnaireController.new
@request = ActionController::TestRequest.new
@response = ActionController::TestResponse.new
@Questionnaire = questionnaires(:questionnaire5).id
login_user(:admin)
end

The login_user method was created to "DRY out" the code associated with logging a user in. The method signature is:

def login_user(userType)

If you pass a symbol of the user type you would like to use for a test, it will log in as that user type for the particular test. The parameter name is userType and assumes that there is a fixture with the name of the user type. There seem to be sufficient fixtures for all of the different user types currently, but additional fixtures may need to be created in the future if new user types are added to the system.

=== Test Coverage ===

There are three main types of tests that we created.

* Happy path tests of the controller's public methods. There is a test for every method. (ex: test_new)
* Sad path tests that passed invalid parameters. (ex: test_edit_questionnaire_with_lower_max_score_than_min)
* Sad path tests that tried to do things with insufficient access level. (ex: test_create_questionnaire_with_student)

=== How to Run Controller Test ===

All of the QuestionnaireController tests are in the questionnaire_controller_test.rb file and can be run as a standard functional test.

== Questionnaire Subclass Unit Tests ==

The original assignment was to write unit tests for the Questionnaire Subclasses. As we reviewed the tests, it was found that most of the methods were trivial (ex: the method "symbol" only only returns a hardcoded symbol). The only test that was found to be worth testing was the get_weighted_score method. Upon further review, however, we found that testing this method in each of the four subclasses violated the DRY principle. Therefore, we moved the test to the superclass (Questionnaire) to test the "get_weighted_score" method.

=== Modifications to Existing Questionnaire Subclass Tests ===

There was only one test in the existing unit test for AuthorFeedbackQuestionnaire for testing the "get_weighted_score" method. Even though the test could be run, we found that it was not making assertions as it should. The files for the other 3 questionnaire subclasses were created to complete the testing on them. As stated earlier, we then found that testing the "get_weighted_score" method was redundant, violating the DRY principle, so it was moved to the superclass (Questionnaire). The tests in the subclasses were deleted (since they were redundant) but the test files were kept for future testing of the subclass if/when needed.

=== Test Coverage ===

Tested the one method "compute_weighted_score" from the subclasses that was not trivial. Based on an average, it was asserted that the value was not nil and that the value was computed correctly.

=== How to Run Unit Tests ===

The "compute_weighted_score" test can be found in the Questionnaire Unit Test file.

== General Information ==

=== Members ===
*Jonathan Wills - jrwills2
*Chun Sing Tsui - ctsui
*Travis Folsom - twfolsom

=== Highlights of Project ===
* Added unit test for questionnaire class
* Added functional tests for questionnaire controller
* 24 total tests
* Delete test was failing due to a potential bug in the questionnaire controller

=== List of files changed ===
*test/fixtures/question_types.yml
*test/fixtures/questionnaires.yml
*test/fixtures/questions.yml
*test/functional/questionnaire_controller_test.rb
*test/unit/author_feedback_questionnaire_test.rb
*test/unit/metareview_questionnaire_test.rb
*test/unit/review_questionnaire_test.rb
*test/unit/teammate_review_questionnaire_test.rb

= NOTE =
Questionnaire class, has_many :assignment_questionnaire needs to be :assignment_questionnaires. Also needs to be changed on the next line: through: => "assignment_questionnaires" (we were told that this was convention to be plural). If this is the case, then in the "compute_weighted_score" method, assignemnt_questionnaire also needs to be changed to assignment_questionnaires. This most likely needs to be refactored, but we did not want to do a refactor without testing its effects on the system.

CSC/ECE 517 Spring 2013/OSS E605B

2013-03-20T19:44:54Z

Twfolsom: /* List of files changed */

=Testing - questionnaire=

== QuestionnaireController Functional Tests ==

The majority of the tests implemented in this project are functional tests of the questionnaire controller. The test cases were written using the [http://api.rubyonrails.org/classes/ActionController/TestCase.html ActionController::TestCase] framework provided by Rails.

=== Modifications to Existing QuestionnaireController Test ===

There were a few tests already written for the Questionnaire controller, but they were not passing initially. We had to modify several things in the test and questionnaire fixture in order to get things up and running. The setup method contained login code that was outdated, and thus each test would result in a redirect due to the invalid login credential. So we looked through other more up to date functional test files and found the correct way to login as a particular user. We also put this code in a helper method so we can call it more easily in different tests if we so choose (more on this in the "Helper Methods" section).

In addition, we added a new questionnaire fixture (:questionnaire5) to help with our testing. Through debugging the test error messages, we saw that an additional required column called "section" has been added to the "Questionnaire" model, which was contributing to the failures. We added the additional column accordingly in :questionnaire5.

=== Helper Methods ===

There are two methods that assist in setting up and running the tests:

*The setup method
*The login_user method

The setup method assigns three special instance variables that are associated with the ActionController::TestCase (@controller, @request, and @response). In addition to setting these, the @Questionnaire variable is assigned to id of the :questionnaire5 fixture. This is the default questionnaire fixture that is used in a lot of the test cases. You will also notice that the fixture :admin is being logged in as the default user. This is done so that you don't have explicitly log into a user account for each test case. The only time you would need to call the method to log in for a particular test case is if you needed to test something specifically in another user type's account (for example a student account as is done in test_create_questionnaire_with_student.

def setup
@controller = QuestionnaireController.new
@request = ActionController::TestRequest.new
@response = ActionController::TestResponse.new
@Questionnaire = questionnaires(:questionnaire5).id
login_user(:admin)
end

The login_user method was created to "DRY out" the code associated with logging a user in. The method signature is:

def login_user(userType)

If you pass a symbol of the user type you would like to use for a test, it will log in as that user type for the particular test. The parameter name is userType and assumes that there is a fixture with the name of the user type. There seem to be sufficient fixtures for all of the different user types currently, but additional fixtures may need to be created in the future if new user types are added to the system.

=== Test Coverage ===

There are three main types of tests that we created.

* Happy path tests of the controller's public methods. There is a test for every method. (ex: test_new)
* Sad path tests that passed invalid parameters. (ex: test_edit_questionnaire_with_lower_max_score_than_min)
* Sad path tests that tried to do things with insufficient access level. (ex: test_create_questionnaire_with_student)

=== How to Run Controller Test ===

All of the QuestionnaireController tests are in the questionnaire_controller_test.rb file and can be run as a standard functional test.

== Questionnaire Subclass Unit Tests ==

The original assignment was to write unit tests for the Questionnaire Subclasses. As we reviewed the tests, it was found that most of the methods were trivial (ex: the method "symbol" only only returns a hardcoded symbol). The only test that was found to be worth testing was the get_weighted_score method. Upon further review, however, we found that testing this method in each of the four subclasses violated the DRY principle. Therefore, we moved the test to the superclass (Questionnaire) to test the "get_weighted_score" method.

=== Modifications to Existing Questionnaire Subclass Tests ===

There was only one test in the existing unit test for AuthorFeedbackQuestionnaire for testing the "get_weighted_score" method. Even though the test could be run, we found that it was not making assertions as it should. The files for the other 3 questionnaire subclasses were created to complete the testing on them. As stated earlier, we then found that testing the "get_weighted_score" method was redundant, violating the DRY principle, so it was moved to the superclass (Questionnaire). The tests in the subclasses were deleted (since they were redundant) but the test files were kept for future testing of the subclass if/when needed.

=== Test Coverage ===

Tested the one method "compute_weighted_score" from the subclasses that was not trivial. Based on an average, it was asserted that the value was not nil and that the value was computed correctly.

=== How to Run Unit Tests ===

The "compute_weighted_score" test can be found in the Questionnaire Unit Test file.

== General Information ==

=== Members ===
*Jonathan Wills - jrwills2
*Chun Sing Tsui - ctsui
*Travis Folsom - twfolsom

=== Highlights of Project ===
* Added unit test for questionnaire class
* Added functional tests for questionnaire controller
* 24 total tests
* Delete test was failing due to a potential bug in the questionnaire controller

=== List of files changed ===
*test/fixtures/question_types.yml
*test/fixtures/questionnaires.yml
*test/fixtures/questions.yml
*test/functional/questionnaire_controller_test.rb
*test/unit/author_feedback_questionnaire_test.rb
*test/unit/metareview_questionnaire_test.rb
*test/unit/review_questionnaire_test.rb
*test/unit/teammate_review_questionnaire_test.rb

Questionnaire class, has_many :assignment_questionnaire needs to be :assignment_questionnaires. Also needs to be changed on the next line: through: => "assignment_questionnaires" (we were told that this was convention to be plural). If this is the case, then in the "compute_weighted_score" method, assignemnt_questionnaire also needs to be changed to assignment_questionnaires. This most likely needs to be refactored, but we did not want to do a refactor without testing its effects on the system.

CSC/ECE 517 Spring 2013/OSS E605B

2013-03-20T19:43:50Z

Twfolsom:

=Testing - questionnaire=

== QuestionnaireController Functional Tests ==

The majority of the tests implemented in this project are functional tests of the questionnaire controller. The test cases were written using the [http://api.rubyonrails.org/classes/ActionController/TestCase.html ActionController::TestCase] framework provided by Rails.

=== Modifications to Existing QuestionnaireController Test ===

There were a few tests already written for the Questionnaire controller, but they were not passing initially. We had to modify several things in the test and questionnaire fixture in order to get things up and running. The setup method contained login code that was outdated, and thus each test would result in a redirect due to the invalid login credential. So we looked through other more up to date functional test files and found the correct way to login as a particular user. We also put this code in a helper method so we can call it more easily in different tests if we so choose (more on this in the "Helper Methods" section).

In addition, we added a new questionnaire fixture (:questionnaire5) to help with our testing. Through debugging the test error messages, we saw that an additional required column called "section" has been added to the "Questionnaire" model, which was contributing to the failures. We added the additional column accordingly in :questionnaire5.

=== Helper Methods ===

There are two methods that assist in setting up and running the tests:

*The setup method
*The login_user method

The setup method assigns three special instance variables that are associated with the ActionController::TestCase (@controller, @request, and @response). In addition to setting these, the @Questionnaire variable is assigned to id of the :questionnaire5 fixture. This is the default questionnaire fixture that is used in a lot of the test cases. You will also notice that the fixture :admin is being logged in as the default user. This is done so that you don't have explicitly log into a user account for each test case. The only time you would need to call the method to log in for a particular test case is if you needed to test something specifically in another user type's account (for example a student account as is done in test_create_questionnaire_with_student.

def setup
@controller = QuestionnaireController.new
@request = ActionController::TestRequest.new
@response = ActionController::TestResponse.new
@Questionnaire = questionnaires(:questionnaire5).id
login_user(:admin)
end

The login_user method was created to "DRY out" the code associated with logging a user in. The method signature is:

def login_user(userType)

If you pass a symbol of the user type you would like to use for a test, it will log in as that user type for the particular test. The parameter name is userType and assumes that there is a fixture with the name of the user type. There seem to be sufficient fixtures for all of the different user types currently, but additional fixtures may need to be created in the future if new user types are added to the system.

=== Test Coverage ===

There are three main types of tests that we created.

* Happy path tests of the controller's public methods. There is a test for every method. (ex: test_new)
* Sad path tests that passed invalid parameters. (ex: test_edit_questionnaire_with_lower_max_score_than_min)
* Sad path tests that tried to do things with insufficient access level. (ex: test_create_questionnaire_with_student)

=== How to Run Controller Test ===

All of the QuestionnaireController tests are in the questionnaire_controller_test.rb file and can be run as a standard functional test.

== Questionnaire Subclass Unit Tests ==

The original assignment was to write unit tests for the Questionnaire Subclasses. As we reviewed the tests, it was found that most of the methods were trivial (ex: the method "symbol" only only returns a hardcoded symbol). The only test that was found to be worth testing was the get_weighted_score method. Upon further review, however, we found that testing this method in each of the four subclasses violated the DRY principle. Therefore, we moved the test to the superclass (Questionnaire) to test the "get_weighted_score" method.

=== Modifications to Existing Questionnaire Subclass Tests ===

There was only one test in the existing unit test for AuthorFeedbackQuestionnaire for testing the "get_weighted_score" method. Even though the test could be run, we found that it was not making assertions as it should. The files for the other 3 questionnaire subclasses were created to complete the testing on them. As stated earlier, we then found that testing the "get_weighted_score" method was redundant, violating the DRY principle, so it was moved to the superclass (Questionnaire). The tests in the subclasses were deleted (since they were redundant) but the test files were kept for future testing of the subclass if/when needed.

=== Test Coverage ===

Tested the one method "compute_weighted_score" from the subclasses that was not trivial. Based on an average, it was asserted that the value was not nil and that the value was computed correctly.

=== How to Run Unit Tests ===

The "compute_weighted_score" test can be found in the Questionnaire Unit Test file.

== General Information ==

=== Members ===
*Jonathan Wills - jrwills2
*Chun Sing Tsui - ctsui
*Travis Folsom - twfolsom

=== Highlights of Project ===
* Added unit test for questionnaire class
* Added functional tests for questionnaire controller
* 24 total tests
* Delete test was failing due to a potential bug in the questionnaire controller

=== List of files changed ===
*test/fixtures/question_types.yml
*test/fixtures/questionnaires.yml
*test/fixtures/questions.yml
*test/functional/questionnaire_controller_test.rb
*test/unit/author_feedback_questionnaire_test.rb
*test/unit/metareview_questionnaire_test.rb
*test/unit/review_questionnaire_test.rb
*test/unit/teammate_review_questionnaire_test.rb

Questionnaire class, has_many :assignment_questionnaire needs to be :assignment_questionnaires. Also needs to be changed on the next line: through: => "assignment_questionnaires" (we were told that this was ). If this is the case, then in the "compute_weighted_score" method, assignemnt_questionnaire also needs to be changed to assignment_questionnaires. This most likely needs to be refactored, but we did not want to do a refactor without testing its effects on the system.

CSC/ECE 517 Spring 2013/OSS E605B

2013-03-20T19:11:34Z

Twfolsom: /* Test Coverage */

CSC/ECE 517 Spring 2013/OSS E605B

2013-03-20T19:09:46Z

Twfolsom: /* Highlights of Project */

=Testing - questionnaire=

== QuestionnaireController Functional Tests ==

The majority of the tests implemented in this project are functional tests of the questionnaire controller. The test cases were written using the [http://api.rubyonrails.org/classes/ActionController/TestCase.html ActionController::TestCase] framework provided by Rails.

=== Modifications to Existing QuestionnaireController Test ===

There were a few tests already written for the Questionnaire controller, but they were not passing initially. We had to modify several things in the test and questionnaire fixture in order to get things up and running. The setup method contained login code that was outdated, and thus each test would result in a redirect due to the invalid login credential. So we looked through other more up to date functional test files and found the correct way to login as a particular user. We also put this code in a helper method so we can call it more easily in different tests if we so choose (more on this in the "Helper Methods" section).

In addition, we added a new questionnaire fixture (:questionnaire5) to help with our testing. Through debugging the test error messages, we saw that an additional required column called "section" has been added to the "Questionnaire" model, which was contributing to the failures. We added the additional column accordingly in :questionnaire5.

=== Helper Methods ===

There are two methods that assist in setting up and running the tests:

*The setup method
*The login_user method

The setup method assigns three special instance variables that are associated with the ActionController::TestCase (@controller, @request, and @response). In addition to setting these, the @Questionnaire variable is assigned to id of the :questionnaire5 fixture. This is the default questionnaire fixture that is used in a lot of the test cases. You will also notice that the fixture :admin is being logged in as the default user. This is done so that you don't have explicitly log into a user account for each test case. The only time you would need to call the method to log in for a particular test case is if you needed to test something specifically in another user type's account (for example a student account as is done in test_create_questionnaire_with_student.

def setup
@controller = QuestionnaireController.new
@request = ActionController::TestRequest.new
@response = ActionController::TestResponse.new
@Questionnaire = questionnaires(:questionnaire5).id
login_user(:admin)
end

The login_user method was created to "DRY out" the code associated with logging a user in. The method signature is:

def login_user(userType)

If you pass a symbol of the user type you would like to use for a test, it will log in as that user type for the particular test. The parameter name is userType and assumes that there is a fixture with the name of the user type. There seem to be sufficient fixtures for all of the different user types currently, but additional fixtures may need to be created in the future if new user types are added to the system.

=== Test Coverage ===

There are three main types of tests that we created.

* Happy path tests of the controller's public methods. There is a test for every method. (ex: test_new)
* Sad path tests that passed invalid parameters. (ex: test_edit_questionnaire_with_lower_max_score_than_min)
* Sad path tests that tried to do things with insufficient access level. (ex: test_create_questionnaire_with_student)

=== How to Run Controller Test ===

All of the QuestionnaireController tests are in the questionnaire_controller_test.rb file and can be run as a standard functional test.

== Questionnaire Subclass Unit Tests ==

The original assignment was to write unit tests for the Questionnaire Subclasses. As we reviewed the tests, it was found that most of the methods were trivial (ex: the method "symbol" only only returns a hardcoded symbol). The only test that was found to be worth testing was the get_weighted_score method. Upon further review, however, we found that testing this method in each of the four subclasses violated the DRY principle. Therefore, we moved the test to the superclass (Questionnaire) to test the "get_weighted_score" method.

=== Modifications to Existing Questionnaire Subclass Tests ===

There was only one test in the existing unit test for AuthorFeedbackQuestionnaire for testing the "get_weighted_score" method. Even though the test could be run, we found that it was not making assertions as it should. The files for the other 3 questionnaire subclasses were created to complete the testing on them. As stated earlier, we then found that testing the "get_weighted_score" method was redundant, violating the DRY principle, so it was moved to the superclass (Questionnaire). The tests in the subclasses were deleted (since they were redundant) but the test files were kept for future testing of the subclass if/when needed.

=== Test Coverage ===

=== How to Run Unit Tests ===

The "compute_weighted_score" test can be found in the Questionnaire Unit Test file.

== General Information ==

=== Members ===
*Jonathan Wills - jrwills2
*Chun Sing Tsui - ctsui
*Travis Folsom - twfolsom

=== Highlights of Project ===
* Added unit test for questionnaire class
* Added functional tests for questionnaire controller
* 24 total tests
* Delete test was failing due to a potential bug in the questionnaire controller

=== List of files changed ===
*test/fixtures/question_types.yml
*test/fixtures/questionnaires.yml
*test/fixtures/questions.yml
*test/functional/questionnaire_controller_test.rb
*test/unit/author_feedback_questionnaire_test.rb
*test/unit/metareview_questionnaire_test.rb
*test/unit/review_questionnaire_test.rb
*test/unit/teammate_review_questionnaire_test.rb

CSC/ECE 517 Spring 2013/OSS E605B

2013-03-20T19:09:17Z

Twfolsom: /* How to Run Unit Tests */

=Testing - questionnaire=

== QuestionnaireController Functional Tests ==

The majority of the tests implemented in this project are functional tests of the questionnaire controller. The test cases were written using the [http://api.rubyonrails.org/classes/ActionController/TestCase.html ActionController::TestCase] framework provided by Rails.

=== Modifications to Existing QuestionnaireController Test ===

There were a few tests already written for the Questionnaire controller, but they were not passing initially. We had to modify several things in the test and questionnaire fixture in order to get things up and running. The setup method contained login code that was outdated, and thus each test would result in a redirect due to the invalid login credential. So we looked through other more up to date functional test files and found the correct way to login as a particular user. We also put this code in a helper method so we can call it more easily in different tests if we so choose (more on this in the "Helper Methods" section).

In addition, we added a new questionnaire fixture (:questionnaire5) to help with our testing. Through debugging the test error messages, we saw that an additional required column called "section" has been added to the "Questionnaire" model, which was contributing to the failures. We added the additional column accordingly in :questionnaire5.

=== Helper Methods ===

There are two methods that assist in setting up and running the tests:

*The setup method
*The login_user method

The setup method assigns three special instance variables that are associated with the ActionController::TestCase (@controller, @request, and @response). In addition to setting these, the @Questionnaire variable is assigned to id of the :questionnaire5 fixture. This is the default questionnaire fixture that is used in a lot of the test cases. You will also notice that the fixture :admin is being logged in as the default user. This is done so that you don't have explicitly log into a user account for each test case. The only time you would need to call the method to log in for a particular test case is if you needed to test something specifically in another user type's account (for example a student account as is done in test_create_questionnaire_with_student.

def setup
@controller = QuestionnaireController.new
@request = ActionController::TestRequest.new
@response = ActionController::TestResponse.new
@Questionnaire = questionnaires(:questionnaire5).id
login_user(:admin)
end

The login_user method was created to "DRY out" the code associated with logging a user in. The method signature is:

def login_user(userType)

If you pass a symbol of the user type you would like to use for a test, it will log in as that user type for the particular test. The parameter name is userType and assumes that there is a fixture with the name of the user type. There seem to be sufficient fixtures for all of the different user types currently, but additional fixtures may need to be created in the future if new user types are added to the system.

=== Test Coverage ===

There are three main types of tests that we created.

* Happy path tests of the controller's public methods. There is a test for every method. (ex: test_new)
* Sad path tests that passed invalid parameters. (ex: test_edit_questionnaire_with_lower_max_score_than_min)
* Sad path tests that tried to do things with insufficient access level. (ex: test_create_questionnaire_with_student)

=== How to Run Controller Test ===

All of the QuestionnaireController tests are in the questionnaire_controller_test.rb file and can be run as a standard functional test.

== Questionnaire Subclass Unit Tests ==

The original assignment was to write unit tests for the Questionnaire Subclasses. As we reviewed the tests, it was found that most of the methods were trivial (ex: the method "symbol" only only returns a hardcoded symbol). The only test that was found to be worth testing was the get_weighted_score method. Upon further review, however, we found that testing this method in each of the four subclasses violated the DRY principle. Therefore, we moved the test to the superclass (Questionnaire) to test the "get_weighted_score" method.

=== Modifications to Existing Questionnaire Subclass Tests ===

There was only one test in the existing unit test for AuthorFeedbackQuestionnaire for testing the "get_weighted_score" method. Even though the test could be run, we found that it was not making assertions as it should. The files for the other 3 questionnaire subclasses were created to complete the testing on them. As stated earlier, we then found that testing the "get_weighted_score" method was redundant, violating the DRY principle, so it was moved to the superclass (Questionnaire). The tests in the subclasses were deleted (since they were redundant) but the test files were kept for future testing of the subclass if/when needed.

=== Test Coverage ===

=== How to Run Unit Tests ===

The "compute_weighted_score" test can be found in the Questionnaire Unit Test file.

== General Information ==

=== Members ===
*Jonathan Wills - jrwills2
*Chun Sing Tsui - ctsui
*Travis Folsom - twfolsom

=== Highlights of Project ===
* Added unit tests for questionnaire subclasses
* Added functional tests for questionnaire controller
* 24 total tests
* Delete test was failing due to a potential bug in the questionnaire controller

=== List of files changed ===
*test/fixtures/question_types.yml
*test/fixtures/questionnaires.yml
*test/fixtures/questions.yml
*test/functional/questionnaire_controller_test.rb
*test/unit/author_feedback_questionnaire_test.rb
*test/unit/metareview_questionnaire_test.rb
*test/unit/review_questionnaire_test.rb
*test/unit/teammate_review_questionnaire_test.rb

CSC/ECE 517 Spring 2013/OSS E605B

2013-03-20T19:07:32Z

Twfolsom: /* Overview */

=Testing - questionnaire=

== QuestionnaireController Functional Tests ==

The majority of the tests implemented in this project are functional tests of the questionnaire controller. The test cases were written using the [http://api.rubyonrails.org/classes/ActionController/TestCase.html ActionController::TestCase] framework provided by Rails.

=== Modifications to Existing QuestionnaireController Test ===

There were a few tests already written for the Questionnaire controller, but they were not passing initially. We had to modify several things in the test and questionnaire fixture in order to get things up and running. The setup method contained login code that was outdated, and thus each test would result in a redirect due to the invalid login credential. So we looked through other more up to date functional test files and found the correct way to login as a particular user. We also put this code in a helper method so we can call it more easily in different tests if we so choose (more on this in the "Helper Methods" section).

In addition, we added a new questionnaire fixture (:questionnaire5) to help with our testing. Through debugging the test error messages, we saw that an additional required column called "section" has been added to the "Questionnaire" model, which was contributing to the failures. We added the additional column accordingly in :questionnaire5.

=== Helper Methods ===

There are two methods that assist in setting up and running the tests:

*The setup method
*The login_user method

The setup method assigns three special instance variables that are associated with the ActionController::TestCase (@controller, @request, and @response). In addition to setting these, the @Questionnaire variable is assigned to id of the :questionnaire5 fixture. This is the default questionnaire fixture that is used in a lot of the test cases. You will also notice that the fixture :admin is being logged in as the default user. This is done so that you don't have explicitly log into a user account for each test case. The only time you would need to call the method to log in for a particular test case is if you needed to test something specifically in another user type's account (for example a student account as is done in test_create_questionnaire_with_student.

def setup
@controller = QuestionnaireController.new
@request = ActionController::TestRequest.new
@response = ActionController::TestResponse.new
@Questionnaire = questionnaires(:questionnaire5).id
login_user(:admin)
end

The login_user method was created to "DRY out" the code associated with logging a user in. The method signature is:

def login_user(userType)

If you pass a symbol of the user type you would like to use for a test, it will log in as that user type for the particular test. The parameter name is userType and assumes that there is a fixture with the name of the user type. There seem to be sufficient fixtures for all of the different user types currently, but additional fixtures may need to be created in the future if new user types are added to the system.

=== Test Coverage ===

There are three main types of tests that we created.

* Happy path tests of the controller's public methods. There is a test for every method. (ex: test_new)
* Sad path tests that passed invalid parameters. (ex: test_edit_questionnaire_with_lower_max_score_than_min)
* Sad path tests that tried to do things with insufficient access level. (ex: test_create_questionnaire_with_student)

=== How to Run Controller Test ===

All of the QuestionnaireController tests are in the questionnaire_controller_test.rb file and can be run as a standard functional test.

== Questionnaire Subclass Unit Tests ==

The original assignment was to write unit tests for the Questionnaire Subclasses. As we reviewed the tests, it was found that most of the methods were trivial (ex: the method "symbol" only only returns a hardcoded symbol). The only test that was found to be worth testing was the get_weighted_score method. Upon further review, however, we found that testing this method in each of the four subclasses violated the DRY principle. Therefore, we moved the test to the superclass (Questionnaire) to test the "get_weighted_score" method.

=== Modifications to Existing Questionnaire Subclass Tests ===

There was only one test in the existing unit test for AuthorFeedbackQuestionnaire for testing the "get_weighted_score" method. Even though the test could be run, we found that it was not making assertions as it should. The files for the other 3 questionnaire subclasses were created to complete the testing on them. As stated earlier, we then found that testing the "get_weighted_score" method was redundant, violating the DRY principle, so it was moved to the superclass (Questionnaire). The tests in the subclasses were deleted (since they were redundant) but the test files were kept for future testing of the subclass if/when needed.

=== Test Coverage ===

=== How to Run Unit Tests ===

The "compute_weighted_score" test can be found in the questionnaire unit test file.

== General Information ==

=== Members ===
*Jonathan Wills - jrwills2
*Chun Sing Tsui - ctsui
*Travis Folsom - twfolsom

=== Highlights of Project ===
* Added unit tests for questionnaire subclasses
* Added functional tests for questionnaire controller
* 24 total tests
* Delete test was failing due to a potential bug in the questionnaire controller

=== List of files changed ===
*test/fixtures/question_types.yml
*test/fixtures/questionnaires.yml
*test/fixtures/questions.yml
*test/functional/questionnaire_controller_test.rb
*test/unit/author_feedback_questionnaire_test.rb
*test/unit/metareview_questionnaire_test.rb
*test/unit/review_questionnaire_test.rb
*test/unit/teammate_review_questionnaire_test.rb

CSC/ECE 517 Spring 2013/OSS E605B

2013-03-20T19:07:07Z

Twfolsom: /* Questionnaire Subclass Unit Tests */

=Testing - questionnaire=

== QuestionnaireController Functional Tests ==

The majority of the tests implemented in this project are functional tests of the questionnaire controller. The test cases were written using the [http://api.rubyonrails.org/classes/ActionController/TestCase.html ActionController::TestCase] framework provided by Rails.

=== Modifications to Existing QuestionnaireController Test ===

There were a few tests already written for the Questionnaire controller, but they were not passing initially. We had to modify several things in the test and questionnaire fixture in order to get things up and running. The setup method contained login code that was outdated, and thus each test would result in a redirect due to the invalid login credential. So we looked through other more up to date functional test files and found the correct way to login as a particular user. We also put this code in a helper method so we can call it more easily in different tests if we so choose (more on this in the "Helper Methods" section).

In addition, we added a new questionnaire fixture (:questionnaire5) to help with our testing. Through debugging the test error messages, we saw that an additional required column called "section" has been added to the "Questionnaire" model, which was contributing to the failures. We added the additional column accordingly in :questionnaire5.

=== Helper Methods ===

There are two methods that assist in setting up and running the tests:

*The setup method
*The login_user method

The setup method assigns three special instance variables that are associated with the ActionController::TestCase (@controller, @request, and @response). In addition to setting these, the @Questionnaire variable is assigned to id of the :questionnaire5 fixture. This is the default questionnaire fixture that is used in a lot of the test cases. You will also notice that the fixture :admin is being logged in as the default user. This is done so that you don't have explicitly log into a user account for each test case. The only time you would need to call the method to log in for a particular test case is if you needed to test something specifically in another user type's account (for example a student account as is done in test_create_questionnaire_with_student.

def setup
@controller = QuestionnaireController.new
@request = ActionController::TestRequest.new
@response = ActionController::TestResponse.new
@Questionnaire = questionnaires(:questionnaire5).id
login_user(:admin)
end

The login_user method was created to "DRY out" the code associated with logging a user in. The method signature is:

def login_user(userType)

If you pass a symbol of the user type you would like to use for a test, it will log in as that user type for the particular test. The parameter name is userType and assumes that there is a fixture with the name of the user type. There seem to be sufficient fixtures for all of the different user types currently, but additional fixtures may need to be created in the future if new user types are added to the system.

=== Test Coverage ===

There are three main types of tests that we created.

* Happy path tests of the controller's public methods. There is a test for every method. (ex: test_new)
* Sad path tests that passed invalid parameters. (ex: test_edit_questionnaire_with_lower_max_score_than_min)
* Sad path tests that tried to do things with insufficient access level. (ex: test_create_questionnaire_with_student)

=== How to Run Controller Test ===

All of the QuestionnaireController tests are in the questionnaire_controller_test.rb file and can be run as a standard functional test.

== Questionnaire Subclass Unit Tests ==
=== Overview ===
The original assignment was to write unit tests for the Questionnaire Subclasses. As we reviewed the tests, it was found that most of the methods were trivial (ex: the method "symbol" only only returns a hardcoded symbol). The only test that was found to be worth testing was the get_weighted_score method. Upon further review, however, we found that testing this method in each of the four subclasses violated the DRY principle. Therefore, we moved the test to the superclass (Questionnaire) to test the "get_weighted_score" method.

=== Modifications to Existing Questionnaire Subclass Tests ===

There was only one test in the existing unit test for AuthorFeedbackQuestionnaire for testing the "get_weighted_score" method. Even though the test could be run, we found that it was not making assertions as it should. The files for the other 3 questionnaire subclasses were created to complete the testing on them. As stated earlier, we then found that testing the "get_weighted_score" method was redundant, violating the DRY principle, so it was moved to the superclass (Questionnaire). The tests in the subclasses were deleted (since they were redundant) but the test files were kept for future testing of the subclass if/when needed.

=== Test Coverage ===

=== How to Run Unit Tests ===

The "compute_weighted_score" test can be found in the questionnaire unit test file.

== General Information ==

=== Members ===
*Jonathan Wills - jrwills2
*Chun Sing Tsui - ctsui
*Travis Folsom - twfolsom

=== Highlights of Project ===
* Added unit tests for questionnaire subclasses
* Added functional tests for questionnaire controller
* 24 total tests
* Delete test was failing due to a potential bug in the questionnaire controller

=== List of files changed ===
*test/fixtures/question_types.yml
*test/fixtures/questionnaires.yml
*test/fixtures/questions.yml
*test/functional/questionnaire_controller_test.rb
*test/unit/author_feedback_questionnaire_test.rb
*test/unit/metareview_questionnaire_test.rb
*test/unit/review_questionnaire_test.rb
*test/unit/teammate_review_questionnaire_test.rb

CSC/ECE 517 Spring 2013/OSS E605B

2013-03-20T19:05:38Z

Twfolsom: /* Questionnaire Subclass Unit Tests */

=Testing - questionnaire=

== QuestionnaireController Functional Tests ==

The majority of the tests implemented in this project are functional tests of the questionnaire controller. The test cases were written using the [http://api.rubyonrails.org/classes/ActionController/TestCase.html ActionController::TestCase] framework provided by Rails.

=== Modifications to Existing QuestionnaireController Test ===

There were a few tests already written for the Questionnaire controller, but they were not passing initially. We had to modify several things in the test and questionnaire fixture in order to get things up and running. The setup method contained login code that was outdated, and thus each test would result in a redirect due to the invalid login credential. So we looked through other more up to date functional test files and found the correct way to login as a particular user. We also put this code in a helper method so we can call it more easily in different tests if we so choose (more on this in the "Helper Methods" section).

In addition, we added a new questionnaire fixture (:questionnaire5) to help with our testing. Through debugging the test error messages, we saw that an additional required column called "section" has been added to the "Questionnaire" model, which was contributing to the failures. We added the additional column accordingly in :questionnaire5.

=== Helper Methods ===

There are two methods that assist in setting up and running the tests:

*The setup method
*The login_user method

The setup method assigns three special instance variables that are associated with the ActionController::TestCase (@controller, @request, and @response). In addition to setting these, the @Questionnaire variable is assigned to id of the :questionnaire5 fixture. This is the default questionnaire fixture that is used in a lot of the test cases. You will also notice that the fixture :admin is being logged in as the default user. This is done so that you don't have explicitly log into a user account for each test case. The only time you would need to call the method to log in for a particular test case is if you needed to test something specifically in another user type's account (for example a student account as is done in test_create_questionnaire_with_student.

def setup
@controller = QuestionnaireController.new
@request = ActionController::TestRequest.new
@response = ActionController::TestResponse.new
@Questionnaire = questionnaires(:questionnaire5).id
login_user(:admin)
end

The login_user method was created to "DRY out" the code associated with logging a user in. The method signature is:

def login_user(userType)

If you pass a symbol of the user type you would like to use for a test, it will log in as that user type for the particular test. The parameter name is userType and assumes that there is a fixture with the name of the user type. There seem to be sufficient fixtures for all of the different user types currently, but additional fixtures may need to be created in the future if new user types are added to the system.

=== Test Coverage ===

There are three main types of tests that we created.

* Happy path tests of the controller's public methods. There is a test for every method. (ex: test_new)
* Sad path tests that passed invalid parameters. (ex: test_edit_questionnaire_with_lower_max_score_than_min)
* Sad path tests that tried to do things with insufficient access level. (ex: test_create_questionnaire_with_student)

=== How to Run Controller Test ===

All of the QuestionnaireController tests are in the questionnaire_controller_test.rb file and can be run as a standard functional test.

== Questionnaire Subclass Unit Tests ==

The original assignment was to write unit tests for the Questionnaire Subclasses. As we reviewed the tests, it was found that most of the methods were trivial (ex: the method "symbol" only only returns a hardcoded symbol). The only test that was found to be worth testing was the get_weighted_score method. Upon further review, however, we found that testing this method in each of the four subclasses violated the DRY principle. Therefore, we moved the test to the superclass (Questionnaire) to test the "get_weighted_score" method.

=== Modifications to Existing Questionnaire Subclass Tests ===

There was only one test in the existing unit test for AuthorFeedbackQuestionnaire for testing the "get_weighted_score" method. Even though the test could be run, we found that it was not making assertions as it should. The files for the other 3 questionnaire subclasses were created to complete the testing on them. As stated earlier, we then found that testing the "get_weighted_score" method was redundant, violating the DRY principle, so it was moved to the superclass (Questionnaire). The tests in the subclasses were deleted (since they were redundant) but the test files were kept for future testing of the subclass if/when needed.

=== Test Coverage ===

=== How to Run Unit Tests ===

== General Information ==

=== Members ===
*Jonathan Wills - jrwills2
*Chun Sing Tsui - ctsui
*Travis Folsom - twfolsom

=== Highlights of Project ===
* Added unit tests for questionnaire subclasses
* Added functional tests for questionnaire controller
* 24 total tests
* Delete test was failing due to a potential bug in the questionnaire controller

=== List of files changed ===
*test/fixtures/question_types.yml
*test/fixtures/questionnaires.yml
*test/fixtures/questions.yml
*test/functional/questionnaire_controller_test.rb
*test/unit/author_feedback_questionnaire_test.rb
*test/unit/metareview_questionnaire_test.rb
*test/unit/review_questionnaire_test.rb
*test/unit/teammate_review_questionnaire_test.rb

CSC/ECE 517 Spring 2013/OSS E605B

2013-03-15T02:19:17Z

Twfolsom:

=Testing - questionnaire=
==Members==
*Jonathan Wills - jrwills2
*Chun Sing Tsui - ctsui
*Travis Folsom - twfolsom

== Highlights ==
*unit tests for questionnaire subclasses
*functional test for questionnaire controller
*20+ total tests
*Delete test was failing due to a potential bug in the questionnaire controller.

===List of files changed ==
*test/fixtures/question_types.yml
*test/fixtures/questionnaires.yml
*test/fixtures/questions.yml
*test/functional/questionnaire_controller_test.rb
*test/unit/author_feedback_questionnaire_test.rb
*test/unit/metareview_questionnaire_test.rb
*test/unit/review_questionnaire_test.rb
*test/unit/teammate_review_questionnaire_test.rb

CSC/ECE 517 Spring 2013/OSS E605B

2013-03-15T02:18:36Z

Twfolsom:

=Testing - questionnaire=
==Members==
*Jonathan Wills - jrwills2
*Chun Sing Tsui - ctsui
*Travis Folsom - twfolsom

== Highlights ==
*unit tests for questionnaire subclasses
*funtional test for questionnaire controller
*24 total tests
*Delete test was failing due to a potential bug in the questionnaire controller.

===List of files changed ==
*test/fixtures/question_types.yml
*test/fixtures/questionnaires.yml
*test/fixtures/questions.yml
*test/functional/questionnaire_controller_test.rb
*test/unit/author_feedback_questionnaire_test.rb
*test/unit/metareview_questionnaire_test.rb
*test/unit/review_questionnaire_test.rb
*test/unit/teammate_review_questionnaire_test.rb

CSC/ECE 517 Spring 2013/OSS E605B

2013-03-15T01:56:57Z

Twfolsom:

=Testing - questionnaire=
==Members==
*Jonathan Wills - jrwills2
*Chun Sing Tsui - ctsui
*Travis Folsom - twfolsom

CSC/ECE 517 Spring 2013/OSS E605B

2013-03-15T01:56:37Z

Twfolsom:

Testing - questionnaire
==Members==
*Jonathan Wills - jrwills2
*Chun Sing Tsui - ctsui
*Travis Folsom - twfolsom

CSC/ECE 517 Spring 2013/OSS E605B

2013-03-15T01:54:25Z

Twfolsom:

Testing - questionnaire

*Jonathan Wills - jrwills2
*Chun Sing Tsui - ctsui
*Travis Folsom - twfolsom

CSC/ECE 517 Spring 2013/OSS E605B

2013-03-15T01:53:49Z

Twfolsom: Created page with "Testing - questionnaire Jonathan Wills - jrwills2 Chun Sing Tsui - ctsui Travis Folsom - twfolsom"

Testing - questionnaire

Jonathan Wills - jrwills2
Chun Sing Tsui - ctsui
Travis Folsom - twfolsom

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-26T02:11:32Z

Twfolsom: /* The MIN macro: */

*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

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

===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-26T02:09:05Z

Twfolsom: /* 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.

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:17:47Z

Twfolsom: /* MetaProgramming in JavaMetaprogramming in Java */

*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

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:13:23Z

Twfolsom: /* 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

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.

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

== References ==
<references/>

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-21T04:08:05Z

Twfolsom: /* 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

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.

===The C preprocessor (CPP)<ref>[http://www.slideshare.net/PolymathicCoder/the-art-of-metaprogramming-in-java The Art of Metaprogramming in Java]</ref>===

== References ==
<references/>

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-21T04:05:53Z

Twfolsom: /* 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

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-21T04:05:34Z

Twfolsom: /* 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

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-21T04:04:14Z

Twfolsom: /* 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,eek 2 Object-Oriented Languages and Systems 23
CSC 517 23
'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

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-21T04:03:47Z

Twfolsom: /* 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,eek 2 Object-Oriented Languages and Systems 23
CSC 517 23
'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

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-21T04:03:28Z

Twfolsom: /* 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 ===
=== 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,eek 2 Object-Oriented Languages and Systems 23
CSC 517 23
'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

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-21T04:02:47Z

Twfolsom:

*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:54:48Z

Twfolsom: /* Examples of Metaprogramming in Ruby */

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-20T19:12:04Z

Twfolsom:

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-20T19:05:13Z

Twfolsom: /* Examples of Metaprogramming in Ruby */

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-20T18:19:30Z

Twfolsom: /* Metaprogramming in Other Languages */

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-20T18:18:43Z

Twfolsom:

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-20T18:17:01Z

Twfolsom:

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-20T04:10:19Z

Twfolsom: /* Metaprogramming in Other Languages */

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-20T03:46:16Z

Twfolsom: /* Metaprogramming in Other Languages */

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-20T03:40:15Z

Twfolsom:

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-20T03:32:30Z

Twfolsom: /* The C preprocessor (CPP) */

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-20T03:23:03Z

Twfolsom: /* The C preprocessor (CPP) */

CSC/ECE 517 Spring 2013/ch1b 1k hf

2013-02-20T03:22:31Z

Twfolsom: /* Metaprogramming in Other Languages */