Expertiza_Wiki - User contributions [en]

CSC/ECE 517/M601 Design Document

2013-04-02T03:17:48Z

Jrwills2: /* Resources */

Design Document for M601 - Add ability to update css through
webapp
Team members: Yuri Kolesnikov, Jonathan Wills, Jeffrey Plemmons, Roshna Agarwal

==Purpose==
The purpose is to add the functionality of allowing the admin to customize the OpenMRS css file to their own specifications. By having the ability to customize the OpenMRS css file, the admin will be free to change the look and feel in their installation of OpenMRS.

==Problem Definition==
Add admin page for customization of the openmrs css file. Admins can 'override' any openmrs css with their own file by specifying that file in the openmrs runtime properties file. (See https://wiki.openmrs.org/display/docs/Overriding+OpenMRS+Default+Runtime+Properties)
This would be best as a new module in openmrs (See https://wiki.openmrs.org/display/docs/Modules)
Or perhaps just adding a new feature in the Custom Logo module? The admin should see a page with a large text box. The text box value should be persisted in the database as a new object/table/column somehow. When the module starts up, the Activator is called. Modify the activator to update the filesystem css file with whatever is defined by the admin. https://wiki.openmrs.org/display/docs/Module+Activator

==Requirements==

The admin should be able to customize the openmrs css file through an admin page.
The admin should see a page with a large text box.
The text box content should be stored in the database.
The activator needs to be modified so that it updates the filesystem css file with whatever is defined by the admin.
Need to use Eclipse, Maven, and Ant as development tools for the module.
==Tasks==
'''Week 1'''

*Get OpenMRS Id
*Get ticket assigned and in progress
*Get openmrs module name assigned
*Create openmrs module
*Commit module to github
*Check out module on partner machines
*Get new admin page link
*Create new spring controller and jsp page
'''Week 2'''

*Create object for storing css in db
*Create service layer and dao layer methods to save object
*Connect controller to db object for saving + retrieving
*Add unit tests for saving/retrieving
'''Week 3'''

*Create settings page to allow admin to choose where tomcat is running
*Add some magic so that module tries to guess where tomcat is running
*Add ability to put the saved css into the right folder in tomcat so that the css is actually overriding the openmrs style.css file.

CSC/ECE 517/M601 Design Document

2013-04-02T03:06:12Z

Jrwills2: /* Problem Definition */

CSC/ECE 517/M601 Design Document

2013-04-02T03:01:48Z

Jrwills2: /* Tasks */

Design Document for M601 - Add ability to update css through
webapp
Team members: Yuri Kolesnikov, Jonathan Wills, Jeffrey Plemmons, Roshna Agarwal

==Purpose==
The purpose is to add the functionality of allowing the admin to customize the OpenMRS css file to their own specifications. By having the ability to customize the OpenMRS css file, the admin will be free to change the look and feel in their installation of OpenMRS.

==Problem Definition==
Add admin page for customization of the openmrs css file. Admins can 'override' any openmrs css with their own file by specifying that file in the openmrs runtime properties file. See https://wiki.openmrs.org/display/docs/Overriding+OpenMRS+Default+Runtime+Properties
This would be best as a new module in openmrs. https://wiki.openmrs.org/display/docs/Modules
Or perhaps just adding a new feature in the Custom Logo module? The admin should see a page with a large text box. The text box value should be persisted in the database as a new object/table/column somehow. When the module starts up, the Activator is called. Modify the activator to update the filesystem css file with whatever is defined by the admin. https://wiki.openmrs.org/display/docs/Module+Activator

==Requirements==

The admin should be able to customize the openmrs css file through an admin page.
The admin should see a page with a large text box.
The text box content should be stored in the database.
The activator needs to be modified so that it updates the filesystem css file with whatever is defined by the admin.
Need to use Eclipse, Maven, and Ant as development tools for the module.
==Tasks==
'''Week 1'''

*Get OpenMRS Id
*Get ticket assigned and in progress
*Get openmrs module name assigned
*Create openmrs module
*Commit module to github
*Check out module on partner machines
*Get new admin page link
*Create new spring controller and jsp page
'''Week 2'''

*Create object for storing css in db
*Create service layer and dao layer methods to save object
*Connect controller to db object for saving + retrieving
*Add unit tests for saving/retrieving
'''Week 3'''

*Create settings page to allow admin to choose where tomcat is running
*Add some magic so that module tries to guess where tomcat is running
*Add ability to put the saved css into the right folder in tomcat so that the css is actually overriding the openmrs style.css file.

==Resources==

CSC/ECE 517/M601 Design Document

2013-04-02T03:01:22Z

Jrwills2: /* Tasks */

Design Document for M601 - Add ability to update css through
webapp
Team members: Yuri Kolesnikov, Jonathan Wills, Jeffrey Plemmons, Roshna Agarwal

==Purpose==
The purpose is to add the functionality of allowing the admin to customize the OpenMRS css file to their own specifications. By having the ability to customize the OpenMRS css file, the admin will be free to change the look and feel in their installation of OpenMRS.

==Problem Definition==
Add admin page for customization of the openmrs css file. Admins can 'override' any openmrs css with their own file by specifying that file in the openmrs runtime properties file. See https://wiki.openmrs.org/display/docs/Overriding+OpenMRS+Default+Runtime+Properties
This would be best as a new module in openmrs. https://wiki.openmrs.org/display/docs/Modules
Or perhaps just adding a new feature in the Custom Logo module? The admin should see a page with a large text box. The text box value should be persisted in the database as a new object/table/column somehow. When the module starts up, the Activator is called. Modify the activator to update the filesystem css file with whatever is defined by the admin. https://wiki.openmrs.org/display/docs/Module+Activator

==Requirements==

The admin should be able to customize the openmrs css file through an admin page.
The admin should see a page with a large text box.
The text box content should be stored in the database.
The activator needs to be modified so that it updates the filesystem css file with whatever is defined by the admin.
Need to use Eclipse, Maven, and Ant as development tools for the module.
==Tasks==
'''Week 1:'''

*Get OpenMRS Id
*Get ticket assigned and in progress
*Get openmrs module name assigned
*Create openmrs module
*Commit module to github
*Check out module on partner machines
*Get new admin page link
*Create new spring controller and jsp page
Week 2:

Create object for storing css in db
Create service layer and dao layer methods to save object
Connect controller to db object for saving + retrieving
Add unit tests for saving/retrieving
Week 3:

Create settings page to allow admin to choose where tomcat is running
Add some magic so that module tries to guess where tomcat is running
Add ability to put the saved css into the right folder in tomcat so that the css is actually overriding the openmrs style.css file.

==Resources==

CSC/ECE 517/M601 Design Document

2013-04-02T03:01:11Z

Jrwills2: /* Tasks */

Design Document for M601 - Add ability to update css through
webapp
Team members: Yuri Kolesnikov, Jonathan Wills, Jeffrey Plemmons, Roshna Agarwal

==Purpose==
The purpose is to add the functionality of allowing the admin to customize the OpenMRS css file to their own specifications. By having the ability to customize the OpenMRS css file, the admin will be free to change the look and feel in their installation of OpenMRS.

==Problem Definition==
Add admin page for customization of the openmrs css file. Admins can 'override' any openmrs css with their own file by specifying that file in the openmrs runtime properties file. See https://wiki.openmrs.org/display/docs/Overriding+OpenMRS+Default+Runtime+Properties
This would be best as a new module in openmrs. https://wiki.openmrs.org/display/docs/Modules
Or perhaps just adding a new feature in the Custom Logo module? The admin should see a page with a large text box. The text box value should be persisted in the database as a new object/table/column somehow. When the module starts up, the Activator is called. Modify the activator to update the filesystem css file with whatever is defined by the admin. https://wiki.openmrs.org/display/docs/Module+Activator

==Requirements==

The admin should be able to customize the openmrs css file through an admin page.
The admin should see a page with a large text box.
The text box content should be stored in the database.
The activator needs to be modified so that it updates the filesystem css file with whatever is defined by the admin.
Need to use Eclipse, Maven, and Ant as development tools for the module.
==Tasks==
Week 1:

*Get OpenMRS Id
*Get ticket assigned and in progress
*Get openmrs module name assigned
*Create openmrs module
*Commit module to github
*Check out module on partner machines
*Get new admin page link
*Create new spring controller and jsp page
Week 2:

Create object for storing css in db
Create service layer and dao layer methods to save object
Connect controller to db object for saving + retrieving
Add unit tests for saving/retrieving
Week 3:

Create settings page to allow admin to choose where tomcat is running
Add some magic so that module tries to guess where tomcat is running
Add ability to put the saved css into the right folder in tomcat so that the css is actually overriding the openmrs style.css file.

==Resources==

CSC/ECE 517/M601 Design Document

2013-04-02T02:59:52Z

Jrwills2: Created page with "Design Document for M601 - Add ability to update css through webapp Team members: Yuri Kolesnikov, Jonathan Wills, Jeffrey Plemmons, Roshna Agarwal ==Purpose== The purpose is ..."

Design Document for M601 - Add ability to update css through
webapp
Team members: Yuri Kolesnikov, Jonathan Wills, Jeffrey Plemmons, Roshna Agarwal

==Purpose==
The purpose is to add the functionality of allowing the admin to customize the OpenMRS css file to their own specifications. By having the ability to customize the OpenMRS css file, the admin will be free to change the look and feel in their installation of OpenMRS.

==Problem Definition==
Add admin page for customization of the openmrs css file. Admins can 'override' any openmrs css with their own file by specifying that file in the openmrs runtime properties file. See https://wiki.openmrs.org/display/docs/Overriding+OpenMRS+Default+Runtime+Properties
This would be best as a new module in openmrs. https://wiki.openmrs.org/display/docs/Modules
Or perhaps just adding a new feature in the Custom Logo module? The admin should see a page with a large text box. The text box value should be persisted in the database as a new object/table/column somehow. When the module starts up, the Activator is called. Modify the activator to update the filesystem css file with whatever is defined by the admin. https://wiki.openmrs.org/display/docs/Module+Activator

==Requirements==

The admin should be able to customize the openmrs css file through an admin page.
The admin should see a page with a large text box.
The text box content should be stored in the database.
The activator needs to be modified so that it updates the filesystem css file with whatever is defined by the admin.
Need to use Eclipse, Maven, and Ant as development tools for the module.
==Tasks==
Week 1:

Get OpenMRS Id
Get ticket assigned and in progress
Get openmrs module name assigned
Create openmrs module
Commit module to github
Check out module on partner machines
Get new admin page link
Create new spring controller and jsp page
Week 2:

Create object for storing css in db
Create service layer and dao layer methods to save object
Connect controller to db object for saving + retrieving
Add unit tests for saving/retrieving
Week 3:

Create settings page to allow admin to choose where tomcat is running
Add some magic so that module tries to guess where tomcat is running
Add ability to put the saved css into the right folder in tomcat so that the css is actually overriding the openmrs style.css file.

==Resources==

CSC/ECE 517 Spring 2013/OSS E605B

2013-03-29T00:57:31Z

Jrwills2: /* Questionnaire Subclass Unit Tests */

=Testing - questionnaire=
[https://docs.google.com/a/ncsu.edu/document/d/1SVNx7Eh6dUdrz2a9rGSgBxLkxAmuBUm8eu08nHEdjIg/edit# Project Description]

[https://github.com/chunsingtsui/expertiza Project Github Repository]

[http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Wiki]

== 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 new fixtures 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 our new fixures.

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

We tried to cover as many types of useful cases as possible according to the project requirements. We used assertions that checked counts after create and delete, as well as asserted redirects. We also tested against invalid inputs that could cause errors. All of the tests are self-explanatory based on their method names, and there really is no need to further provide explanations here.

We also attempted to test the private methods of the controller as well at the beginning of the project. However, we couldn't find a way to test many of them due to the fact that they reference the params[] hash in the methods, and we can't isolate the testing of those methods without calling some controller action. Since these private methods are only used by the public controller action methods, we did the next best thing by creating tests for the action methods that would use these private methods to test them indirectly.

=== 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. In Rubymine, this can be done by right clicking the test file and selecting "Run <filename>". Individual tests inside each test file can also be run by right clicking on the test method name and selecting "Run <method_name>". If the command line is preferred, the following command can be used:

ruby -Itest test/functional/questionnaire_controller_test.rb

== Questionnaire Subclass Unit Tests ==

The original assignment was to write unit tests for the Questionnaire subclasses:
* author_feedback_questionnaire.rb
* metareview_questionnaire.rb
* review_questionnaire.rb
* teammate_review_questionnaire.rb

As we reviewed the tests, it was found that most of the methods were trivial (ex: the method "symbol" only returns a hardcoded symbol). The only method 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.rb) 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 ===

The method "compute_weighted_score" from the the base class was the only thing that needed to be tested (due to the above reason). 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. Same as directions for the functional test, this can be run in either Rubymine or the command line. In Rubymine, this can be done by right clicking the test file and selecting "Run <filename>". Individual tests inside each test file can also be run by right clicking on the test method name and selecting "Run <method_name>". If the command line is preferred, the following command can be used:

ruby -Itest test/unit/questionnaire_test.rb

=== VNC Server Information ===

IP: 152.46.16.122:2
Password: project517

== 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
* The test that uses the "delete" action in the controller was failing due to a potential bug in the questionnaire.rb model class (refer to ''Potential Bug'' section)

=== List of files changed ===
*test/fixtures/assignment_questionnaires.yml
*test/fixtures/question_types.yml
*test/fixtures/questionnaires.yml
*test/fixtures/questions.yml
*test/functional/questionnaire_controller_test.rb
*test/unit/questionnaire_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

= Potential Bug =
The Questionnaire model class contains a ''has_many :assignment_questionnaire'' that should be ''has_many :assignment_questionnaire'''s''' '' according to convention. Because of this, our "delete" action test fails since it doesn't match the convention. If it is indeed incorrect, then in the "compute_weighted_score" method, the ''self.assignemnt_questionnaire...'' call also needs to be changed to ''self.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 thoroughly.

CSC/ECE 517 Spring 2013/OSS E605B

2013-03-29T00:56:20Z

Jrwills2: /* Testing - questionnaire */

=Testing - questionnaire=
[https://docs.google.com/a/ncsu.edu/document/d/1SVNx7Eh6dUdrz2a9rGSgBxLkxAmuBUm8eu08nHEdjIg/edit# Project Description]

[https://github.com/chunsingtsui/expertiza Project Github Repository]

[http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Wiki]

== 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 new fixtures 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 our new fixures.

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

We tried to cover as many types of useful cases as possible according to the project requirements. We used assertions that checked counts after create and delete, as well as asserted redirects. We also tested against invalid inputs that could cause errors. All of the tests are self-explanatory based on their method names, and there really is no need to further provide explanations here.

We also attempted to test the private methods of the controller as well at the beginning of the project. However, we couldn't find a way to test many of them due to the fact that they reference the params[] hash in the methods, and we can't isolate the testing of those methods without calling some controller action. Since these private methods are only used by the public controller action methods, we did the next best thing by creating tests for the action methods that would use these private methods to test them indirectly.

=== 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. In Rubymine, this can be done by right clicking the test file and selecting "Run <filename>". Individual tests inside each test file can also be run by right clicking on the test method name and selecting "Run <method_name>". If the command line is preferred, the following command can be used:

ruby -Itest test/functional/questionnaire_controller_test.rb

== Questionnaire Subclass Unit Tests ==

The original assignment was to write unit tests for the Questionnaire subclasses:
* author_feedback_questionnaire.rb
* metareview_questionnaire.rb
* review_questionnaire.rb
* teammate_review_questionnaire.rb

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 method 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.rb) 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 ===

The method "compute_weighted_score" from the the base class was the only thing that needed to be tested (due to the above reason). 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. Same as directions for the functional test, this can be run in either Rubymine or the command line. In Rubymine, this can be done by right clicking the test file and selecting "Run <filename>". Individual tests inside each test file can also be run by right clicking on the test method name and selecting "Run <method_name>". If the command line is preferred, the following command can be used:

ruby -Itest test/unit/questionnaire_test.rb

=== VNC Server Information ===

IP: 152.46.16.122:2
Password: project517

== 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
* The test that uses the "delete" action in the controller was failing due to a potential bug in the questionnaire.rb model class (refer to ''Potential Bug'' section)

=== List of files changed ===
*test/fixtures/assignment_questionnaires.yml
*test/fixtures/question_types.yml
*test/fixtures/questionnaires.yml
*test/fixtures/questions.yml
*test/functional/questionnaire_controller_test.rb
*test/unit/questionnaire_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

= Potential Bug =
The Questionnaire model class contains a ''has_many :assignment_questionnaire'' that should be ''has_many :assignment_questionnaire'''s''' '' according to convention. Because of this, our "delete" action test fails since it doesn't match the convention. If it is indeed incorrect, then in the "compute_weighted_score" method, the ''self.assignemnt_questionnaire...'' call also needs to be changed to ''self.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 thoroughly.

CSC/ECE 517 Spring 2013/OSS E605B

2013-03-29T00:54:19Z

Jrwills2: /* Testing - questionnaire */

=Testing - questionnaire=
[https://docs.google.com/a/ncsu.edu/document/d/1SVNx7Eh6dUdrz2a9rGSgBxLkxAmuBUm8eu08nHEdjIg/edit# Project Description]

[https://github.com/chunsingtsui/expertiza Project Github Repository]

== 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 new fixtures 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 our new fixures.

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

We tried to cover as many types of useful cases as possible according to the project requirements. We used assertions that checked counts after create and delete, as well as asserted redirects. We also tested against invalid inputs that could cause errors. All of the tests are self-explanatory based on their method names, and there really is no need to further provide explanations here.

We also attempted to test the private methods of the controller as well at the beginning of the project. However, we couldn't find a way to test many of them due to the fact that they reference the params[] hash in the methods, and we can't isolate the testing of those methods without calling some controller action. Since these private methods are only used by the public controller action methods, we did the next best thing by creating tests for the action methods that would use these private methods to test them indirectly.

=== 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. In Rubymine, this can be done by right clicking the test file and selecting "Run <filename>". Individual tests inside each test file can also be run by right clicking on the test method name and selecting "Run <method_name>". If the command line is preferred, the following command can be used:

ruby -Itest test/functional/questionnaire_controller_test.rb

== Questionnaire Subclass Unit Tests ==

The original assignment was to write unit tests for the Questionnaire subclasses:
* author_feedback_questionnaire.rb
* metareview_questionnaire.rb
* review_questionnaire.rb
* teammate_review_questionnaire.rb

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 method 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.rb) 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 ===

The method "compute_weighted_score" from the the base class was the only thing that needed to be tested (due to the above reason). 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. Same as directions for the functional test, this can be run in either Rubymine or the command line. In Rubymine, this can be done by right clicking the test file and selecting "Run <filename>". Individual tests inside each test file can also be run by right clicking on the test method name and selecting "Run <method_name>". If the command line is preferred, the following command can be used:

ruby -Itest test/unit/questionnaire_test.rb

=== VNC Server Information ===

IP: 152.46.16.122:2
Password: project517

== 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
* The test that uses the "delete" action in the controller was failing due to a potential bug in the questionnaire.rb model class (refer to ''Potential Bug'' section)

=== List of files changed ===
*test/fixtures/assignment_questionnaires.yml
*test/fixtures/question_types.yml
*test/fixtures/questionnaires.yml
*test/fixtures/questions.yml
*test/functional/questionnaire_controller_test.rb
*test/unit/questionnaire_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

= Potential Bug =
The Questionnaire model class contains a ''has_many :assignment_questionnaire'' that should be ''has_many :assignment_questionnaire'''s''' '' according to convention. Because of this, our "delete" action test fails since it doesn't match the convention. If it is indeed incorrect, then in the "compute_weighted_score" method, the ''self.assignemnt_questionnaire...'' call also needs to be changed to ''self.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 thoroughly.

CSC/ECE 517 Spring 2013/OSS E605B

2013-03-29T00:54:01Z

Jrwills2: /* Testing - questionnaire */

=Testing - questionnaire=
[https://docs.google.com/a/ncsu.edu/document/d/1SVNx7Eh6dUdrz2a9rGSgBxLkxAmuBUm8eu08nHEdjIg/edit# Project Description]

[https://github.com/chunsingtsui/expertiza Project Repository https://github.com/chunsingtsui/expertiza]

== 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 new fixtures 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 our new fixures.

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

We tried to cover as many types of useful cases as possible according to the project requirements. We used assertions that checked counts after create and delete, as well as asserted redirects. We also tested against invalid inputs that could cause errors. All of the tests are self-explanatory based on their method names, and there really is no need to further provide explanations here.

We also attempted to test the private methods of the controller as well at the beginning of the project. However, we couldn't find a way to test many of them due to the fact that they reference the params[] hash in the methods, and we can't isolate the testing of those methods without calling some controller action. Since these private methods are only used by the public controller action methods, we did the next best thing by creating tests for the action methods that would use these private methods to test them indirectly.

=== 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. In Rubymine, this can be done by right clicking the test file and selecting "Run <filename>". Individual tests inside each test file can also be run by right clicking on the test method name and selecting "Run <method_name>". If the command line is preferred, the following command can be used:

ruby -Itest test/functional/questionnaire_controller_test.rb

== Questionnaire Subclass Unit Tests ==

The original assignment was to write unit tests for the Questionnaire subclasses:
* author_feedback_questionnaire.rb
* metareview_questionnaire.rb
* review_questionnaire.rb
* teammate_review_questionnaire.rb

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 method 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.rb) 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 ===

The method "compute_weighted_score" from the the base class was the only thing that needed to be tested (due to the above reason). 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. Same as directions for the functional test, this can be run in either Rubymine or the command line. In Rubymine, this can be done by right clicking the test file and selecting "Run <filename>". Individual tests inside each test file can also be run by right clicking on the test method name and selecting "Run <method_name>". If the command line is preferred, the following command can be used:

ruby -Itest test/unit/questionnaire_test.rb

=== VNC Server Information ===

IP: 152.46.16.122:2
Password: project517

== 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
* The test that uses the "delete" action in the controller was failing due to a potential bug in the questionnaire.rb model class (refer to ''Potential Bug'' section)

=== List of files changed ===
*test/fixtures/assignment_questionnaires.yml
*test/fixtures/question_types.yml
*test/fixtures/questionnaires.yml
*test/fixtures/questions.yml
*test/functional/questionnaire_controller_test.rb
*test/unit/questionnaire_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

= Potential Bug =
The Questionnaire model class contains a ''has_many :assignment_questionnaire'' that should be ''has_many :assignment_questionnaire'''s''' '' according to convention. Because of this, our "delete" action test fails since it doesn't match the convention. If it is indeed incorrect, then in the "compute_weighted_score" method, the ''self.assignemnt_questionnaire...'' call also needs to be changed to ''self.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 thoroughly.

CSC/ECE 517 Spring 2013/OSS E605B

2013-03-29T00:53:40Z

Jrwills2: /* Testing - questionnaire */

=Testing - questionnaire=
[https://docs.google.com/a/ncsu.edu/document/d/1SVNx7Eh6dUdrz2a9rGSgBxLkxAmuBUm8eu08nHEdjIg/edit# Project Description]

[https://github.com/chunsingtsui/expertiza Project Repository]

== 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 new fixtures 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 our new fixures.

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

We tried to cover as many types of useful cases as possible according to the project requirements. We used assertions that checked counts after create and delete, as well as asserted redirects. We also tested against invalid inputs that could cause errors. All of the tests are self-explanatory based on their method names, and there really is no need to further provide explanations here.

We also attempted to test the private methods of the controller as well at the beginning of the project. However, we couldn't find a way to test many of them due to the fact that they reference the params[] hash in the methods, and we can't isolate the testing of those methods without calling some controller action. Since these private methods are only used by the public controller action methods, we did the next best thing by creating tests for the action methods that would use these private methods to test them indirectly.

=== 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. In Rubymine, this can be done by right clicking the test file and selecting "Run <filename>". Individual tests inside each test file can also be run by right clicking on the test method name and selecting "Run <method_name>". If the command line is preferred, the following command can be used:

ruby -Itest test/functional/questionnaire_controller_test.rb

== Questionnaire Subclass Unit Tests ==

The original assignment was to write unit tests for the Questionnaire subclasses:
* author_feedback_questionnaire.rb
* metareview_questionnaire.rb
* review_questionnaire.rb
* teammate_review_questionnaire.rb

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 method 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.rb) 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 ===

The method "compute_weighted_score" from the the base class was the only thing that needed to be tested (due to the above reason). 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. Same as directions for the functional test, this can be run in either Rubymine or the command line. In Rubymine, this can be done by right clicking the test file and selecting "Run <filename>". Individual tests inside each test file can also be run by right clicking on the test method name and selecting "Run <method_name>". If the command line is preferred, the following command can be used:

ruby -Itest test/unit/questionnaire_test.rb

=== VNC Server Information ===

IP: 152.46.16.122:2
Password: project517

== 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
* The test that uses the "delete" action in the controller was failing due to a potential bug in the questionnaire.rb model class (refer to ''Potential Bug'' section)

=== List of files changed ===
*test/fixtures/assignment_questionnaires.yml
*test/fixtures/question_types.yml
*test/fixtures/questionnaires.yml
*test/fixtures/questions.yml
*test/functional/questionnaire_controller_test.rb
*test/unit/questionnaire_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

= Potential Bug =
The Questionnaire model class contains a ''has_many :assignment_questionnaire'' that should be ''has_many :assignment_questionnaire'''s''' '' according to convention. Because of this, our "delete" action test fails since it doesn't match the convention. If it is indeed incorrect, then in the "compute_weighted_score" method, the ''self.assignemnt_questionnaire...'' call also needs to be changed to ''self.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 thoroughly.

CSC/ECE 517 Spring 2013/OSS E605B

2013-03-29T00:53:29Z

Jrwills2: /* Testing - questionnaire */

=Testing - questionnaire=
[https://docs.google.com/a/ncsu.edu/document/d/1SVNx7Eh6dUdrz2a9rGSgBxLkxAmuBUm8eu08nHEdjIg/edit# Project Description]
[https://github.com/chunsingtsui/expertiza Project Repository]

== 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 new fixtures 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 our new fixures.

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

We tried to cover as many types of useful cases as possible according to the project requirements. We used assertions that checked counts after create and delete, as well as asserted redirects. We also tested against invalid inputs that could cause errors. All of the tests are self-explanatory based on their method names, and there really is no need to further provide explanations here.

We also attempted to test the private methods of the controller as well at the beginning of the project. However, we couldn't find a way to test many of them due to the fact that they reference the params[] hash in the methods, and we can't isolate the testing of those methods without calling some controller action. Since these private methods are only used by the public controller action methods, we did the next best thing by creating tests for the action methods that would use these private methods to test them indirectly.

=== 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. In Rubymine, this can be done by right clicking the test file and selecting "Run <filename>". Individual tests inside each test file can also be run by right clicking on the test method name and selecting "Run <method_name>". If the command line is preferred, the following command can be used:

ruby -Itest test/functional/questionnaire_controller_test.rb

== Questionnaire Subclass Unit Tests ==

The original assignment was to write unit tests for the Questionnaire subclasses:
* author_feedback_questionnaire.rb
* metareview_questionnaire.rb
* review_questionnaire.rb
* teammate_review_questionnaire.rb

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 method 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.rb) 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 ===

The method "compute_weighted_score" from the the base class was the only thing that needed to be tested (due to the above reason). 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. Same as directions for the functional test, this can be run in either Rubymine or the command line. In Rubymine, this can be done by right clicking the test file and selecting "Run <filename>". Individual tests inside each test file can also be run by right clicking on the test method name and selecting "Run <method_name>". If the command line is preferred, the following command can be used:

ruby -Itest test/unit/questionnaire_test.rb

=== VNC Server Information ===

IP: 152.46.16.122:2
Password: project517

== 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
* The test that uses the "delete" action in the controller was failing due to a potential bug in the questionnaire.rb model class (refer to ''Potential Bug'' section)

=== List of files changed ===
*test/fixtures/assignment_questionnaires.yml
*test/fixtures/question_types.yml
*test/fixtures/questionnaires.yml
*test/fixtures/questions.yml
*test/functional/questionnaire_controller_test.rb
*test/unit/questionnaire_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

= Potential Bug =
The Questionnaire model class contains a ''has_many :assignment_questionnaire'' that should be ''has_many :assignment_questionnaire'''s''' '' according to convention. Because of this, our "delete" action test fails since it doesn't match the convention. If it is indeed incorrect, then in the "compute_weighted_score" method, the ''self.assignemnt_questionnaire...'' call also needs to be changed to ''self.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 thoroughly.

CSC/ECE 517 Spring 2013/OSS E605B

2013-03-21T14:58:43Z

Jrwills2: /* Testing - questionnaire */

=Testing - questionnaire=
[https://docs.google.com/a/ncsu.edu/document/d/1SVNx7Eh6dUdrz2a9rGSgBxLkxAmuBUm8eu08nHEdjIg/edit# Project Description]

== 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 new fixtures 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 our new fixures.

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

We tried to cover as many types of useful cases as possible according to the project requirements. We used assertions that checked counts after create and delete, as well as asserted redirects. We also tested against invalid inputs that could cause errors. All of the tests are self-explanatory based on their method names, and there really is no need to further provide explanations here.

We also attempted to test the private methods of the controller as well at the beginning of the project. However, we couldn't find a way to test many of them due to the fact that they reference the params[] hash in the methods, and we can't isolate the testing of those methods without calling some controller action. Since these private methods are only used by the public controller action methods, we did the next best thing by creating tests for the action methods that would use these private methods to test them indirectly.

=== 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. In Rubymine, this can be done by right clicking the test file and selecting "Run <filename>". Individual tests inside each test file can also be run by right clicking on the test method name and selecting "Run <method_name>". If the command line is preferred, the following command can be used:

ruby -Itest test/functional/questionnaire_controller_test.rb

== Questionnaire Subclass Unit Tests ==

The original assignment was to write unit tests for the Questionnaire subclasses:
* author_feedback_questionnaire.rb
* metareview_questionnaire.rb
* review_questionnaire.rb
* teammate_review_questionnaire.rb

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 method 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.rb) 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 ===

The method "compute_weighted_score" from the the base class was the only thing that needed to be tested (due to the above reason). 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. Same as directions for the functional test, this can be run in either Rubymine or the command line. In Rubymine, this can be done by right clicking the test file and selecting "Run <filename>". Individual tests inside each test file can also be run by right clicking on the test method name and selecting "Run <method_name>". If the command line is preferred, the following command can be used:

ruby -Itest test/unit/questionnaire_test.rb

=== VNC Server Information ===

IP: 152.46.16.122:2
Password: project517

== 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
* The test that uses the "delete" action in the controller was failing due to a potential bug in the questionnaire.rb model class (refer to ''Potential Bug'' section)

=== List of files changed ===
*test/fixtures/assignment_questionnaires.yml
*test/fixtures/question_types.yml
*test/fixtures/questionnaires.yml
*test/fixtures/questions.yml
*test/functional/questionnaire_controller_test.rb
*test/unit/questionnaire_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

= Potential Bug =
The Questionnaire model class contains a ''has_many :assignment_questionnaire'' that should be ''has_many :assignment_questionnaire'''s''' '' according to convention. Because of this, our "delete" action test fails since it doesn't match the convention. If it is indeed incorrect, then in the "compute_weighted_score" method, the ''self.assignemnt_questionnaire...'' call also needs to be changed to ''self.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 thoroughly.

CSC/ECE 517 Spring 2013/OSS E605B

2013-03-20T04:27:04Z

Jrwills2: /* Summary of Project */

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

== Summary of Project ==

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

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

== 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-20T04:26:44Z

Jrwills2: /* Summary of Project */

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

== Summary of Project ==

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

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

== 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-20T04:26:04Z

Jrwills2: /* Summary of Project */

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

== Summary of Project ==

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

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

== 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-20T04:24:14Z

Jrwills2: /* Test Coverage */

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

== Summary of Project ==

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

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

== 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-20T04:24:02Z

Jrwills2: /* Test Coverage */

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

== Summary of Project ==

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

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

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

== 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-20T04:23:36Z

Jrwills2: /* Helper Methods */

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

== Summary of Project ==

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

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

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

== 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-20T04:22:32Z

Jrwills2: /* Helper Methods */

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

== Summary of Project ==

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

==== 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. This is true of the current user types, 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.

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

== 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-20T04:01:58Z

Jrwills2: /* Helper Methods */

CSC/ECE 517 Spring 2013/OSS E605B

2013-03-20T04:01:46Z

Jrwills2: /* Helper Methods */

CSC/ECE 517 Spring 2013/OSS E605B

2013-03-20T04:00:43Z

Jrwills2: /* questionnaire_controller_test */

CSC/ECE 517 Spring 2013/OSS E605B

2013-03-20T04:00:21Z

Jrwills2: /* questionnaire_controller_test */

CSC/ECE 517 Spring 2013/OSS E605B

2013-03-20T03:59:34Z

Jrwills2: /* questionnaire_controller_test */

CSC/ECE 517 Spring 2013/OSS E605B

2013-03-20T03:57:47Z

Jrwills2: /* questionnaire_controller_test */

CSC/ECE 517 Spring 2013/OSS E605B

2013-03-20T03:56:39Z

Jrwills2: /* Testing - questionnaire */

CSC/ECE 517 Spring 2013/OSS E605B

2013-03-20T03:47:28Z

Jrwills2: /* Summary of Project */

CSC/ECE 517 Spring 2013/OSS E605B

2013-03-20T03:47:09Z

Jrwills2: /* =List of files changed */

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

== Summary 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-20T03:44:57Z

Jrwills2: /* Highlights */

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

== Summary 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/ch1 1h jc

2013-02-26T04:31:26Z

Jrwills2: /* Programming Language API */

Metaprogramming in statically typed languages
=Metaprogramming in statically typed languages=
==Introduction==
===What is metaprogramming===

[http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming] refers to writing programs that can manipulate other programs or themselves. The program that is doing the manipulating is called the ''metaprogram'', and the program that is being manipulated is called the ''object program''. The language of the ''metaprogram'' is referred to as the ''metalanguage'' and the language of the object program is called the ''object language''. A language has the ability of [http://en.wikipedia.org/wiki/Reflection_(computer_programming) reflection] if it can be used to write a metaprogram that can manipulate a program written in the same language. <ref name="mp1">http://en.wikipedia.org/wiki/Metaprogramming</ref>

===Metaprogramming in statically typed languages===

Metaprogramming can be accomplished in both statically and dynamically typed languages, however [http://en.wikipedia.org/wiki/Dynamically_typed_language#Dynamic_typing dynamically typed languages] have some advantages over [http://en.wikipedia.org/wiki/Dynamically_typed_language#Dynamic_typing statically typed languages] when it comes to metaprogramming.

One example of a metaprogramming task is to add a method to a particular class at runtime. Sample code in Ruby to perform this task is outlined below. First is a definition of a Ruby class called TestAddMethodAtRuntime:

class TestAddMethodAtRuntime
def originalMethod
puts "Original Method"
end
end

The code below created a new instance of the class. After that, it defines a new method called newlyAddedMethod. Then the original method is called, follow by the newly added method at runtime:

t = TestAddMethodAtRuntime.new
def t.newlyAddedMethod
puts "Newly Added Method"
end
t.originalMethod
puts "\n"
t.newlyAddedMethod

Below is the output of the code above:

Original Method
Newly Added Method

Accomplishing something like this in a statically typed language would be much more difficult or impossible depending on the language. It is for this reason that dynamically typed languages are usually viewed as being better equipped to handle metaprogramming overall.

==Implementation==
===Programming Language API===

One way that metaprogramming can be possible in a language is through an [http://en.wikipedia.org/wiki/API API] that helps programmers achieve a metaprogramming task. An example of this is a language that provides an API for reflection. One type of reflection is ''introspection'' in which the program can access the source code of the program itself. <ref name="ref1">https://blogs.oracle.com/java/entry/metaprogramming_manipulating_data_about_data</ref>

Below is an example from the Java API to illustrate how an API can be used to achieve some metaprogramming tasks:

import java.lang.reflect.*;
public class DumpMethods {
public static void main(String[] args) {
try {
Class c = Class.forName(args[0]);
Method m[] = c.getDeclaredMethods();
for (int i = 0; i < m.length; i++) {
System.out.println(m[i].toString());
}
}
catch (Throwable e) {
System.err.println(e);
}
}

The above example prints out all of the methods that are declared for a particular class. This is an example of metaprogramming since the program is accessing the source code of itself.

===Program transformation system===

A program transformation system is something that takes a program as the input, and outputs a different program. One example of a program transformation system is the Java compiler. The Java compiler takes a Java program as its input, and outputs a .class file with platform independent bytecode in it. Another example of a program transformation system is a Java decompiler, which takes bytecode as an input and outputs a Java program.

In the case of the Java compiler, the program input is being output into another program in a different "language". There are other types of transformation systems that take a program as an input and output a different program in the same language. One example of this would be ''program migration'' which migrates source code to a newer or older version of the same language. This can be useful if upgrading a software system to run on a newer version of a framework. <ref name="pm1">http://www.program-transformation.org/Transform/ProgramMigration</ref>

==Common Uses==
===Pre-generate static data at compile time===
One common use of metaprogramming in statically typed languages is to write programs that will pre-generate tables of data for use at runtime.<ref name="use1">Jonathan Bartlett, "The art of metaprogramming, Part 1: Introduction to metaprogramming", 20 Oct 2005 http://www.ibm.com/developerworks/library/l-metaprog1/index.html#N10052</ref>

One simple but useful code generator is to build static lookup tables. Often, in order to build fast functions in C programming, we simply create a lookup table of all of the answers. This means that we either need to pre-compute them by hand (which is wasteful of your time) or build them at runtime (which is wasteful of the user's time).

In following example we will build a generator that will take a function or set of functions on an integer and build lookup tables for the answer.

To think of how to make such a program, we can start from the end and work backward. Firstly we need a lookup table that will return square roots of numbers between 5 and 20. A simple program can be written to generate such a table like this:

Generate and use a lookup table of square roots

/* our lookup table */
double square_roots[21];
/* function to load the table at runtime */
void init_square_roots()
{
int i;
for(i = 5; i < 21; i++)
{
square_roots[i] = sqrt((double)i);
}
}

With that single macro, we can take away a lot of work for any program that has to generate mathematical tables indexed by integer. A little extra work would also allow tables containing full struct definitions; a little more would ensure that space isn't wasted at the front of the array with useless empty entries.
/* program that uses the table */
int main ()
{
init_square_roots();
printf("The square root of 5 is %f\n", square_roots[5]);
return 0;
}

Now, to convert this to a statically initialized array, you would remove the first part of the program and replace it with something like this, calculated by hand:

Square root program with a static lookup table

double square_roots[] = {
/* these are the ones we skipped */ 0.0, 0.0, 0.0, 0.0, 0.0
2.236068, /* Square root of 5 */
2.449490, /* Square root of 6 */
2.645751, /* Square root of 7 */
2.828427, /* Square root of 8 */
3.0, /* Square root of 9 */
...
4.472136 /* Square root of 20 */
};

What is needed is a program that will produce these values and print them out in a table like the previous one so they are loaded in at compile-time.

Code generator for the table macro

#!/usr/bin/perl
#
#tablegen.pl
#
##Puts each program line into $line
while(my $line = <>)
{
#Is this a macro invocation?
if($line =~ m/TABLE:/)
{
#If so, split it apart into its component pieces
my ($dummy, $table_name, $type, $start_idx, $end_idx, $default, $procedure) = split(m/:/, $line, 7);
#The main difference between C and Perl for mathematical expressions is that
#Perl prefixes its variables with a dollar sign, so we will add that here
$procedure =~ s/VAL/\$VAL/g;
#Print out the array declaration
print "${type} ${table_name} [] = {\n";
#Go through each array element
foreach my $VAL (0 .. $end_idx)
{
#Only process an answer if we have reached our starting index
if($VAL >= $start_idx)
{
#evaluate the procedure specified (this sets $@ if there are any errors)
$result = eval $procedure;
die("Error processing: $@") if $@;
}
else
{
#if we haven't reached the starting index, just use the default
$result = $default;
}
#Print out the value
print "\t${result}";
#If there are more to be processed, add a comma after the value
if($VAL != $end_idx)
{
print ",";
}
print "\n"
}
#Finish the declaration
print "};\n";
}
else
{
#If this is not a macro invocation, just copy the line directly to the output
print $line;
}
}

To run this program, do this:

Running the code generator

./tablegen.pl < sqrt.in > sqrt.c
gcc sqrt.c -o sqrt
./a.out

===Mini-language for boiler-plate===
If you have a large application where many of the functions include a lot of boilerplate code, it is often a good idea to create a mini-language that allows you to work with your boilerplate code in an easier fashion.<ref name="boiler">K. Czarnecki, "Generative Programming" chapter 8, Static Metaprogramming in C++</ref> This mini-language will then be converted into your regular source code language before compiling.<ref name="use2">Jonathan Bartlett, "The art of metaprogramming, Part 2: Metaprogramming using Scheme", 02 May 2006 http://www.ibm.com/developerworks/linux/library/l-metaprog2/index.html</ref>

The following is an example:

Let's say that we are building a CGI application consisting of many independent CGI scripts. In most CGI applications, much of the state is stored in a database, but only a session ID is passed to each script via a cookie.

However, in nearly every page we need to know the other standard information (such as the username, group number, the current job being worked on, whatever else information is pertinent). In addition, we need to redirect the user if they do not have an appropriate cookie.

(define (handle-cgi-request req)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
;;Code for processing goes here
))))

While some of that can be handled by a procedure, the bindings certainly cannot. However, we can turn most of it into a macro. The macro can be implemented like this:

(define-syntax cgi-boilerplate
(lambda (x)
(syntax-case x ()
(
(cgi-boilerplate expr)
(datum->syntax-object
(syntax k)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
(syntax-object->datum (syntax expr))))))
)
)))

We can now create new forms based on our boilerplate code by doing the following:

(define (handle-cgi-request req)
(cgi-boilerplate
(begin
;;Do whatever I want here
)))

In addition, since we are not defining our variables explicitly, adding new variable definitions to our boilerplate won't affect its calling conventions, so new features can be added without having to create a whole new function.

In any large project, there are inevitably templates to follow which cannot be reduced to functions, usually because of the bindings being created. Using boilerplate macros can make maintenance of such templated code much easier.

Likewise, other standard macros can be created which make use of variables defined in the boilerplate. Using macros like this significantly reduces typing because you do not have to constantly be writing and rewriting variable bindings, derivations, and parameter passing. This also reduces the potential for errors in such code.

Realize though that boilerplate macros are not a panacea. There are many significant problems that can occur, including:
* Accidentally overwriting bindings by introducing a variable name that was previously defined in a macro.
* Difficulty tracing problems because the inputs and the outputs of the macros are implicit, not explicit.

These can be largely avoided by doing a few things in conjunction with your boilerplate macros:
* Have a naming convention which clearly labels macros as such, as well as indicate that a variable came from boilerplate code. This could be done by affixing -m to macros and -b to variables defined within a boilerplate.
* Carefully document all boilerplate macros, especially the introduced variable bindings and all changes between versions.
* Only use boilerplate macros when the savings in repetitiveness clearly outweigh the negatives of implicit functionality.

===Abbreviate statements and prevent mistakes===
A lot of programming languages make you write really verbose statements to do really simple things. Code-generating programs allow you to abbreviate such statements and save a lot of typing, which also prevents a lot of mistakes because there is less chance of mistyping.

=Metaprogramming Framework in Java=
==Reflection==
===Introduction to reflection===
[http://en.wikipedia.org/wiki/Reflection_(computer_programming) Reflection] is the ability to introspect metalevel information about the program structure itself at runtime. Usually this metalevel information is modeled using the general abstraction mechanisms available in the language. In Java, reflection enables to discover information about the loaded classes:
* Fields,
* Methods, and
* Constructors
* Generics information
* Metadata annotations
It also enables to use these metaobjects to their instances in runtime environment.<ref name="meta_java">Abdelmonaim Remani, "The Art of Metaprogramming in Java", Jul 19, 2012 http://www.slideshare.net/PolymathicCoder/the-art-of-metaprogramming-in-java</ref>

The following is the Java metalevel architecture<ref name="reflection">Mika Haapakorpi, "Meta Programming In Java"</ref>

[[File:Metalevel architecture.PNG]]

===Dynamic proxy classes===
A dynamic proxy class implements a list of interfaces specified at runtime when the class is created.
* A proxy interface is an interface that is implemented by a proxy class.
* A proxy instance is an instance of a proxy class which has an associated invocation handler object.
The following is an example of dynamic proxy classes

[[File:Dynamic_proxy_class.PNG]]

==Generics==
[http://en.wikipedia.org/wiki/Generics_in_Java Generics] are a facility of generic programming that was added to the Java programming language in 2004 as part of J2SE 5.0. They allow "a type or method to operate on objects of various types while providing compile-time type safety." The generics can be used in classes, interfaces, methods and constructors.<ref name="reflection">Mika Haapakorpi, "Meta Programming In Java"</ref>
===Two new types in generics===
Two new types in generics:
* Parametrized types
* Type variables

A type variable is an unqualified identifier. Class and interface declarations can have type arguments (type variables). Method and constructors definitions can have type arguments (type variables).

The following is an example for type variables

List<String> anExample = new ArrayList<String>()

* List : interface
* ArrayList : class
* String : class (the actual type argument)
* List<String> and ArrayList<String> : parametrized type

===Class/Interface Declarations===
The following is an example of class declaration:

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

==Metadata annotation==
An annotation, in the Java computer programming language, is a form of syntactic metadata that can be added to Java source code. Classes, methods, variables, parameters and packages may be annotated.<ref name="reflection">Mika Haapakorpi, "Meta Programming In Java"</ref>

The following is an example of annotation:

/**
* Designates a formatter to pretty-print the annotated class.
*/
public @interface PrettyPrinter{
Class<? extends Formatter> value();
}
// Single-member annotation with Class
// member restricted by bounded wildcard
// The annotation presumes the existence of this class.
class GorgeousFormatterimplements Formatter { ... }
@PrettyPrinter(GorgeousFormatter.class)
public class Petunia { ... }

‘@’ indicates the start of an annotation definition.

=References=
<references/>

CSC/ECE 517 Spring 2013/ch1 1h jc

2013-02-26T04:18:54Z

Jrwills2: /* What is metaprogramming */

Metaprogramming in statically typed languages
=Metaprogramming in statically typed languages=
==Introduction==
===What is metaprogramming===

[http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming] refers to writing programs that can manipulate other programs or themselves. The program that is doing the manipulating is called the ''metaprogram'', and the program that is being manipulated is called the ''object program''. The language of the ''metaprogram'' is referred to as the ''metalanguage'' and the language of the object program is called the ''object language''. A language has the ability of [http://en.wikipedia.org/wiki/Reflection_(computer_programming) reflection] if it can be used to write a metaprogram that can manipulate a program written in the same language. <ref name="mp1">http://en.wikipedia.org/wiki/Metaprogramming</ref>

===Metaprogramming in statically typed languages===

Metaprogramming can be accomplished in both statically and dynamically typed languages, however [http://en.wikipedia.org/wiki/Dynamically_typed_language#Dynamic_typing dynamically typed languages] have some advantages over [http://en.wikipedia.org/wiki/Dynamically_typed_language#Dynamic_typing statically typed languages] when it comes to metaprogramming.

One example of a metaprogramming task is to add a method to a particular class at runtime. Sample code in Ruby to perform this task is outlined below. First is a definition of a Ruby class called TestAddMethodAtRuntime:

class TestAddMethodAtRuntime
def originalMethod
puts "Original Method"
end
end

The code below created a new instance of the class. After that, it defines a new method called newlyAddedMethod. Then the original method is called, follow by the newly added method at runtime:

t = TestAddMethodAtRuntime.new
def t.newlyAddedMethod
puts "Newly Added Method"
end
t.originalMethod
puts "\n"
t.newlyAddedMethod

Below is the output of the code above:

Original Method
Newly Added Method

Accomplishing something like this in a statically typed language would be much more difficult or impossible depending on the language. It is for this reason that dynamically typed languages are usually viewed as being better equipped to handle metaprogramming overall.

==Implementation==
===Programming Language API===

One way that metaprogramming can be possible in a language is through an [http://en.wikipedia.org/wiki/API API] that helps programmers achieve a metaprogramming task. An example of this is a language that provides an API for reflection. One type of reflection is ''introspection'' in which the program can access the source code of the program itself.

Below is an example from the Java API to illustrate how an API can be used to achieve some metaprogramming tasks:

import java.lang.reflect.*;
public class DumpMethods {
public static void main(String[] args) {
try {
Class c = Class.forName(args[0]);
Method m[] = c.getDeclaredMethods();
for (int i = 0; i < m.length; i++) {
System.out.println(m[i].toString());
}
}
catch (Throwable e) {
System.err.println(e);
}
}

The above example prints out all of the methods that are declared for a particular class. This is an example of metaprogramming since the program is accessing the source code of itself.

===Program transformation system===

A program transformation system is something that takes a program as the input, and outputs a different program. One example of a program transformation system is the Java compiler. The Java compiler takes a Java program as its input, and outputs a .class file with platform independent bytecode in it. Another example of a program transformation system is a Java decompiler, which takes bytecode as an input and outputs a Java program.

In the case of the Java compiler, the program input is being output into another program in a different "language". There are other types of transformation systems that take a program as an input and output a different program in the same language. One example of this would be ''program migration'' which migrates source code to a newer or older version of the same language. This can be useful if upgrading a software system to run on a newer version of a framework. <ref name="pm1">http://www.program-transformation.org/Transform/ProgramMigration</ref>

==Common Uses==
===Pre-generate static data at compile time===
One common use of metaprogramming in statically typed languages is to write programs that will pre-generate tables of data for use at runtime.<ref name="use1">Jonathan Bartlett, "The art of metaprogramming, Part 1: Introduction to metaprogramming", 20 Oct 2005 http://www.ibm.com/developerworks/library/l-metaprog1/index.html#N10052</ref>

One simple but useful code generator is to build static lookup tables. Often, in order to build fast functions in C programming, we simply create a lookup table of all of the answers. This means that we either need to pre-compute them by hand (which is wasteful of your time) or build them at runtime (which is wasteful of the user's time).

In following example we will build a generator that will take a function or set of functions on an integer and build lookup tables for the answer.

To think of how to make such a program, we can start from the end and work backward. Firstly we need a lookup table that will return square roots of numbers between 5 and 20. A simple program can be written to generate such a table like this:

Generate and use a lookup table of square roots

/* our lookup table */
double square_roots[21];
/* function to load the table at runtime */
void init_square_roots()
{
int i;
for(i = 5; i < 21; i++)
{
square_roots[i] = sqrt((double)i);
}
}

With that single macro, we can take away a lot of work for any program that has to generate mathematical tables indexed by integer. A little extra work would also allow tables containing full struct definitions; a little more would ensure that space isn't wasted at the front of the array with useless empty entries.
/* program that uses the table */
int main ()
{
init_square_roots();
printf("The square root of 5 is %f\n", square_roots[5]);
return 0;
}

Now, to convert this to a statically initialized array, you would remove the first part of the program and replace it with something like this, calculated by hand:

Square root program with a static lookup table

double square_roots[] = {
/* these are the ones we skipped */ 0.0, 0.0, 0.0, 0.0, 0.0
2.236068, /* Square root of 5 */
2.449490, /* Square root of 6 */
2.645751, /* Square root of 7 */
2.828427, /* Square root of 8 */
3.0, /* Square root of 9 */
...
4.472136 /* Square root of 20 */
};

What is needed is a program that will produce these values and print them out in a table like the previous one so they are loaded in at compile-time.

Code generator for the table macro

#!/usr/bin/perl
#
#tablegen.pl
#
##Puts each program line into $line
while(my $line = <>)
{
#Is this a macro invocation?
if($line =~ m/TABLE:/)
{
#If so, split it apart into its component pieces
my ($dummy, $table_name, $type, $start_idx, $end_idx, $default, $procedure) = split(m/:/, $line, 7);
#The main difference between C and Perl for mathematical expressions is that
#Perl prefixes its variables with a dollar sign, so we will add that here
$procedure =~ s/VAL/\$VAL/g;
#Print out the array declaration
print "${type} ${table_name} [] = {\n";
#Go through each array element
foreach my $VAL (0 .. $end_idx)
{
#Only process an answer if we have reached our starting index
if($VAL >= $start_idx)
{
#evaluate the procedure specified (this sets $@ if there are any errors)
$result = eval $procedure;
die("Error processing: $@") if $@;
}
else
{
#if we haven't reached the starting index, just use the default
$result = $default;
}
#Print out the value
print "\t${result}";
#If there are more to be processed, add a comma after the value
if($VAL != $end_idx)
{
print ",";
}
print "\n"
}
#Finish the declaration
print "};\n";
}
else
{
#If this is not a macro invocation, just copy the line directly to the output
print $line;
}
}

To run this program, do this:

Running the code generator

./tablegen.pl < sqrt.in > sqrt.c
gcc sqrt.c -o sqrt
./a.out

===Mini-language for boiler-plate===
If you have a large application where many of the functions include a lot of boilerplate code, it is often a good idea to create a mini-language that allows you to work with your boilerplate code in an easier fashion.<ref name="boiler">K. Czarnecki, "Generative Programming" chapter 8, Static Metaprogramming in C++</ref> This mini-language will then be converted into your regular source code language before compiling.<ref name="use2">Jonathan Bartlett, "The art of metaprogramming, Part 2: Metaprogramming using Scheme", 02 May 2006 http://www.ibm.com/developerworks/linux/library/l-metaprog2/index.html</ref>

The following is an example:

Let's say that we are building a CGI application consisting of many independent CGI scripts. In most CGI applications, much of the state is stored in a database, but only a session ID is passed to each script via a cookie.

However, in nearly every page we need to know the other standard information (such as the username, group number, the current job being worked on, whatever else information is pertinent). In addition, we need to redirect the user if they do not have an appropriate cookie.

(define (handle-cgi-request req)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
;;Code for processing goes here
))))

While some of that can be handled by a procedure, the bindings certainly cannot. However, we can turn most of it into a macro. The macro can be implemented like this:

(define-syntax cgi-boilerplate
(lambda (x)
(syntax-case x ()
(
(cgi-boilerplate expr)
(datum->syntax-object
(syntax k)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
(syntax-object->datum (syntax expr))))))
)
)))

We can now create new forms based on our boilerplate code by doing the following:

(define (handle-cgi-request req)
(cgi-boilerplate
(begin
;;Do whatever I want here
)))

In addition, since we are not defining our variables explicitly, adding new variable definitions to our boilerplate won't affect its calling conventions, so new features can be added without having to create a whole new function.

In any large project, there are inevitably templates to follow which cannot be reduced to functions, usually because of the bindings being created. Using boilerplate macros can make maintenance of such templated code much easier.

Likewise, other standard macros can be created which make use of variables defined in the boilerplate. Using macros like this significantly reduces typing because you do not have to constantly be writing and rewriting variable bindings, derivations, and parameter passing. This also reduces the potential for errors in such code.

Realize though that boilerplate macros are not a panacea. There are many significant problems that can occur, including:
* Accidentally overwriting bindings by introducing a variable name that was previously defined in a macro.
* Difficulty tracing problems because the inputs and the outputs of the macros are implicit, not explicit.

These can be largely avoided by doing a few things in conjunction with your boilerplate macros:
* Have a naming convention which clearly labels macros as such, as well as indicate that a variable came from boilerplate code. This could be done by affixing -m to macros and -b to variables defined within a boilerplate.
* Carefully document all boilerplate macros, especially the introduced variable bindings and all changes between versions.
* Only use boilerplate macros when the savings in repetitiveness clearly outweigh the negatives of implicit functionality.

===Abbreviate statements and prevent mistakes===
A lot of programming languages make you write really verbose statements to do really simple things. Code-generating programs allow you to abbreviate such statements and save a lot of typing, which also prevents a lot of mistakes because there is less chance of mistyping.

=Metaprogramming Framework in Java=
==Reflection==
===Introduction to reflection===
[http://en.wikipedia.org/wiki/Reflection_(computer_programming) Reflection] is the ability to introspect metalevel information about the program structure itself at runtime. Usually this metalevel information is modeled using the general abstraction mechanisms available in the language. In Java, reflection enables to discover information about the loaded classes:
* Fields,
* Methods, and
* Constructors
* Generics information
* Metadata annotations
It also enables to use these metaobjects to their instances in runtime environment.<ref name="meta_java">Abdelmonaim Remani, "The Art of Metaprogramming in Java", Jul 19, 2012 http://www.slideshare.net/PolymathicCoder/the-art-of-metaprogramming-in-java</ref>

The following is the Java metalevel architecture<ref name="reflection">Mika Haapakorpi, "Meta Programming In Java"</ref>

[[File:Metalevel architecture.PNG]]

===Dynamic proxy classes===
A dynamic proxy class implements a list of interfaces specified at runtime when the class is created.
* A proxy interface is an interface that is implemented by a proxy class.
* A proxy instance is an instance of a proxy class which has an associated invocation handler object.
The following is an example of dynamic proxy classes

[[File:Dynamic_proxy_class.PNG]]

==Generics==
[http://en.wikipedia.org/wiki/Generics_in_Java Generics] are a facility of generic programming that was added to the Java programming language in 2004 as part of J2SE 5.0. They allow "a type or method to operate on objects of various types while providing compile-time type safety." The generics can be used in classes, interfaces, methods and constructors.<ref name="reflection">Mika Haapakorpi, "Meta Programming In Java"</ref>
===Two new types in generics===
Two new types in generics:
* Parametrized types
* Type variables

A type variable is an unqualified identifier. Class and interface declarations can have type arguments (type variables). Method and constructors definitions can have type arguments (type variables).

The following is an example for type variables

List<String> anExample = new ArrayList<String>()

* List : interface
* ArrayList : class
* String : class (the actual type argument)
* List<String> and ArrayList<String> : parametrized type

===Class/Interface Declarations===
The following is an example of class declaration:

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

==Metadata annotation==
An annotation, in the Java computer programming language, is a form of syntactic metadata that can be added to Java source code. Classes, methods, variables, parameters and packages may be annotated.<ref name="reflection">Mika Haapakorpi, "Meta Programming In Java"</ref>

The following is an example of annotation:

/**
* Designates a formatter to pretty-print the annotated class.
*/
public @interface PrettyPrinter{
Class<? extends Formatter> value();
}
// Single-member annotation with Class
// member restricted by bounded wildcard
// The annotation presumes the existence of this class.
class GorgeousFormatterimplements Formatter { ... }
@PrettyPrinter(GorgeousFormatter.class)
public class Petunia { ... }

‘@’ indicates the start of an annotation definition.

=References=
<references/>

CSC/ECE 517 Spring 2013/ch1 1h jc

2013-02-26T04:18:30Z

Jrwills2: /* What is metaprogramming */

Metaprogramming in statically typed languages
=Metaprogramming in statically typed languages=
==Introduction==
===What is metaprogramming===

[http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming] refers to writing programs that can manipulate other programs or themselves. The program that is doing the manipulating is called the ''metaprogram'', and the program that is being manipulated is called the ''object program''. The language of the ''metaprogram'' is referred to as the ''metalanguage'' and the language of the object program is called the ''object language''. A language has the ability of [http://en.wikipedia.org/wiki/Reflection_(computer_programming) reflection] if it can be used to write a metaprogram that can manipulate a program written in the same language. <ref name="mp1">http://en.wikipedia.org/wiki/Metaprogramming</ref1>

===Metaprogramming in statically typed languages===

Metaprogramming can be accomplished in both statically and dynamically typed languages, however [http://en.wikipedia.org/wiki/Dynamically_typed_language#Dynamic_typing dynamically typed languages] have some advantages over [http://en.wikipedia.org/wiki/Dynamically_typed_language#Dynamic_typing statically typed languages] when it comes to metaprogramming.

One example of a metaprogramming task is to add a method to a particular class at runtime. Sample code in Ruby to perform this task is outlined below. First is a definition of a Ruby class called TestAddMethodAtRuntime:

class TestAddMethodAtRuntime
def originalMethod
puts "Original Method"
end
end

The code below created a new instance of the class. After that, it defines a new method called newlyAddedMethod. Then the original method is called, follow by the newly added method at runtime:

t = TestAddMethodAtRuntime.new
def t.newlyAddedMethod
puts "Newly Added Method"
end
t.originalMethod
puts "\n"
t.newlyAddedMethod

Below is the output of the code above:

Original Method
Newly Added Method

Accomplishing something like this in a statically typed language would be much more difficult or impossible depending on the language. It is for this reason that dynamically typed languages are usually viewed as being better equipped to handle metaprogramming overall.

==Implementation==
===Programming Language API===

One way that metaprogramming can be possible in a language is through an [http://en.wikipedia.org/wiki/API API] that helps programmers achieve a metaprogramming task. An example of this is a language that provides an API for reflection. One type of reflection is ''introspection'' in which the program can access the source code of the program itself.

Below is an example from the Java API to illustrate how an API can be used to achieve some metaprogramming tasks:

import java.lang.reflect.*;
public class DumpMethods {
public static void main(String[] args) {
try {
Class c = Class.forName(args[0]);
Method m[] = c.getDeclaredMethods();
for (int i = 0; i < m.length; i++) {
System.out.println(m[i].toString());
}
}
catch (Throwable e) {
System.err.println(e);
}
}

The above example prints out all of the methods that are declared for a particular class. This is an example of metaprogramming since the program is accessing the source code of itself.

===Program transformation system===

A program transformation system is something that takes a program as the input, and outputs a different program. One example of a program transformation system is the Java compiler. The Java compiler takes a Java program as its input, and outputs a .class file with platform independent bytecode in it. Another example of a program transformation system is a Java decompiler, which takes bytecode as an input and outputs a Java program.

In the case of the Java compiler, the program input is being output into another program in a different "language". There are other types of transformation systems that take a program as an input and output a different program in the same language. One example of this would be ''program migration'' which migrates source code to a newer or older version of the same language. This can be useful if upgrading a software system to run on a newer version of a framework. <ref name="pm1">http://www.program-transformation.org/Transform/ProgramMigration</ref>

==Common Uses==
===Pre-generate static data at compile time===
One common use of metaprogramming in statically typed languages is to write programs that will pre-generate tables of data for use at runtime.<ref name="use1">Jonathan Bartlett, "The art of metaprogramming, Part 1: Introduction to metaprogramming", 20 Oct 2005 http://www.ibm.com/developerworks/library/l-metaprog1/index.html#N10052</ref>

One simple but useful code generator is to build static lookup tables. Often, in order to build fast functions in C programming, we simply create a lookup table of all of the answers. This means that we either need to pre-compute them by hand (which is wasteful of your time) or build them at runtime (which is wasteful of the user's time).

In following example we will build a generator that will take a function or set of functions on an integer and build lookup tables for the answer.

To think of how to make such a program, we can start from the end and work backward. Firstly we need a lookup table that will return square roots of numbers between 5 and 20. A simple program can be written to generate such a table like this:

Generate and use a lookup table of square roots

/* our lookup table */
double square_roots[21];
/* function to load the table at runtime */
void init_square_roots()
{
int i;
for(i = 5; i < 21; i++)
{
square_roots[i] = sqrt((double)i);
}
}

With that single macro, we can take away a lot of work for any program that has to generate mathematical tables indexed by integer. A little extra work would also allow tables containing full struct definitions; a little more would ensure that space isn't wasted at the front of the array with useless empty entries.
/* program that uses the table */
int main ()
{
init_square_roots();
printf("The square root of 5 is %f\n", square_roots[5]);
return 0;
}

Now, to convert this to a statically initialized array, you would remove the first part of the program and replace it with something like this, calculated by hand:

Square root program with a static lookup table

double square_roots[] = {
/* these are the ones we skipped */ 0.0, 0.0, 0.0, 0.0, 0.0
2.236068, /* Square root of 5 */
2.449490, /* Square root of 6 */
2.645751, /* Square root of 7 */
2.828427, /* Square root of 8 */
3.0, /* Square root of 9 */
...
4.472136 /* Square root of 20 */
};

What is needed is a program that will produce these values and print them out in a table like the previous one so they are loaded in at compile-time.

Code generator for the table macro

#!/usr/bin/perl
#
#tablegen.pl
#
##Puts each program line into $line
while(my $line = <>)
{
#Is this a macro invocation?
if($line =~ m/TABLE:/)
{
#If so, split it apart into its component pieces
my ($dummy, $table_name, $type, $start_idx, $end_idx, $default, $procedure) = split(m/:/, $line, 7);
#The main difference between C and Perl for mathematical expressions is that
#Perl prefixes its variables with a dollar sign, so we will add that here
$procedure =~ s/VAL/\$VAL/g;
#Print out the array declaration
print "${type} ${table_name} [] = {\n";
#Go through each array element
foreach my $VAL (0 .. $end_idx)
{
#Only process an answer if we have reached our starting index
if($VAL >= $start_idx)
{
#evaluate the procedure specified (this sets $@ if there are any errors)
$result = eval $procedure;
die("Error processing: $@") if $@;
}
else
{
#if we haven't reached the starting index, just use the default
$result = $default;
}
#Print out the value
print "\t${result}";
#If there are more to be processed, add a comma after the value
if($VAL != $end_idx)
{
print ",";
}
print "\n"
}
#Finish the declaration
print "};\n";
}
else
{
#If this is not a macro invocation, just copy the line directly to the output
print $line;
}
}

To run this program, do this:

Running the code generator

./tablegen.pl < sqrt.in > sqrt.c
gcc sqrt.c -o sqrt
./a.out

===Mini-language for boiler-plate===
If you have a large application where many of the functions include a lot of boilerplate code, it is often a good idea to create a mini-language that allows you to work with your boilerplate code in an easier fashion.<ref name="boiler">K. Czarnecki, "Generative Programming" chapter 8, Static Metaprogramming in C++</ref> This mini-language will then be converted into your regular source code language before compiling.<ref name="use2">Jonathan Bartlett, "The art of metaprogramming, Part 2: Metaprogramming using Scheme", 02 May 2006 http://www.ibm.com/developerworks/linux/library/l-metaprog2/index.html</ref>

The following is an example:

Let's say that we are building a CGI application consisting of many independent CGI scripts. In most CGI applications, much of the state is stored in a database, but only a session ID is passed to each script via a cookie.

However, in nearly every page we need to know the other standard information (such as the username, group number, the current job being worked on, whatever else information is pertinent). In addition, we need to redirect the user if they do not have an appropriate cookie.

(define (handle-cgi-request req)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
;;Code for processing goes here
))))

While some of that can be handled by a procedure, the bindings certainly cannot. However, we can turn most of it into a macro. The macro can be implemented like this:

(define-syntax cgi-boilerplate
(lambda (x)
(syntax-case x ()
(
(cgi-boilerplate expr)
(datum->syntax-object
(syntax k)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
(syntax-object->datum (syntax expr))))))
)
)))

We can now create new forms based on our boilerplate code by doing the following:

(define (handle-cgi-request req)
(cgi-boilerplate
(begin
;;Do whatever I want here
)))

In addition, since we are not defining our variables explicitly, adding new variable definitions to our boilerplate won't affect its calling conventions, so new features can be added without having to create a whole new function.

In any large project, there are inevitably templates to follow which cannot be reduced to functions, usually because of the bindings being created. Using boilerplate macros can make maintenance of such templated code much easier.

Likewise, other standard macros can be created which make use of variables defined in the boilerplate. Using macros like this significantly reduces typing because you do not have to constantly be writing and rewriting variable bindings, derivations, and parameter passing. This also reduces the potential for errors in such code.

Realize though that boilerplate macros are not a panacea. There are many significant problems that can occur, including:
* Accidentally overwriting bindings by introducing a variable name that was previously defined in a macro.
* Difficulty tracing problems because the inputs and the outputs of the macros are implicit, not explicit.

These can be largely avoided by doing a few things in conjunction with your boilerplate macros:
* Have a naming convention which clearly labels macros as such, as well as indicate that a variable came from boilerplate code. This could be done by affixing -m to macros and -b to variables defined within a boilerplate.
* Carefully document all boilerplate macros, especially the introduced variable bindings and all changes between versions.
* Only use boilerplate macros when the savings in repetitiveness clearly outweigh the negatives of implicit functionality.

===Abbreviate statements and prevent mistakes===
A lot of programming languages make you write really verbose statements to do really simple things. Code-generating programs allow you to abbreviate such statements and save a lot of typing, which also prevents a lot of mistakes because there is less chance of mistyping.

=Metaprogramming Framework in Java=
==Reflection==
===Introduction to reflection===
[http://en.wikipedia.org/wiki/Reflection_(computer_programming) Reflection] is the ability to introspect metalevel information about the program structure itself at runtime. Usually this metalevel information is modeled using the general abstraction mechanisms available in the language. In Java, reflection enables to discover information about the loaded classes:
* Fields,
* Methods, and
* Constructors
* Generics information
* Metadata annotations
It also enables to use these metaobjects to their instances in runtime environment.<ref name="meta_java">Abdelmonaim Remani, "The Art of Metaprogramming in Java", Jul 19, 2012 http://www.slideshare.net/PolymathicCoder/the-art-of-metaprogramming-in-java</ref>

The following is the Java metalevel architecture<ref name="reflection">Mika Haapakorpi, "Meta Programming In Java"</ref>

[[File:Metalevel architecture.PNG]]

===Dynamic proxy classes===
A dynamic proxy class implements a list of interfaces specified at runtime when the class is created.
* A proxy interface is an interface that is implemented by a proxy class.
* A proxy instance is an instance of a proxy class which has an associated invocation handler object.
The following is an example of dynamic proxy classes

[[File:Dynamic_proxy_class.PNG]]

==Generics==
[http://en.wikipedia.org/wiki/Generics_in_Java Generics] are a facility of generic programming that was added to the Java programming language in 2004 as part of J2SE 5.0. They allow "a type or method to operate on objects of various types while providing compile-time type safety." The generics can be used in classes, interfaces, methods and constructors.<ref name="reflection">Mika Haapakorpi, "Meta Programming In Java"</ref>
===Two new types in generics===
Two new types in generics:
* Parametrized types
* Type variables

A type variable is an unqualified identifier. Class and interface declarations can have type arguments (type variables). Method and constructors definitions can have type arguments (type variables).

The following is an example for type variables

List<String> anExample = new ArrayList<String>()

* List : interface
* ArrayList : class
* String : class (the actual type argument)
* List<String> and ArrayList<String> : parametrized type

===Class/Interface Declarations===
The following is an example of class declaration:

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

==Metadata annotation==
An annotation, in the Java computer programming language, is a form of syntactic metadata that can be added to Java source code. Classes, methods, variables, parameters and packages may be annotated.<ref name="reflection">Mika Haapakorpi, "Meta Programming In Java"</ref>

The following is an example of annotation:

/**
* Designates a formatter to pretty-print the annotated class.
*/
public @interface PrettyPrinter{
Class<? extends Formatter> value();
}
// Single-member annotation with Class
// member restricted by bounded wildcard
// The annotation presumes the existence of this class.
class GorgeousFormatterimplements Formatter { ... }
@PrettyPrinter(GorgeousFormatter.class)
public class Petunia { ... }

‘@’ indicates the start of an annotation definition.

=References=
<references/>

CSC/ECE 517 Spring 2013/ch1 1h jc

2013-02-26T03:46:53Z

Jrwills2: /* Programming Language API */

Metaprogramming in statically typed languages
=Metaprogramming in statically typed languages=
==Introduction==
===What is metaprogramming===

[http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming] refers to writing programs that can manipulate other programs or themselves. The program that is doing the manipulating is called the ''metaprogram'', and the program that is being manipulated is called the ''object program''. The language of the ''metaprogram'' is referred to as the ''metalanguage'' and the language of the object program is called the ''object language''. A language has the ability of [http://en.wikipedia.org/wiki/Reflection_(computer_programming) reflection] if it can be used to write a metaprogram that can manipulate a program written in the same language.

===Metaprogramming in statically typed languages===

Metaprogramming can be accomplished in both statically and dynamically typed languages, however [http://en.wikipedia.org/wiki/Dynamically_typed_language#Dynamic_typing dynamically typed languages] have some advantages over [http://en.wikipedia.org/wiki/Dynamically_typed_language#Dynamic_typing statically typed languages] when it comes to metaprogramming.

One example of a metaprogramming task is to add a method to a particular class at runtime. Sample code in Ruby to perform this task is outlined below. First is a definition of a Ruby class called TestAddMethodAtRuntime:

class TestAddMethodAtRuntime
def originalMethod
puts "Original Method"
end
end

The code below created a new instance of the class. After that, it defines a new method called newlyAddedMethod. Then the original method is called, follow by the newly added method at runtime:

t = TestAddMethodAtRuntime.new
def t.newlyAddedMethod
puts "Newly Added Method"
end
t.originalMethod
puts "\n"
t.newlyAddedMethod

Below is the output of the code above:

Original Method
Newly Added Method

Accomplishing something like this in a statically typed language would be much more difficult or impossible depending on the language. It is for this reason that dynamically typed languages are usually viewed as being better equipped to handle metaprogramming overall.

==Implementation==
===Programming Language API===

One way that metaprogramming can be possible in a language is through an [http://en.wikipedia.org/wiki/API API] that helps programmers achieve a metaprogramming task. An example of this is a language that provides an API for reflection. One type of reflection is ''introspection'' in which the program can access the source code of the program itself.

Below is an example from the Java API to illustrate how an API can be used to achieve some metaprogramming tasks:

import java.lang.reflect.*;
public class DumpMethods {
public static void main(String[] args) {
try {
Class c = Class.forName(args[0]);
Method m[] = c.getDeclaredMethods();
for (int i = 0; i < m.length; i++) {
System.out.println(m[i].toString());
}
}
catch (Throwable e) {
System.err.println(e);
}
}

The above example prints out all of the methods that are declared for a particular class. This is an example of metaprogramming since the program is accessing the source code of itself.

===Program transformation system===

A program transformation system is something that takes a program as the input, and outputs a different program. One example of a program transformation system is the Java compiler. The Java compiler takes a Java program as its input, and outputs a .class file with platform independent bytecode in it. Another example of a program transformation system is a Java decompiler, which takes bytecode as an input and outputs a Java program.

In the case of the Java compiler, the program input is being output into another program in a different "language". There are other types of transformation systems that take a program as an input and output a different program in the same language. One example of this would be ''program migration'' which migrates source code to a newer or older version of the same language. This can be useful if upgrading a software system to run on a newer version of a framework. <ref name="pm1">http://www.program-transformation.org/Transform/ProgramMigration</ref>

==Common Uses==
===Pre-generate static data at compile time===
One common use of metaprogramming in statically typed languages is to write programs that will pre-generate tables of data for use at runtime.<ref name="use1">Jonathan Bartlett, "The art of metaprogramming, Part 1: Introduction to metaprogramming", 20 Oct 2005 http://www.ibm.com/developerworks/library/l-metaprog1/index.html#N10052</ref>

One simple but useful code generator is to build static lookup tables. Often, in order to build fast functions in C programming, we simply create a lookup table of all of the answers. This means that we either need to pre-compute them by hand (which is wasteful of your time) or build them at runtime (which is wasteful of the user's time).

In following example we will build a generator that will take a function or set of functions on an integer and build lookup tables for the answer.

To think of how to make such a program, we can start from the end and work backward. Firstly we need a lookup table that will return square roots of numbers between 5 and 20. A simple program can be written to generate such a table like this:

Generate and use a lookup table of square roots

/* our lookup table */
double square_roots[21];
/* function to load the table at runtime */
void init_square_roots()
{
int i;
for(i = 5; i < 21; i++)
{
square_roots[i] = sqrt((double)i);
}
}

With that single macro, we can take away a lot of work for any program that has to generate mathematical tables indexed by integer. A little extra work would also allow tables containing full struct definitions; a little more would ensure that space isn't wasted at the front of the array with useless empty entries.
/* program that uses the table */
int main ()
{
init_square_roots();
printf("The square root of 5 is %f\n", square_roots[5]);
return 0;
}

Now, to convert this to a statically initialized array, you would remove the first part of the program and replace it with something like this, calculated by hand:

Square root program with a static lookup table

double square_roots[] = {
/* these are the ones we skipped */ 0.0, 0.0, 0.0, 0.0, 0.0
2.236068, /* Square root of 5 */
2.449490, /* Square root of 6 */
2.645751, /* Square root of 7 */
2.828427, /* Square root of 8 */
3.0, /* Square root of 9 */
...
4.472136 /* Square root of 20 */
};

What is needed is a program that will produce these values and print them out in a table like the previous one so they are loaded in at compile-time.

Code generator for the table macro

#!/usr/bin/perl
#
#tablegen.pl
#
##Puts each program line into $line
while(my $line = <>)
{
#Is this a macro invocation?
if($line =~ m/TABLE:/)
{
#If so, split it apart into its component pieces
my ($dummy, $table_name, $type, $start_idx, $end_idx, $default, $procedure) = split(m/:/, $line, 7);
#The main difference between C and Perl for mathematical expressions is that
#Perl prefixes its variables with a dollar sign, so we will add that here
$procedure =~ s/VAL/\$VAL/g;
#Print out the array declaration
print "${type} ${table_name} [] = {\n";
#Go through each array element
foreach my $VAL (0 .. $end_idx)
{
#Only process an answer if we have reached our starting index
if($VAL >= $start_idx)
{
#evaluate the procedure specified (this sets $@ if there are any errors)
$result = eval $procedure;
die("Error processing: $@") if $@;
}
else
{
#if we haven't reached the starting index, just use the default
$result = $default;
}
#Print out the value
print "\t${result}";
#If there are more to be processed, add a comma after the value
if($VAL != $end_idx)
{
print ",";
}
print "\n"
}
#Finish the declaration
print "};\n";
}
else
{
#If this is not a macro invocation, just copy the line directly to the output
print $line;
}
}

To run this program, do this:

Running the code generator

./tablegen.pl < sqrt.in > sqrt.c
gcc sqrt.c -o sqrt
./a.out

===Mini-language for boiler-plate===
If you have a large application where many of the functions include a lot of boilerplate code, it is often a good idea to create a mini-language that allows you to work with your boilerplate code in an easier fashion.<ref name="boiler">K. Czarnecki, "Generative Programming" chapter 8, Static Metaprogramming in C++</ref> This mini-language will then be converted into your regular source code language before compiling.<ref name="use2">Jonathan Bartlett, "The art of metaprogramming, Part 2: Metaprogramming using Scheme", 02 May 2006 http://www.ibm.com/developerworks/linux/library/l-metaprog2/index.html</ref>

The following is an example:

Let's say that we are building a CGI application consisting of many independent CGI scripts. In most CGI applications, much of the state is stored in a database, but only a session ID is passed to each script via a cookie.

However, in nearly every page we need to know the other standard information (such as the username, group number, the current job being worked on, whatever else information is pertinent). In addition, we need to redirect the user if they do not have an appropriate cookie.

(define (handle-cgi-request req)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
;;Code for processing goes here
))))

While some of that can be handled by a procedure, the bindings certainly cannot. However, we can turn most of it into a macro. The macro can be implemented like this:

(define-syntax cgi-boilerplate
(lambda (x)
(syntax-case x ()
(
(cgi-boilerplate expr)
(datum->syntax-object
(syntax k)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
(syntax-object->datum (syntax expr))))))
)
)))

We can now create new forms based on our boilerplate code by doing the following:

(define (handle-cgi-request req)
(cgi-boilerplate
(begin
;;Do whatever I want here
)))

In addition, since we are not defining our variables explicitly, adding new variable definitions to our boilerplate won't affect its calling conventions, so new features can be added without having to create a whole new function.

In any large project, there are inevitably templates to follow which cannot be reduced to functions, usually because of the bindings being created. Using boilerplate macros can make maintenance of such templated code much easier.

Likewise, other standard macros can be created which make use of variables defined in the boilerplate. Using macros like this significantly reduces typing because you do not have to constantly be writing and rewriting variable bindings, derivations, and parameter passing. This also reduces the potential for errors in such code.

Realize though that boilerplate macros are not a panacea. There are many significant problems that can occur, including:
* Accidentally overwriting bindings by introducing a variable name that was previously defined in a macro.
* Difficulty tracing problems because the inputs and the outputs of the macros are implicit, not explicit.

These can be largely avoided by doing a few things in conjunction with your boilerplate macros:
* Have a naming convention which clearly labels macros as such, as well as indicate that a variable came from boilerplate code. This could be done by affixing -m to macros and -b to variables defined within a boilerplate.
* Carefully document all boilerplate macros, especially the introduced variable bindings and all changes between versions.
* Only use boilerplate macros when the savings in repetitiveness clearly outweigh the negatives of implicit functionality.

===Abbreviate statements and prevent mistakes===
A lot of programming languages make you write really verbose statements to do really simple things. Code-generating programs allow you to abbreviate such statements and save a lot of typing, which also prevents a lot of mistakes because there is less chance of mistyping.

=Metaprogramming Framework in Java=
==Reflection==
===Introduction to reflection===
[http://en.wikipedia.org/wiki/Reflection_(computer_programming) Reflection] is the ability to introspect metalevel information about the program structure itself at runtime. Usually this metalevel information is modeled using the general abstraction mechanisms available in the language. In Java, reflection enables to discover information about the loaded classes:
* Fields,
* Methods, and
* Constructors
* Generics information
* Metadata annotations
It also enables to use these metaobjects to their instances in runtime environment.<ref name="meta_java">Abdelmonaim Remani, "The Art of Metaprogramming in Java", Jul 19, 2012 http://www.slideshare.net/PolymathicCoder/the-art-of-metaprogramming-in-java</ref>

The following is the Java metalevel architecture<ref name="reflection">Mika Haapakorpi, "Meta Programming In Java"</ref>

[[File:Metalevel architecture.PNG]]

===Dynamic proxy classes===
A dynamic proxy class implements a list of interfaces specified at runtime when the class is created.
* A proxy interface is an interface that is implemented by a proxy class.
* A proxy instance is an instance of a proxy class which has an associated invocation handler object.
The following is an example of dynamic proxy classes

[[File:Dynamic_proxy_class.PNG]]

==Generics==
[http://en.wikipedia.org/wiki/Generics_in_Java Generics] are a facility of generic programming that was added to the Java programming language in 2004 as part of J2SE 5.0. They allow "a type or method to operate on objects of various types while providing compile-time type safety." The generics can be used in classes, interfaces, methods and constructors.<ref name="reflection">Mika Haapakorpi, "Meta Programming In Java"</ref>
===Two new types in generics===
Two new types in generics:
* Parametrized types
* Type variables

A type variable is an unqualified identifier. Class and interface declarations can have type arguments (type variables). Method and constructors definitions can have type arguments (type variables).

The following is an example for type variables

List<String> anExample = new ArrayList<String>()

* List : interface
* ArrayList : class
* String : class (the actual type argument)
* List<String> and ArrayList<String> : parametrized type

===Class/Interface Declarations===
The following is an example of class declaration:

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

==Metadata annotation==
An annotation, in the Java computer programming language, is a form of syntactic metadata that can be added to Java source code. Classes, methods, variables, parameters and packages may be annotated.<ref name="reflection">Mika Haapakorpi, "Meta Programming In Java"</ref>

The following is an example of annotation:

/**
* Designates a formatter to pretty-print the annotated class.
*/
public @interface PrettyPrinter{
Class<? extends Formatter> value();
}
// Single-member annotation with Class
// member restricted by bounded wildcard
// The annotation presumes the existence of this class.
class GorgeousFormatterimplements Formatter { ... }
@PrettyPrinter(GorgeousFormatter.class)
public class Petunia { ... }

‘@’ indicates the start of an annotation definition.

=References=
<references/>

CSC/ECE 517 Spring 2013/ch1 1h jc

2013-02-26T03:28:13Z

Jrwills2: /* Program transformation system */

Metaprogramming in statically typed languages
=Metaprogramming in statically typed languages=
==Introduction==
===What is metaprogramming===

[http://en.wikipedia.org/wiki/Metaprogramming Metaprogramming] refers to writing programs that can manipulate other programs or themselves. The program that is doing the manipulating is called the ''metaprogram'', and the program that is being manipulated is called the ''object program''. The language of the ''metaprogram'' is referred to as the ''metalanguage'' and the language of the object program is called the ''object language''. A language has the ability of [http://en.wikipedia.org/wiki/Reflection_(computer_programming) reflection] if it can be used to write a metaprogram that can manipulate a program written in the same language.

===Metaprogramming in statically typed languages===

Metaprogramming can be accomplished in both statically and dynamically typed languages, however [http://en.wikipedia.org/wiki/Dynamically_typed_language#Dynamic_typing dynamically typed languages] have some advantages over [http://en.wikipedia.org/wiki/Dynamically_typed_language#Dynamic_typing statically typed languages] when it comes to metaprogramming.

One example of a metaprogramming task is to add a method to a particular class at runtime. Sample code in Ruby to perform this task is outlined below. First is a definition of a Ruby class called TestAddMethodAtRuntime:

class TestAddMethodAtRuntime
def originalMethod
puts "Original Method"
end
end

The code below created a new instance of the class. After that, it defines a new method called newlyAddedMethod. Then the original method is called, follow by the newly added method at runtime:

t = TestAddMethodAtRuntime.new
def t.newlyAddedMethod
puts "Newly Added Method"
end
t.originalMethod
puts "\n"
t.newlyAddedMethod

Below is the output of the code above:

Original Method
Newly Added Method

Accomplishing something like this in a statically typed language would be much more difficult or impossible depending on the language. It is for this reason that dynamically typed languages are usually viewed as being better equipped to handle metaprogramming overall.

==Implementation==
===Programming Language API===

One way that metaprogramming can be possible in a language is through an [http://en.wikipedia.org/wiki/API API] that helps programmers achieve a metaprogramming task. An example of this is a language that provides an API for reflection. One type of reflection is ''introspection'' in which the program can access the source code of the program itself.

Below is an example from the Java API to illustrate how an API can be used to achieve some metaprogramming tasks:

import java.lang.reflect.*;
public class DumpMethods {
public static void main(String args[]) {
try {
Class c = Class.forName(args[0]);
Method m[] = c.getDeclaredMethods();
for (int i = 0; i < m.length; i++) {
System.out.println(m[i].toString());
}
}
catch (Throwable e) {
System.err.println(e);
}
}

The above example prints out all of the methods that are declared for a particular class. This is an example of metaprogramming since the program is accessing the source code of itself.

===Program transformation system===

A program transformation system is something that takes a program as the input, and outputs a different program. One example of a program transformation system is the Java compiler. The Java compiler takes a Java program as its input, and outputs a .class file with platform independent bytecode in it. Another example of a program transformation system is a Java decompiler, which takes bytecode as an input and outputs a Java program.

In the case of the Java compiler, the program input is being output into another program in a different "language". There are other types of transformation systems that take a program as an input and output a different program in the same language. One example of this would be ''program migration'' which migrates source code to a newer or older version of the same language. This can be useful if upgrading a software system to run on a newer version of a framework. <ref name="pm1">http://www.program-transformation.org/Transform/ProgramMigration</ref>

==Common Uses==
===Pre-generate static data at compile time===
One common use of metaprogramming in statically typed languages is to write programs that will pre-generate tables of data for use at runtime.<ref name="use1">Jonathan Bartlett, "The art of metaprogramming, Part 1: Introduction to metaprogramming", 20 Oct 2005 http://www.ibm.com/developerworks/library/l-metaprog1/index.html#N10052</ref>

One simple but useful code generator is to build static lookup tables. Often, in order to build fast functions in C programming, we simply create a lookup table of all of the answers. This means that we either need to pre-compute them by hand (which is wasteful of your time) or build them at runtime (which is wasteful of the user's time).

In following example we will build a generator that will take a function or set of functions on an integer and build lookup tables for the answer.

To think of how to make such a program, we can start from the end and work backward. Firstly we need a lookup table that will return square roots of numbers between 5 and 20. A simple program can be written to generate such a table like this:

Generate and use a lookup table of square roots

/* our lookup table */
double square_roots[21];
/* function to load the table at runtime */
void init_square_roots()
{
int i;
for(i = 5; i < 21; i++)
{
square_roots[i] = sqrt((double)i);
}
}

With that single macro, we can take away a lot of work for any program that has to generate mathematical tables indexed by integer. A little extra work would also allow tables containing full struct definitions; a little more would ensure that space isn't wasted at the front of the array with useless empty entries.
/* program that uses the table */
int main ()
{
init_square_roots();
printf("The square root of 5 is %f\n", square_roots[5]);
return 0;
}

Now, to convert this to a statically initialized array, you would remove the first part of the program and replace it with something like this, calculated by hand:

Square root program with a static lookup table

double square_roots[] = {
/* these are the ones we skipped */ 0.0, 0.0, 0.0, 0.0, 0.0
2.236068, /* Square root of 5 */
2.449490, /* Square root of 6 */
2.645751, /* Square root of 7 */
2.828427, /* Square root of 8 */
3.0, /* Square root of 9 */
...
4.472136 /* Square root of 20 */
};

What is needed is a program that will produce these values and print them out in a table like the previous one so they are loaded in at compile-time.

Code generator for the table macro

#!/usr/bin/perl
#
#tablegen.pl
#
##Puts each program line into $line
while(my $line = <>)
{
#Is this a macro invocation?
if($line =~ m/TABLE:/)
{
#If so, split it apart into its component pieces
my ($dummy, $table_name, $type, $start_idx, $end_idx, $default, $procedure) = split(m/:/, $line, 7);
#The main difference between C and Perl for mathematical expressions is that
#Perl prefixes its variables with a dollar sign, so we will add that here
$procedure =~ s/VAL/\$VAL/g;
#Print out the array declaration
print "${type} ${table_name} [] = {\n";
#Go through each array element
foreach my $VAL (0 .. $end_idx)
{
#Only process an answer if we have reached our starting index
if($VAL >= $start_idx)
{
#evaluate the procedure specified (this sets $@ if there are any errors)
$result = eval $procedure;
die("Error processing: $@") if $@;
}
else
{
#if we haven't reached the starting index, just use the default
$result = $default;
}
#Print out the value
print "\t${result}";
#If there are more to be processed, add a comma after the value
if($VAL != $end_idx)
{
print ",";
}
print "\n"
}
#Finish the declaration
print "};\n";
}
else
{
#If this is not a macro invocation, just copy the line directly to the output
print $line;
}
}

To run this program, do this:

Running the code generator

./tablegen.pl < sqrt.in > sqrt.c
gcc sqrt.c -o sqrt
./a.out

===Mini-language for boiler-plate===
If you have a large application where many of the functions include a lot of boilerplate code, it is often a good idea to create a mini-language that allows you to work with your boilerplate code in an easier fashion.<ref name="boiler">K. Czarnecki, "Generative Programming" chapter 8, Static Metaprogramming in C++</ref> This mini-language will then be converted into your regular source code language before compiling.<ref name="use2">Jonathan Bartlett, "The art of metaprogramming, Part 2: Metaprogramming using Scheme", 02 May 2006 http://www.ibm.com/developerworks/linux/library/l-metaprog2/index.html</ref>

The following is an example:

Let's say that we are building a CGI application consisting of many independent CGI scripts. In most CGI applications, much of the state is stored in a database, but only a session ID is passed to each script via a cookie.

However, in nearly every page we need to know the other standard information (such as the username, group number, the current job being worked on, whatever else information is pertinent). In addition, we need to redirect the user if they do not have an appropriate cookie.

(define (handle-cgi-request req)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
;;Code for processing goes here
))))

While some of that can be handled by a procedure, the bindings certainly cannot. However, we can turn most of it into a macro. The macro can be implemented like this:

(define-syntax cgi-boilerplate
(lambda (x)
(syntax-case x ()
(
(cgi-boilerplate expr)
(datum->syntax-object
(syntax k)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
(syntax-object->datum (syntax expr))))))
)
)))

We can now create new forms based on our boilerplate code by doing the following:

(define (handle-cgi-request req)
(cgi-boilerplate
(begin
;;Do whatever I want here
)))

In addition, since we are not defining our variables explicitly, adding new variable definitions to our boilerplate won't affect its calling conventions, so new features can be added without having to create a whole new function.

In any large project, there are inevitably templates to follow which cannot be reduced to functions, usually because of the bindings being created. Using boilerplate macros can make maintenance of such templated code much easier.

Likewise, other standard macros can be created which make use of variables defined in the boilerplate. Using macros like this significantly reduces typing because you do not have to constantly be writing and rewriting variable bindings, derivations, and parameter passing. This also reduces the potential for errors in such code.

Realize though that boilerplate macros are not a panacea. There are many significant problems that can occur, including:
* Accidentally overwriting bindings by introducing a variable name that was previously defined in a macro.
* Difficulty tracing problems because the inputs and the outputs of the macros are implicit, not explicit.

These can be largely avoided by doing a few things in conjunction with your boilerplate macros:
* Have a naming convention which clearly labels macros as such, as well as indicate that a variable came from boilerplate code. This could be done by affixing -m to macros and -b to variables defined within a boilerplate.
* Carefully document all boilerplate macros, especially the introduced variable bindings and all changes between versions.
* Only use boilerplate macros when the savings in repetitiveness clearly outweigh the negatives of implicit functionality.

===Abbreviate statements and prevent mistakes===
A lot of programming languages make you write really verbose statements to do really simple things. Code-generating programs allow you to abbreviate such statements and save a lot of typing, which also prevents a lot of mistakes because there is less chance of mistyping.

=Metaprogramming Framework in Java=
==Reflection==
===Introduction to reflection===
[http://en.wikipedia.org/wiki/Reflection_(computer_programming) Reflection] is the ability to introspect metalevel information about the program structure itself at runtime. Usually this metalevel information is modeled using the general abstraction mechanisms available in the language. In Java, reflection enables to discover information about the loaded classes:
* Fields,
* Methods, and
* Constructors
* Generics information
* Metadata annotations
It also enables to use these metaobjects to their instances in runtime environment.<ref name="meta_java">Abdelmonaim Remani, "The Art of Metaprogramming in Java", Jul 19, 2012 http://www.slideshare.net/PolymathicCoder/the-art-of-metaprogramming-in-java</ref>

The following is the Java metalevel architecture<ref name="reflection">Mika Haapakorpi, "Meta Programming In Java"</ref>

[[File:Metalevel architecture.PNG]]

===Dynamic proxy classes===
A dynamic proxy class implements a list of interfaces specified at runtime when the class is created.
* A proxy interface is an interface that is implemented by a proxy class.
* A proxy instance is an instance of a proxy class which has an associated invocation handler object.
The following is an example of dynamic proxy classes

[[File:Dynamic_proxy_class.PNG]]

==Generics==
[http://en.wikipedia.org/wiki/Generics_in_Java Generics] are a facility of generic programming that was added to the Java programming language in 2004 as part of J2SE 5.0. They allow "a type or method to operate on objects of various types while providing compile-time type safety." The generics can be used in classes, interfaces, methods and constructors.<ref name="reflection">Mika Haapakorpi, "Meta Programming In Java"</ref>
===Two new types in generics===
Two new types in generics:
* Parametrized types
* Type variables

A type variable is an unqualified identifier. Class and interface declarations can have type arguments (type variables). Method and constructors definitions can have type arguments (type variables).

The following is an example for type variables

List<String> anExample = new ArrayList<String>()

* List : interface
* ArrayList : class
* String : class (the actual type argument)
* List<String> and ArrayList<String> : parametrized type

===Class/Interface Declarations===
The following is an example of class declaration:

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

==Metadata annotation==
An annotation, in the Java computer programming language, is a form of syntactic metadata that can be added to Java source code. Classes, methods, variables, parameters and packages may be annotated.<ref name="reflection">Mika Haapakorpi, "Meta Programming In Java"</ref>

The following is an example of annotation:

/**
* Designates a formatter to pretty-print the annotated class.
*/
public @interface PrettyPrinter{
Class<? extends Formatter> value();
}
// Single-member annotation with Class
// member restricted by bounded wildcard
// The annotation presumes the existence of this class.
class GorgeousFormatterimplements Formatter { ... }
@PrettyPrinter(GorgeousFormatter.class)
public class Petunia { ... }

‘@’ indicates the start of an annotation definition.

=References=
<references/>

CSC/ECE 517 Spring 2013/ch1 1h jc

2013-02-20T00:02:55Z

Jrwills2: /* Metaprogramming in statically typed languages */

Metaprogramming in statically typed languages
=Metaprogramming in statically typed languages=
==Introduction==
===What is metaprogramming===

Metaprogramming refers to writing programs that can manipulate other programs or themselves. The program that is doing the manipulating is called the ''metaprogram'', and the program that is being manipulated is called the ''object program''. The language of the ''metaprogram'' is referred to as the ''metalanguage'' and the language of the object program is called the ''object language''. A language has the ability of ''reflection'' if it can be used to write a metaprogram that can manipulate a program written in the same language.

===Metaprogramming in statically typed languages===

Metaprogramming can be accomplished in both statically and dynamically typed languages, however dynamically typed languages have some advantages over statically typed languages when it comes to metaprogramming.

One example of a metaprogramming task is to add a method to a particular class at runtime. Sample code in Ruby to perform this task is outlined below. First is a definition of a Ruby class called TestAddMethodAtRuntime:

class TestAddMethodAtRuntime
def originalMethod
puts "Original Method"
end
end

The code below created a new instance of the class. After that, it defines a new method called newlyAddedMethod. Then the original method is called, follow by the newly added method at runtime:

t = TestAddMethodAtRuntime.new
def t.newlyAddedMethod
puts "Newly Added Method"
end
t.originalMethod
puts "\n"
t.newlyAddedMethod

Below is the output of the code above:

Original Method
Newly Added Method

Accomplishing something like this in a statically typed language would be much more difficult or impossible depending on the language. It is for this reason that dynamically typed languages are usually viewed as being better equipped to handle metaprogramming overall.

==Implementation==
===Programming Language API===

One way that metaprogramming can be possible in a language is through an API that helps programmers achieve a metaprogramming task. An example of this is a language that provides an API for reflection. One type of reflection is ''introspection'' in which the program can access the source code of the program itself.

Below is an example from the Java API to illustrate how an API can be used to achieve some metaprogramming tasks:

import java.lang.reflect.*;
public class DumpMethods {
public static void main(String args[]) {
try {
Class c = Class.forName(args[0]);
Method m[] = c.getDeclaredMethods();
for (int i = 0; i < m.length; i++) {
System.out.println(m[i].toString());
}
}
catch (Throwable e) {
System.err.println(e);
}
}

The above example prints out all of the methods that are declared for a particular class. This is an example of metaprogramming since the program is accessing the source code of itself.

===Program transformation system===

A program transformation system is something that takes a program as the input, and outputs a different program. One example of a program transformation system is the Java compiler. The Java compiler takes a Java program as its input, and outputs a .class file with platform independent bytecode in it. Another example of a program transformation system is a Java decompiler, which takes bytecode as an input and outputs a Java program.

In the case of the Java compiler, the program input is being output into another program in a different "language". There are other types of transformation systems that take a program as an input and output a different program in the same language. One example of this would be ''program migration'' which migrates source code to a newer or older version of the same language. This can be useful if upgrading a software system to run on a newer version of a framework.

==Common Uses==
===Pre-generate static data at compile time===
One common use of metaprogramming in statically typed languages is to write programs that will pre-generate tables of data for use at runtime.

One simple but useful code generator is to build static lookup tables. Often, in order to build fast functions in C programming, we simply create a lookup table of all of the answers. This means that we either need to pre-compute them by hand (which is wasteful of your time) or build them at runtime (which is wasteful of the user's time).

In following example we will build a generator that will take a function or set of functions on an integer and build lookup tables for the answer.

To think of how to make such a program, we can start from the end and work backward. Firstly we need a lookup table that will return square roots of numbers between 5 and 20. A simple program can be written to generate such a table like this:

Generate and use a lookup table of square roots

/* our lookup table */
double square_roots[21];
/* function to load the table at runtime */
void init_square_roots()
{
int i;
for(i = 5; i < 21; i++)
{
square_roots[i] = sqrt((double)i);
}
}

With that single macro, we can take away a lot of work for any program that has to generate mathematical tables indexed by integer. A little extra work would also allow tables containing full struct definitions; a little more would ensure that space isn't wasted at the front of the array with useless empty entries.
/* program that uses the table */
int main ()
{
init_square_roots();
printf("The square root of 5 is %f\n", square_roots[5]);
return 0;
}

Now, to convert this to a statically initialized array, you would remove the first part of the program and replace it with something like this, calculated by hand:

Square root program with a static lookup table

double square_roots[] = {
/* these are the ones we skipped */ 0.0, 0.0, 0.0, 0.0, 0.0
2.236068, /* Square root of 5 */
2.449490, /* Square root of 6 */
2.645751, /* Square root of 7 */
2.828427, /* Square root of 8 */
3.0, /* Square root of 9 */
...
4.472136 /* Square root of 20 */
};

What is needed is a program that will produce these values and print them out in a table like the previous one so they are loaded in at compile-time.

Code generator for the table macro

#!/usr/bin/perl
#
#tablegen.pl
#
##Puts each program line into $line
while(my $line = <>)
{
#Is this a macro invocation?
if($line =~ m/TABLE:/)
{
#If so, split it apart into its component pieces
my ($dummy, $table_name, $type, $start_idx, $end_idx, $default, $procedure) = split(m/:/, $line, 7);
#The main difference between C and Perl for mathematical expressions is that
#Perl prefixes its variables with a dollar sign, so we will add that here
$procedure =~ s/VAL/\$VAL/g;
#Print out the array declaration
print "${type} ${table_name} [] = {\n";
#Go through each array element
foreach my $VAL (0 .. $end_idx)
{
#Only process an answer if we have reached our starting index
if($VAL >= $start_idx)
{
#evaluate the procedure specified (this sets $@ if there are any errors)
$result = eval $procedure;
die("Error processing: $@") if $@;
}
else
{
#if we haven't reached the starting index, just use the default
$result = $default;
}
#Print out the value
print "\t${result}";
#If there are more to be processed, add a comma after the value
if($VAL != $end_idx)
{
print ",";
}
print "\n"
}
#Finish the declaration
print "};\n";
}
else
{
#If this is not a macro invocation, just copy the line directly to the output
print $line;
}
}

To run this program, do this:

Running the code generator

./tablegen.pl < sqrt.in > sqrt.c
gcc sqrt.c -o sqrt
./a.out

===Mini-language for boiler-plate===
If you have a large application where many of the functions include a lot of boilerplate code, it is often a good idea to create a mini-language that allows you to work with your boilerplate code in an easier fashion. This mini-language will then be converted into your regular source code language before compiling.

The following is an example:

Let's say that we are building a CGI application consisting of many independent CGI scripts. In most CGI applications, much of the state is stored in a database, but only a session ID is passed to each script via a cookie.

However, in nearly every page we need to know the other standard information (such as the username, group number, the current job being worked on, whatever else information is pertinent). In addition, we need to redirect the user if they do not have an appropriate cookie.

(define (handle-cgi-request req)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
;;Code for processing goes here
))))

While some of that can be handled by a procedure, the bindings certainly cannot. However, we can turn most of it into a macro. The macro can be implemented like this:

(define-syntax cgi-boilerplate
(lambda (x)
(syntax-case x ()
(
(cgi-boilerplate expr)
(datum->syntax-object
(syntax k)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
(syntax-object->datum (syntax expr))))))
)
)))

We can now create new forms based on our boilerplate code by doing the following:

(define (handle-cgi-request req)
(cgi-boilerplate
(begin
;;Do whatever I want here
)))

In addition, since we are not defining our variables explicitly, adding new variable definitions to our boilerplate won't affect its calling conventions, so new features can be added without having to create a whole new function.

In any large project, there are inevitably templates to follow which cannot be reduced to functions, usually because of the bindings being created. Using boilerplate macros can make maintenance of such templated code much easier.

Likewise, other standard macros can be created which make use of variables defined in the boilerplate. Using macros like this significantly reduces typing because you do not have to constantly be writing and rewriting variable bindings, derivations, and parameter passing. This also reduces the potential for errors in such code.

Realize though that boilerplate macros are not a panacea. There are many significant problems that can occur, including:
* Accidentally overwriting bindings by introducing a variable name that was previously defined in a macro.
* Difficulty tracing problems because the inputs and the outputs of the macros are implicit, not explicit.

These can be largely avoided by doing a few things in conjunction with your boilerplate macros:
* Have a naming convention which clearly labels macros as such, as well as indicate that a variable came from boilerplate code. This could be done by affixing -m to macros and -b to variables defined within a boilerplate.
* Carefully document all boilerplate macros, especially the introduced variable bindings and all changes between versions.
* Only use boilerplate macros when the savings in repetitiveness clearly outweigh the negatives of implicit functionality.

===Abbreviate statements and prevent mistakes===
A lot of programming languages make you write really verbose statements to do really simple things. Code-generating programs allow you to abbreviate such statements and save a lot of typing, which also prevents a lot of mistakes because there is less chance of mistyping.

=Metaprogramming Framework in Java=
==Reflection==
===Introduction to reflection===
Reflection is the ability to introspect metalevel information about the program structure itself at runtime. Usually this metalevel information is modeled using the general abstraction mechanisms available in the language. In Java, reflection enables to discover information about the loaded classes:
* Fields,
* Methods, and
* Constructors
* Generics information
* Metadata annotations
It also enables to use these metaobjects to their instances in runtime environment.

The following is the Java metalevel architecture

[[File:Metalevel architecture.PNG]]

===Dynamic proxy classes===
A dynamic proxy class implements a list of interfaces specified at runtime when the class is created.
* A proxy interface is an interface that is implemented by a proxy class.
* A proxy instance is an instance of a proxy class which has an associated invocation handler object.
The following is an example of dynamic proxy classes

[[File:Dynamic_proxy_class.PNG]]

==Generics==
Generics are a facility of generic programming that was added to the Java programming language in 2004 as part of J2SE 5.0. They allow "a type or method to operate on objects of various types while providing compile-time type safety." The generics can be used in classes, interfaces, methods and constructors.
===Two new types in generics===
Two new types in generics:
* Parametrized types
* Type variables

A type variable is an unqualified identifier. Class and interface declarations can have type arguments (type variables). Method and constructors definitions can have type arguments (type variables).

The following is an example for type variables

List<String> anExample = new ArrayList<String>()

* List : interface
* ArrayList : class
* String : class (the actual type argument)
* List<String> and ArrayList<String> : parametrized type

===Class/Interface Declarations===
The following is an example of class declaration:

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

==Metadata annotation==
An annotation, in the Java computer programming language, is a form of syntactic metadata that can be added to Java source code. Classes, methods, variables, parameters and packages may be annotated.

The following is an example of annotation:

/**
* Designates a formatter to pretty-print the annotated class.
*/
public @interface PrettyPrinter{
Class<? extends Formatter> value();
}
// Single-member annotation with Class
// member restricted by bounded wildcard
// The annotation presumes the existence of this class.
class GorgeousFormatterimplements Formatter { ... }
@PrettyPrinter(GorgeousFormatter.class)
public class Petunia { ... }

‘@’ indicates the start of an annotation definition.

=References=
[1] Jonathan Bartlett, "The art of metaprogramming, Part 1: Introduction to metaprogramming", 20 Oct 2005 http://www.ibm.com/developerworks/library/l-metaprog1/index.html#N10052

[2] Jonathan Bartlett, "The art of metaprogramming, Part 2: Metaprogramming using Scheme", 02 May 2006 http://www.ibm.com/developerworks/linux/library/l-metaprog2/index.html

[3] Abdelmonaim Remani, "The Art of Metaprogramming in Java", Jul 19, 2012 http://www.slideshare.net/PolymathicCoder/the-art-of-metaprogramming-in-java

[4] Mika Haapakorpi, "Meta Programming In Java"

[5] K. Czarnecki, "Generative Programming" chapter 8, Static Metaprogramming in C++

[6] http://www.program-transformation.org

[7] http://www.codeproject.com/Articles/15429/Ruby-Add-class-methods-at-runtime

[8] http://docs.oracle.com/javase/tutorial/reflect/index.html

CSC/ECE 517 Spring 2013/ch1 1h jc

2013-02-19T03:34:09Z

Jrwills2: /* References */

Metaprogramming in statically typed languages
=Metaprogramming in statically typed languages=
==Introduction==
===What is metaprogramming===

Metaprogramming refers to writing programs that can manipulate other programs or themselves. The program that is doing the manipulating is called the ''metaprogram'', and the program that is being manipulated is called the ''object program''. The language of the ''metaprogram'' is referred to as the ''metalanguage'' and the language of the object program is called the ''object language''. A language has the ability of ''reflection'' if it can be used to write a metaprogram that can manipulate a program written in the same language.

===Metaprogramming in statically typed languages===

Metaprogramming can be accomplished in both statically and dynamically typed languages. Dynamically type languages have some advantages over statically typed languages when it comes to metaprogramming.

One example of a metaprogramming task is to add a method to a particular class at runtime. Sample code in Ruby to perform this task is outlined below. First is a definition of a Ruby class called TestAddMethodAtRuntime:

class TestAddMethodAtRuntime
def originalMethod
puts "Original Method"
end
end

The code below created a new instance of the class. After that, it defines a new method called newlyAddedMethod. Then the original method is called, follow by the newly added method at runtime:

t = TestAddMethodAtRuntime.new
def t.newlyAddedMethod
puts "Newly Added Method"
end
t.originalMethod
puts "\n"
t.newlyAddedMethod

Below is the output of the code above:

Original Method
Newly Added Method

Accomplishing something like this in a statically typed language would be much more difficult or impossible depending on the language. It is for this reason that dynamically typed languages are usually viewed as being better equipped to handle metaprogramming overall.

==Implementation==
===Programming Language API===

One way that metaprogramming can be possible in a language is through an API that helps programmers achieve a metaprogramming task. An example of this is a language that provides an API for reflection. One type of reflection is ''introspection'' in which the program can access the source code of the program itself.

Below is an example from the Java API to illustrate how an API can be used to achieve some metaprogramming tasks:

import java.lang.reflect.*;
public class DumpMethods {
public static void main(String args[]) {
try {
Class c = Class.forName(args[0]);
Method m[] = c.getDeclaredMethods();
for (int i = 0; i < m.length; i++) {
System.out.println(m[i].toString());
}
}
catch (Throwable e) {
System.err.println(e);
}
}

The above example prints out all of the methods that are declared for a particular class. This is an example of metaprogramming since the program is accessing the source code of itself.

===Program transformation system===

A program transformation system is something that takes a program as the input, and outputs a different program. One example of a program transformation system is the Java compiler. The Java compiler takes a Java program as its input, and outputs a .class file with platform independent bytecode in it. Another example of a program transformation system is a Java decompiler, which takes bytecode as an input and outputs a Java program.

In the case of the Java compiler, the program input is being output into another program in a different "language". There are other types of transformation systems that take a program as an input and output a different program in the same language. One example of this would be ''program migration'' which migrates source code to a newer or older version of the same language. This can be useful if upgrading a software system to run on a newer version of a framework.

==Common Uses==
===Pre-generate static data at compile time===
One common use of metaprogramming in statically typed languages is to write programs that will pre-generate tables of data for use at runtime.

One simple but useful code generator is to build static lookup tables. Often, in order to build fast functions in C programming, we simply create a lookup table of all of the answers. This means that we either need to pre-compute them by hand (which is wasteful of your time) or build them at runtime (which is wasteful of the user's time).

In following example we will build a generator that will take a function or set of functions on an integer and build lookup tables for the answer.

To think of how to make such a program, we can start from the end and work backward. Firstly we need a lookup table that will return square roots of numbers between 5 and 20. A simple program can be written to generate such a table like this:

Generate and use a lookup table of square roots

/* our lookup table */
double square_roots[21];
/* function to load the table at runtime */
void init_square_roots()
{
int i;
for(i = 5; i < 21; i++)
{
square_roots[i] = sqrt((double)i);
}
}

With that single macro, we can take away a lot of work for any program that has to generate mathematical tables indexed by integer. A little extra work would also allow tables containing full struct definitions; a little more would ensure that space isn't wasted at the front of the array with useless empty entries.
/* program that uses the table */
int main ()
{
init_square_roots();
printf("The square root of 5 is %f\n", square_roots[5]);
return 0;
}

Now, to convert this to a statically initialized array, you would remove the first part of the program and replace it with something like this, calculated by hand:

Square root program with a static lookup table

double square_roots[] = {
/* these are the ones we skipped */ 0.0, 0.0, 0.0, 0.0, 0.0
2.236068, /* Square root of 5 */
2.449490, /* Square root of 6 */
2.645751, /* Square root of 7 */
2.828427, /* Square root of 8 */
3.0, /* Square root of 9 */
...
4.472136 /* Square root of 20 */
};

What is needed is a program that will produce these values and print them out in a table like the previous one so they are loaded in at compile-time.

Code generator for the table macro

#!/usr/bin/perl
#
#tablegen.pl
#
##Puts each program line into $line
while(my $line = <>)
{
#Is this a macro invocation?
if($line =~ m/TABLE:/)
{
#If so, split it apart into its component pieces
my ($dummy, $table_name, $type, $start_idx, $end_idx, $default, $procedure) = split(m/:/, $line, 7);
#The main difference between C and Perl for mathematical expressions is that
#Perl prefixes its variables with a dollar sign, so we will add that here
$procedure =~ s/VAL/\$VAL/g;
#Print out the array declaration
print "${type} ${table_name} [] = {\n";
#Go through each array element
foreach my $VAL (0 .. $end_idx)
{
#Only process an answer if we have reached our starting index
if($VAL >= $start_idx)
{
#evaluate the procedure specified (this sets $@ if there are any errors)
$result = eval $procedure;
die("Error processing: $@") if $@;
}
else
{
#if we haven't reached the starting index, just use the default
$result = $default;
}
#Print out the value
print "\t${result}";
#If there are more to be processed, add a comma after the value
if($VAL != $end_idx)
{
print ",";
}
print "\n"
}
#Finish the declaration
print "};\n";
}
else
{
#If this is not a macro invocation, just copy the line directly to the output
print $line;
}
}

To run this program, do this:

Running the code generator

./tablegen.pl < sqrt.in > sqrt.c
gcc sqrt.c -o sqrt
./a.out

===Mini-language for boiler-plate===
If you have a large application where many of the functions include a lot of boilerplate code, it is often a good idea to create a mini-language that allows you to work with your boilerplate code in an easier fashion. This mini-language will then be converted into your regular source code language before compiling.

The following is an example:

Let's say that we are building a CGI application consisting of many independent CGI scripts. In most CGI applications, much of the state is stored in a database, but only a session ID is passed to each script via a cookie.

However, in nearly every page we need to know the other standard information (such as the username, group number, the current job being worked on, whatever else information is pertinent). In addition, we need to redirect the user if they do not have an appropriate cookie.

(define (handle-cgi-request req)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
;;Code for processing goes here
))))

While some of that can be handled by a procedure, the bindings certainly cannot. However, we can turn most of it into a macro. The macro can be implemented like this:

(define-syntax cgi-boilerplate
(lambda (x)
(syntax-case x ()
(
(cgi-boilerplate expr)
(datum->syntax-object
(syntax k)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
(syntax-object->datum (syntax expr))))))
)
)))

We can now create new forms based on our boilerplate code by doing the following:

(define (handle-cgi-request req)
(cgi-boilerplate
(begin
;;Do whatever I want here
)))

In addition, since we are not defining our variables explicitly, adding new variable definitions to our boilerplate won't affect its calling conventions, so new features can be added without having to create a whole new function.

In any large project, there are inevitably templates to follow which cannot be reduced to functions, usually because of the bindings being created. Using boilerplate macros can make maintenance of such templated code much easier.

Likewise, other standard macros can be created which make use of variables defined in the boilerplate. Using macros like this significantly reduces typing because you do not have to constantly be writing and rewriting variable bindings, derivations, and parameter passing. This also reduces the potential for errors in such code.

Realize though that boilerplate macros are not a panacea. There are many significant problems that can occur, including:
* Accidentally overwriting bindings by introducing a variable name that was previously defined in a macro.
* Difficulty tracing problems because the inputs and the outputs of the macros are implicit, not explicit.

These can be largely avoided by doing a few things in conjunction with your boilerplate macros:
* Have a naming convention which clearly labels macros as such, as well as indicate that a variable came from boilerplate code. This could be done by affixing -m to macros and -b to variables defined within a boilerplate.
* Carefully document all boilerplate macros, especially the introduced variable bindings and all changes between versions.
* Only use boilerplate macros when the savings in repetitiveness clearly outweigh the negatives of implicit functionality.

===Abbreviate statements and prevent mistakes===
A lot of programming languages make you write really verbose statements to do really simple things. Code-generating programs allow you to abbreviate such statements and save a lot of typing, which also prevents a lot of mistakes because there is less chance of mistyping.

=Metaprogramming Framework in Java=
==Reflection==
===Introduction to reflection===
Reflection is the ability to introspect metalevel information about the program structure itself at runtime. Usually this metalevel information is modeled using the general abstraction mechanisms available in the language. In Java, reflection enables to discover information about the loaded classes:
* Fields,
* Methods, and
* Constructors
* Generics information
* Metadata annotations
It also enables to use these metaobjects to their instances in runtime environment.

The following is the Java metalevel architecture

[[File:Metalevel architecture.PNG]]

===Dynamic proxy classes===
A dynamic proxy class implements a list of interfaces specified at runtime when the class is created.
* A proxy interface is an interface that is implemented by a proxy class.
* A proxy instance is an instance of a proxy class which has an associated invocation handler object.
The following is an example of dynamic proxy classes

[[File:Dynamic_proxy_class.PNG]]

==Generics==
Generics are a facility of generic programming that was added to the Java programming language in 2004 as part of J2SE 5.0. They allow "a type or method to operate on objects of various types while providing compile-time type safety." The generics can be used in classes, interfaces, methods and constructors.
===Two new types in generics===
Two new types in generics:
* Parametrized types
* Type variables

A type variable is an unqualified identifier. Class and interface declarations can have type arguments (type variables). Method and constructors definitions can have type arguments (type variables).

The following is an example for type variables

List<String> anExample = new ArrayList<String>()

* List : interface
* ArrayList : class
* String : class (the actual type argument)
* List<String> and ArrayList<String> : parametrized type

===Class/Interface Declarations===
The following is an example of class declaration:

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

==Metadata annotation==
An annotation, in the Java computer programming language, is a form of syntactic metadata that can be added to Java source code. Classes, methods, variables, parameters and packages may be annotated.

The following is an example of annotation:

/**
* Designates a formatter to pretty-print the annotated class.
*/
public @interface PrettyPrinter{
Class<? extends Formatter> value();
}
// Single-member annotation with Class
// member restricted by bounded wildcard
// The annotation presumes the existence of this class.
class GorgeousFormatterimplements Formatter { ... }
@PrettyPrinter(GorgeousFormatter.class)
public class Petunia { ... }

‘@’ indicates the start of an annotation definition.

=References=
[1] Jonathan Bartlett, "The art of metaprogramming, Part 1: Introduction to metaprogramming", 20 Oct 2005 http://www.ibm.com/developerworks/library/l-metaprog1/index.html#N10052

[2] Jonathan Bartlett, "The art of metaprogramming, Part 2: Metaprogramming using Scheme", 02 May 2006 http://www.ibm.com/developerworks/linux/library/l-metaprog2/index.html

[3] Abdelmonaim Remani, "The Art of Metaprogramming in Java", Jul 19, 2012 http://www.slideshare.net/PolymathicCoder/the-art-of-metaprogramming-in-java

[4] Mika Haapakorpi, "Meta Programming In Java"

[5] K. Czarnecki, "Generative Programming" chapter 8, Static Metaprogramming in C++

[6] http://www.program-transformation.org

[7] http://www.codeproject.com/Articles/15429/Ruby-Add-class-methods-at-runtime

[8] http://docs.oracle.com/javase/tutorial/reflect/index.html

CSC/ECE 517 Spring 2013/ch1 1h jc

2013-02-19T03:33:54Z

Jrwills2: /* References */

Metaprogramming in statically typed languages
=Metaprogramming in statically typed languages=
==Introduction==
===What is metaprogramming===

Metaprogramming refers to writing programs that can manipulate other programs or themselves. The program that is doing the manipulating is called the ''metaprogram'', and the program that is being manipulated is called the ''object program''. The language of the ''metaprogram'' is referred to as the ''metalanguage'' and the language of the object program is called the ''object language''. A language has the ability of ''reflection'' if it can be used to write a metaprogram that can manipulate a program written in the same language.

===Metaprogramming in statically typed languages===

Metaprogramming can be accomplished in both statically and dynamically typed languages. Dynamically type languages have some advantages over statically typed languages when it comes to metaprogramming.

One example of a metaprogramming task is to add a method to a particular class at runtime. Sample code in Ruby to perform this task is outlined below. First is a definition of a Ruby class called TestAddMethodAtRuntime:

class TestAddMethodAtRuntime
def originalMethod
puts "Original Method"
end
end

The code below created a new instance of the class. After that, it defines a new method called newlyAddedMethod. Then the original method is called, follow by the newly added method at runtime:

t = TestAddMethodAtRuntime.new
def t.newlyAddedMethod
puts "Newly Added Method"
end
t.originalMethod
puts "\n"
t.newlyAddedMethod

Below is the output of the code above:

Original Method
Newly Added Method

Accomplishing something like this in a statically typed language would be much more difficult or impossible depending on the language. It is for this reason that dynamically typed languages are usually viewed as being better equipped to handle metaprogramming overall.

==Implementation==
===Programming Language API===

One way that metaprogramming can be possible in a language is through an API that helps programmers achieve a metaprogramming task. An example of this is a language that provides an API for reflection. One type of reflection is ''introspection'' in which the program can access the source code of the program itself.

Below is an example from the Java API to illustrate how an API can be used to achieve some metaprogramming tasks:

import java.lang.reflect.*;
public class DumpMethods {
public static void main(String args[]) {
try {
Class c = Class.forName(args[0]);
Method m[] = c.getDeclaredMethods();
for (int i = 0; i < m.length; i++) {
System.out.println(m[i].toString());
}
}
catch (Throwable e) {
System.err.println(e);
}
}

The above example prints out all of the methods that are declared for a particular class. This is an example of metaprogramming since the program is accessing the source code of itself.

===Program transformation system===

A program transformation system is something that takes a program as the input, and outputs a different program. One example of a program transformation system is the Java compiler. The Java compiler takes a Java program as its input, and outputs a .class file with platform independent bytecode in it. Another example of a program transformation system is a Java decompiler, which takes bytecode as an input and outputs a Java program.

In the case of the Java compiler, the program input is being output into another program in a different "language". There are other types of transformation systems that take a program as an input and output a different program in the same language. One example of this would be ''program migration'' which migrates source code to a newer or older version of the same language. This can be useful if upgrading a software system to run on a newer version of a framework.

==Common Uses==
===Pre-generate static data at compile time===
One common use of metaprogramming in statically typed languages is to write programs that will pre-generate tables of data for use at runtime.

One simple but useful code generator is to build static lookup tables. Often, in order to build fast functions in C programming, we simply create a lookup table of all of the answers. This means that we either need to pre-compute them by hand (which is wasteful of your time) or build them at runtime (which is wasteful of the user's time).

In following example we will build a generator that will take a function or set of functions on an integer and build lookup tables for the answer.

To think of how to make such a program, we can start from the end and work backward. Firstly we need a lookup table that will return square roots of numbers between 5 and 20. A simple program can be written to generate such a table like this:

Generate and use a lookup table of square roots

/* our lookup table */
double square_roots[21];
/* function to load the table at runtime */
void init_square_roots()
{
int i;
for(i = 5; i < 21; i++)
{
square_roots[i] = sqrt((double)i);
}
}

With that single macro, we can take away a lot of work for any program that has to generate mathematical tables indexed by integer. A little extra work would also allow tables containing full struct definitions; a little more would ensure that space isn't wasted at the front of the array with useless empty entries.
/* program that uses the table */
int main ()
{
init_square_roots();
printf("The square root of 5 is %f\n", square_roots[5]);
return 0;
}

Now, to convert this to a statically initialized array, you would remove the first part of the program and replace it with something like this, calculated by hand:

Square root program with a static lookup table

double square_roots[] = {
/* these are the ones we skipped */ 0.0, 0.0, 0.0, 0.0, 0.0
2.236068, /* Square root of 5 */
2.449490, /* Square root of 6 */
2.645751, /* Square root of 7 */
2.828427, /* Square root of 8 */
3.0, /* Square root of 9 */
...
4.472136 /* Square root of 20 */
};

What is needed is a program that will produce these values and print them out in a table like the previous one so they are loaded in at compile-time.

Code generator for the table macro

#!/usr/bin/perl
#
#tablegen.pl
#
##Puts each program line into $line
while(my $line = <>)
{
#Is this a macro invocation?
if($line =~ m/TABLE:/)
{
#If so, split it apart into its component pieces
my ($dummy, $table_name, $type, $start_idx, $end_idx, $default, $procedure) = split(m/:/, $line, 7);
#The main difference between C and Perl for mathematical expressions is that
#Perl prefixes its variables with a dollar sign, so we will add that here
$procedure =~ s/VAL/\$VAL/g;
#Print out the array declaration
print "${type} ${table_name} [] = {\n";
#Go through each array element
foreach my $VAL (0 .. $end_idx)
{
#Only process an answer if we have reached our starting index
if($VAL >= $start_idx)
{
#evaluate the procedure specified (this sets $@ if there are any errors)
$result = eval $procedure;
die("Error processing: $@") if $@;
}
else
{
#if we haven't reached the starting index, just use the default
$result = $default;
}
#Print out the value
print "\t${result}";
#If there are more to be processed, add a comma after the value
if($VAL != $end_idx)
{
print ",";
}
print "\n"
}
#Finish the declaration
print "};\n";
}
else
{
#If this is not a macro invocation, just copy the line directly to the output
print $line;
}
}

To run this program, do this:

Running the code generator

./tablegen.pl < sqrt.in > sqrt.c
gcc sqrt.c -o sqrt
./a.out

===Mini-language for boiler-plate===
If you have a large application where many of the functions include a lot of boilerplate code, it is often a good idea to create a mini-language that allows you to work with your boilerplate code in an easier fashion. This mini-language will then be converted into your regular source code language before compiling.

The following is an example:

Let's say that we are building a CGI application consisting of many independent CGI scripts. In most CGI applications, much of the state is stored in a database, but only a session ID is passed to each script via a cookie.

However, in nearly every page we need to know the other standard information (such as the username, group number, the current job being worked on, whatever else information is pertinent). In addition, we need to redirect the user if they do not have an appropriate cookie.

(define (handle-cgi-request req)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
;;Code for processing goes here
))))

While some of that can be handled by a procedure, the bindings certainly cannot. However, we can turn most of it into a macro. The macro can be implemented like this:

(define-syntax cgi-boilerplate
(lambda (x)
(syntax-case x ()
(
(cgi-boilerplate expr)
(datum->syntax-object
(syntax k)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
(syntax-object->datum (syntax expr))))))
)
)))

We can now create new forms based on our boilerplate code by doing the following:

(define (handle-cgi-request req)
(cgi-boilerplate
(begin
;;Do whatever I want here
)))

In addition, since we are not defining our variables explicitly, adding new variable definitions to our boilerplate won't affect its calling conventions, so new features can be added without having to create a whole new function.

In any large project, there are inevitably templates to follow which cannot be reduced to functions, usually because of the bindings being created. Using boilerplate macros can make maintenance of such templated code much easier.

Likewise, other standard macros can be created which make use of variables defined in the boilerplate. Using macros like this significantly reduces typing because you do not have to constantly be writing and rewriting variable bindings, derivations, and parameter passing. This also reduces the potential for errors in such code.

Realize though that boilerplate macros are not a panacea. There are many significant problems that can occur, including:
* Accidentally overwriting bindings by introducing a variable name that was previously defined in a macro.
* Difficulty tracing problems because the inputs and the outputs of the macros are implicit, not explicit.

These can be largely avoided by doing a few things in conjunction with your boilerplate macros:
* Have a naming convention which clearly labels macros as such, as well as indicate that a variable came from boilerplate code. This could be done by affixing -m to macros and -b to variables defined within a boilerplate.
* Carefully document all boilerplate macros, especially the introduced variable bindings and all changes between versions.
* Only use boilerplate macros when the savings in repetitiveness clearly outweigh the negatives of implicit functionality.

===Abbreviate statements and prevent mistakes===
A lot of programming languages make you write really verbose statements to do really simple things. Code-generating programs allow you to abbreviate such statements and save a lot of typing, which also prevents a lot of mistakes because there is less chance of mistyping.

=Metaprogramming Framework in Java=
==Reflection==
===Introduction to reflection===
Reflection is the ability to introspect metalevel information about the program structure itself at runtime. Usually this metalevel information is modeled using the general abstraction mechanisms available in the language. In Java, reflection enables to discover information about the loaded classes:
* Fields,
* Methods, and
* Constructors
* Generics information
* Metadata annotations
It also enables to use these metaobjects to their instances in runtime environment.

The following is the Java metalevel architecture

[[File:Metalevel architecture.PNG]]

===Dynamic proxy classes===
A dynamic proxy class implements a list of interfaces specified at runtime when the class is created.
* A proxy interface is an interface that is implemented by a proxy class.
* A proxy instance is an instance of a proxy class which has an associated invocation handler object.
The following is an example of dynamic proxy classes

[[File:Dynamic_proxy_class.PNG]]

==Generics==
Generics are a facility of generic programming that was added to the Java programming language in 2004 as part of J2SE 5.0. They allow "a type or method to operate on objects of various types while providing compile-time type safety." The generics can be used in classes, interfaces, methods and constructors.
===Two new types in generics===
Two new types in generics:
* Parametrized types
* Type variables

A type variable is an unqualified identifier. Class and interface declarations can have type arguments (type variables). Method and constructors definitions can have type arguments (type variables).

The following is an example for type variables

List<String> anExample = new ArrayList<String>()

* List : interface
* ArrayList : class
* String : class (the actual type argument)
* List<String> and ArrayList<String> : parametrized type

===Class/Interface Declarations===
The following is an example of class declaration:

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

==Metadata annotation==
An annotation, in the Java computer programming language, is a form of syntactic metadata that can be added to Java source code. Classes, methods, variables, parameters and packages may be annotated.

The following is an example of annotation:

/**
* Designates a formatter to pretty-print the annotated class.
*/
public @interface PrettyPrinter{
Class<? extends Formatter> value();
}
// Single-member annotation with Class
// member restricted by bounded wildcard
// The annotation presumes the existence of this class.
class GorgeousFormatterimplements Formatter { ... }
@PrettyPrinter(GorgeousFormatter.class)
public class Petunia { ... }

‘@’ indicates the start of an annotation definition.

=References=
[1] Jonathan Bartlett, "The art of metaprogramming, Part 1: Introduction to metaprogramming", 20 Oct 2005 http://www.ibm.com/developerworks/library/l-metaprog1/index.html#N10052

[2] Jonathan Bartlett, "The art of metaprogramming, Part 2: Metaprogramming using Scheme", 02 May 2006 http://www.ibm.com/developerworks/linux/library/l-metaprog2/index.html

[3] Abdelmonaim Remani, "The Art of Metaprogramming in Java", Jul 19, 2012 http://www.slideshare.net/PolymathicCoder/the-art-of-metaprogramming-in-java

[4] Mika Haapakorpi, "Meta Programming In Java"

[5] K. Czarnecki, "Generative Programming" chapter 8, Static Metaprogramming in C++

[6] www.program-transformation.org

[7] http://www.codeproject.com/Articles/15429/Ruby-Add-class-methods-at-runtime

[8] http://docs.oracle.com/javase/tutorial/reflect/index.html

CSC/ECE 517 Spring 2013/ch1 1h jc

2013-02-19T03:31:22Z

Jrwills2:

Metaprogramming in statically typed languages
=Metaprogramming in statically typed languages=
==Introduction==
===What is metaprogramming===

Metaprogramming refers to writing programs that can manipulate other programs or themselves. The program that is doing the manipulating is called the ''metaprogram'', and the program that is being manipulated is called the ''object program''. The language of the ''metaprogram'' is referred to as the ''metalanguage'' and the language of the object program is called the ''object language''. A language has the ability of ''reflection'' if it can be used to write a metaprogram that can manipulate a program written in the same language.

===Metaprogramming in statically typed languages===

Metaprogramming can be accomplished in both statically and dynamically typed languages. Dynamically type languages have some advantages over statically typed languages when it comes to metaprogramming.

One example of a metaprogramming task is to add a method to a particular class at runtime. Sample code in Ruby to perform this task is outlined below. First is a definition of a Ruby class called TestAddMethodAtRuntime:

class TestAddMethodAtRuntime
def originalMethod
puts "Original Method"
end
end

The code below created a new instance of the class. After that, it defines a new method called newlyAddedMethod. Then the original method is called, follow by the newly added method at runtime:

t = TestAddMethodAtRuntime.new
def t.newlyAddedMethod
puts "Newly Added Method"
end
t.originalMethod
puts "\n"
t.newlyAddedMethod

Below is the output of the code above:

Original Method
Newly Added Method

Accomplishing something like this in a statically typed language would be much more difficult or impossible depending on the language. It is for this reason that dynamically typed languages are usually viewed as being better equipped to handle metaprogramming overall.

==Implementation==
===Programming Language API===

One way that metaprogramming can be possible in a language is through an API that helps programmers achieve a metaprogramming task. An example of this is a language that provides an API for reflection. One type of reflection is ''introspection'' in which the program can access the source code of the program itself.

Below is an example from the Java API to illustrate how an API can be used to achieve some metaprogramming tasks:

import java.lang.reflect.*;
public class DumpMethods {
public static void main(String args[]) {
try {
Class c = Class.forName(args[0]);
Method m[] = c.getDeclaredMethods();
for (int i = 0; i < m.length; i++) {
System.out.println(m[i].toString());
}
}
catch (Throwable e) {
System.err.println(e);
}
}

The above example prints out all of the methods that are declared for a particular class. This is an example of metaprogramming since the program is accessing the source code of itself.

===Program transformation system===

A program transformation system is something that takes a program as the input, and outputs a different program. One example of a program transformation system is the Java compiler. The Java compiler takes a Java program as its input, and outputs a .class file with platform independent bytecode in it. Another example of a program transformation system is a Java decompiler, which takes bytecode as an input and outputs a Java program.

In the case of the Java compiler, the program input is being output into another program in a different "language". There are other types of transformation systems that take a program as an input and output a different program in the same language. One example of this would be ''program migration'' which migrates source code to a newer or older version of the same language. This can be useful if upgrading a software system to run on a newer version of a framework.

==Common Uses==
===Pre-generate static data at compile time===
One common use of metaprogramming in statically typed languages is to write programs that will pre-generate tables of data for use at runtime.

One simple but useful code generator is to build static lookup tables. Often, in order to build fast functions in C programming, we simply create a lookup table of all of the answers. This means that we either need to pre-compute them by hand (which is wasteful of your time) or build them at runtime (which is wasteful of the user's time).

In following example we will build a generator that will take a function or set of functions on an integer and build lookup tables for the answer.

To think of how to make such a program, we can start from the end and work backward. Firstly we need a lookup table that will return square roots of numbers between 5 and 20. A simple program can be written to generate such a table like this:

Generate and use a lookup table of square roots

/* our lookup table */
double square_roots[21];
/* function to load the table at runtime */
void init_square_roots()
{
int i;
for(i = 5; i < 21; i++)
{
square_roots[i] = sqrt((double)i);
}
}

With that single macro, we can take away a lot of work for any program that has to generate mathematical tables indexed by integer. A little extra work would also allow tables containing full struct definitions; a little more would ensure that space isn't wasted at the front of the array with useless empty entries.
/* program that uses the table */
int main ()
{
init_square_roots();
printf("The square root of 5 is %f\n", square_roots[5]);
return 0;
}

Now, to convert this to a statically initialized array, you would remove the first part of the program and replace it with something like this, calculated by hand:

Square root program with a static lookup table

double square_roots[] = {
/* these are the ones we skipped */ 0.0, 0.0, 0.0, 0.0, 0.0
2.236068, /* Square root of 5 */
2.449490, /* Square root of 6 */
2.645751, /* Square root of 7 */
2.828427, /* Square root of 8 */
3.0, /* Square root of 9 */
...
4.472136 /* Square root of 20 */
};

What is needed is a program that will produce these values and print them out in a table like the previous one so they are loaded in at compile-time.

Code generator for the table macro

#!/usr/bin/perl
#
#tablegen.pl
#
##Puts each program line into $line
while(my $line = <>)
{
#Is this a macro invocation?
if($line =~ m/TABLE:/)
{
#If so, split it apart into its component pieces
my ($dummy, $table_name, $type, $start_idx, $end_idx, $default, $procedure) = split(m/:/, $line, 7);
#The main difference between C and Perl for mathematical expressions is that
#Perl prefixes its variables with a dollar sign, so we will add that here
$procedure =~ s/VAL/\$VAL/g;
#Print out the array declaration
print "${type} ${table_name} [] = {\n";
#Go through each array element
foreach my $VAL (0 .. $end_idx)
{
#Only process an answer if we have reached our starting index
if($VAL >= $start_idx)
{
#evaluate the procedure specified (this sets $@ if there are any errors)
$result = eval $procedure;
die("Error processing: $@") if $@;
}
else
{
#if we haven't reached the starting index, just use the default
$result = $default;
}
#Print out the value
print "\t${result}";
#If there are more to be processed, add a comma after the value
if($VAL != $end_idx)
{
print ",";
}
print "\n"
}
#Finish the declaration
print "};\n";
}
else
{
#If this is not a macro invocation, just copy the line directly to the output
print $line;
}
}

To run this program, do this:

Running the code generator

./tablegen.pl < sqrt.in > sqrt.c
gcc sqrt.c -o sqrt
./a.out

===Mini-language for boiler-plate===
If you have a large application where many of the functions include a lot of boilerplate code, it is often a good idea to create a mini-language that allows you to work with your boilerplate code in an easier fashion. This mini-language will then be converted into your regular source code language before compiling.

The following is an example:

Let's say that we are building a CGI application consisting of many independent CGI scripts. In most CGI applications, much of the state is stored in a database, but only a session ID is passed to each script via a cookie.

However, in nearly every page we need to know the other standard information (such as the username, group number, the current job being worked on, whatever else information is pertinent). In addition, we need to redirect the user if they do not have an appropriate cookie.

(define (handle-cgi-request req)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
;;Code for processing goes here
))))

While some of that can be handled by a procedure, the bindings certainly cannot. However, we can turn most of it into a macro. The macro can be implemented like this:

(define-syntax cgi-boilerplate
(lambda (x)
(syntax-case x ()
(
(cgi-boilerplate expr)
(datum->syntax-object
(syntax k)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
(syntax-object->datum (syntax expr))))))
)
)))

We can now create new forms based on our boilerplate code by doing the following:

(define (handle-cgi-request req)
(cgi-boilerplate
(begin
;;Do whatever I want here
)))

In addition, since we are not defining our variables explicitly, adding new variable definitions to our boilerplate won't affect its calling conventions, so new features can be added without having to create a whole new function.

In any large project, there are inevitably templates to follow which cannot be reduced to functions, usually because of the bindings being created. Using boilerplate macros can make maintenance of such templated code much easier.

Likewise, other standard macros can be created which make use of variables defined in the boilerplate. Using macros like this significantly reduces typing because you do not have to constantly be writing and rewriting variable bindings, derivations, and parameter passing. This also reduces the potential for errors in such code.

Realize though that boilerplate macros are not a panacea. There are many significant problems that can occur, including:
* Accidentally overwriting bindings by introducing a variable name that was previously defined in a macro.
* Difficulty tracing problems because the inputs and the outputs of the macros are implicit, not explicit.

These can be largely avoided by doing a few things in conjunction with your boilerplate macros:
* Have a naming convention which clearly labels macros as such, as well as indicate that a variable came from boilerplate code. This could be done by affixing -m to macros and -b to variables defined within a boilerplate.
* Carefully document all boilerplate macros, especially the introduced variable bindings and all changes between versions.
* Only use boilerplate macros when the savings in repetitiveness clearly outweigh the negatives of implicit functionality.

===Abbreviate statements and prevent mistakes===
A lot of programming languages make you write really verbose statements to do really simple things. Code-generating programs allow you to abbreviate such statements and save a lot of typing, which also prevents a lot of mistakes because there is less chance of mistyping.

=Metaprogramming Framework in Java=
==Reflection==
===Introduction to reflection===
Reflection is the ability to introspect metalevel information about the program structure itself at runtime. Usually this metalevel information is modeled using the general abstraction mechanisms available in the language. In Java, reflection enables to discover information about the loaded classes:
* Fields,
* Methods, and
* Constructors
* Generics information
* Metadata annotations
It also enables to use these metaobjects to their instances in runtime environment.

The following is the Java metalevel architecture

[[File:Metalevel architecture.PNG]]

===Dynamic proxy classes===
A dynamic proxy class implements a list of interfaces specified at runtime when the class is created.
* A proxy interface is an interface that is implemented by a proxy class.
* A proxy instance is an instance of a proxy class which has an associated invocation handler object.
The following is an example of dynamic proxy classes

[[File:Dynamic_proxy_class.PNG]]

==Generics==
Generics are a facility of generic programming that was added to the Java programming language in 2004 as part of J2SE 5.0. They allow "a type or method to operate on objects of various types while providing compile-time type safety." The generics can be used in classes, interfaces, methods and constructors.
===Two new types in generics===
Two new types in generics:
* Parametrized types
* Type variables

A type variable is an unqualified identifier. Class and interface declarations can have type arguments (type variables). Method and constructors definitions can have type arguments (type variables).

The following is an example for type variables

List<String> anExample = new ArrayList<String>()

* List : interface
* ArrayList : class
* String : class (the actual type argument)
* List<String> and ArrayList<String> : parametrized type

===Class/Interface Declarations===
The following is an example of class declaration:

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

==Metadata annotation==
An annotation, in the Java computer programming language, is a form of syntactic metadata that can be added to Java source code. Classes, methods, variables, parameters and packages may be annotated.

The following is an example of annotation:

/**
* Designates a formatter to pretty-print the annotated class.
*/
public @interface PrettyPrinter{
Class<? extends Formatter> value();
}
// Single-member annotation with Class
// member restricted by bounded wildcard
// The annotation presumes the existence of this class.
class GorgeousFormatterimplements Formatter { ... }
@PrettyPrinter(GorgeousFormatter.class)
public class Petunia { ... }

‘@’ indicates the start of an annotation definition.

=References=
[1] Jonathan Bartlett, "The art of metaprogramming, Part 1: Introduction to metaprogramming", 20 Oct 2005 http://www.ibm.com/developerworks/library/l-metaprog1/index.html#N10052

[2] Jonathan Bartlett, "The art of metaprogramming, Part 2: Metaprogramming using Scheme", 02 May 2006 http://www.ibm.com/developerworks/linux/library/l-metaprog2/index.html

[3] Abdelmonaim Remani, "The Art of Metaprogramming in Java", Jul 19, 2012 http://www.slideshare.net/PolymathicCoder/the-art-of-metaprogramming-in-java

[4] Mika Haapakorpi, "Meta Programming In Java"

[5] K. Czarnecki, "Generative Programming" chapter 8, Static Metaprogramming in C++

CSC/ECE 517 Spring 2013/ch1 1h jc

2013-02-19T03:30:38Z

Jrwills2:

Metaprogramming in statically typed languages
=Metaprogramming in statically typed languages=
==Introduction==
===What is metaprogramming===

Metaprogramming refers to writing programs that can manipulate other programs or themselves. The program that is doing the manipulating is called the ''metaprogram'', and the program that is being manipulated is called the ''object program''. The language of the ''metaprogram'' is referred to as the ''metalanguage'' and the language of the object program is called the ''object language''. A language has the ability of ''reflection'' if it can be used to write a metaprogram that can manipulate a program written in the same language.

===Metaprogramming in statically typed languages===

Metaprogramming can be accomplished in both statically and dynamically typed languages. Dynamically type languages have some advantages over statically typed languages when it comes to metaprogramming.

One example of a metaprogramming task is to add a method to a particular class at runtime. Sample code in Ruby to perform this task is outlined below. First is a definition of a Ruby class called TestAddMethodAtRuntime:

class TestAddMethodAtRuntime
def originalMethod
puts "Original Method"
end
end

The code below created a new instance of the class. After that, it defines a new method called newlyAddedMethod. Then the original method is called, follow by the newly added method at runtime:

t = TestAddMethodAtRuntime.new
def t.newlyAddedMethod
puts "Newly Added Method"
end
t.originalMethod
puts "\n"
t.newlyAddedMethod

Below is the output of the code above:

Original Method
Newly Added Method

Accomplishing something like this in a statically typed language would be much more difficult or impossible depending on the language. It is for this reason that dynamically typed languages are usually viewed as being better equipped to handle metaprogramming overall.

==Implementation==
===Programming Language API===

One way that metaprogramming can be possible in a language is through an API that helps programmers achieve a metaprogramming task. An example of this is a language that provides an API for reflection. One type of reflection is ''introspection'' in which the program can access the source code of the program itself.

Below is an example from the Java API to illustrate how an API can be used to achieve some metaprogramming tasks:

import java.lang.reflect.*;
public class DumpMethods {
public static void main(String args[]) {
try {
Class c = Class.forName(args[0]);
Method m[] = c.getDeclaredMethods();
for (int i = 0; i < m.length; i++) {
System.out.println(m[i].toString());
}
}
catch (Throwable e) {
System.err.println(e);
}
}

The above example prints out all of the methods that are declared for a particular class. This is an example of metaprogramming since the program is accessing the source code of itself.

===Program transformation system===

A program transformation system is something that takes a program as the input, and outputs a different program. One example of a program transformation system is the Java compiler. The Java compiler takes a Java program as its input, and outputs a .class file with platform independent bytecode in it. Another example of a program transformation system is a Java decompiler, which takes bytecode as an input and outputs a Java program.

In the case of the Java compiler, the program input is being output into another program in a different "language". There are other types of transformation systems that take a program as an input and output a different program in the same language. One example of this would be ''program migration'' which migrates source code to a newer or older version of the same language. This can be useful if upgrading a software system to run on a newer version of a framework.

===Metaprogramming using Scheme===
==Common Uses==
===Pre-generate static data at compile time===
One common use of metaprogramming in statically typed languages is to write programs that will pre-generate tables of data for use at runtime.

One simple but useful code generator is to build static lookup tables. Often, in order to build fast functions in C programming, we simply create a lookup table of all of the answers. This means that we either need to pre-compute them by hand (which is wasteful of your time) or build them at runtime (which is wasteful of the user's time).

In following example we will build a generator that will take a function or set of functions on an integer and build lookup tables for the answer.

To think of how to make such a program, we can start from the end and work backward. Firstly we need a lookup table that will return square roots of numbers between 5 and 20. A simple program can be written to generate such a table like this:

Generate and use a lookup table of square roots

/* our lookup table */
double square_roots[21];
/* function to load the table at runtime */
void init_square_roots()
{
int i;
for(i = 5; i < 21; i++)
{
square_roots[i] = sqrt((double)i);
}
}

With that single macro, we can take away a lot of work for any program that has to generate mathematical tables indexed by integer. A little extra work would also allow tables containing full struct definitions; a little more would ensure that space isn't wasted at the front of the array with useless empty entries.
/* program that uses the table */
int main ()
{
init_square_roots();
printf("The square root of 5 is %f\n", square_roots[5]);
return 0;
}

Now, to convert this to a statically initialized array, you would remove the first part of the program and replace it with something like this, calculated by hand:

Square root program with a static lookup table

double square_roots[] = {
/* these are the ones we skipped */ 0.0, 0.0, 0.0, 0.0, 0.0
2.236068, /* Square root of 5 */
2.449490, /* Square root of 6 */
2.645751, /* Square root of 7 */
2.828427, /* Square root of 8 */
3.0, /* Square root of 9 */
...
4.472136 /* Square root of 20 */
};

What is needed is a program that will produce these values and print them out in a table like the previous one so they are loaded in at compile-time.

Code generator for the table macro

#!/usr/bin/perl
#
#tablegen.pl
#
##Puts each program line into $line
while(my $line = <>)
{
#Is this a macro invocation?
if($line =~ m/TABLE:/)
{
#If so, split it apart into its component pieces
my ($dummy, $table_name, $type, $start_idx, $end_idx, $default, $procedure) = split(m/:/, $line, 7);
#The main difference between C and Perl for mathematical expressions is that
#Perl prefixes its variables with a dollar sign, so we will add that here
$procedure =~ s/VAL/\$VAL/g;
#Print out the array declaration
print "${type} ${table_name} [] = {\n";
#Go through each array element
foreach my $VAL (0 .. $end_idx)
{
#Only process an answer if we have reached our starting index
if($VAL >= $start_idx)
{
#evaluate the procedure specified (this sets $@ if there are any errors)
$result = eval $procedure;
die("Error processing: $@") if $@;
}
else
{
#if we haven't reached the starting index, just use the default
$result = $default;
}
#Print out the value
print "\t${result}";
#If there are more to be processed, add a comma after the value
if($VAL != $end_idx)
{
print ",";
}
print "\n"
}
#Finish the declaration
print "};\n";
}
else
{
#If this is not a macro invocation, just copy the line directly to the output
print $line;
}
}

To run this program, do this:

Running the code generator

./tablegen.pl < sqrt.in > sqrt.c
gcc sqrt.c -o sqrt
./a.out

===Mini-language for boiler-plate===
If you have a large application where many of the functions include a lot of boilerplate code, it is often a good idea to create a mini-language that allows you to work with your boilerplate code in an easier fashion. This mini-language will then be converted into your regular source code language before compiling.

The following is an example:

Let's say that we are building a CGI application consisting of many independent CGI scripts. In most CGI applications, much of the state is stored in a database, but only a session ID is passed to each script via a cookie.

However, in nearly every page we need to know the other standard information (such as the username, group number, the current job being worked on, whatever else information is pertinent). In addition, we need to redirect the user if they do not have an appropriate cookie.

(define (handle-cgi-request req)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
;;Code for processing goes here
))))

While some of that can be handled by a procedure, the bindings certainly cannot. However, we can turn most of it into a macro. The macro can be implemented like this:

(define-syntax cgi-boilerplate
(lambda (x)
(syntax-case x ()
(
(cgi-boilerplate expr)
(datum->syntax-object
(syntax k)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
(syntax-object->datum (syntax expr))))))
)
)))

We can now create new forms based on our boilerplate code by doing the following:

(define (handle-cgi-request req)
(cgi-boilerplate
(begin
;;Do whatever I want here
)))

In addition, since we are not defining our variables explicitly, adding new variable definitions to our boilerplate won't affect its calling conventions, so new features can be added without having to create a whole new function.

In any large project, there are inevitably templates to follow which cannot be reduced to functions, usually because of the bindings being created. Using boilerplate macros can make maintenance of such templated code much easier.

Likewise, other standard macros can be created which make use of variables defined in the boilerplate. Using macros like this significantly reduces typing because you do not have to constantly be writing and rewriting variable bindings, derivations, and parameter passing. This also reduces the potential for errors in such code.

Realize though that boilerplate macros are not a panacea. There are many significant problems that can occur, including:
* Accidentally overwriting bindings by introducing a variable name that was previously defined in a macro.
* Difficulty tracing problems because the inputs and the outputs of the macros are implicit, not explicit.

These can be largely avoided by doing a few things in conjunction with your boilerplate macros:
* Have a naming convention which clearly labels macros as such, as well as indicate that a variable came from boilerplate code. This could be done by affixing -m to macros and -b to variables defined within a boilerplate.
* Carefully document all boilerplate macros, especially the introduced variable bindings and all changes between versions.
* Only use boilerplate macros when the savings in repetitiveness clearly outweigh the negatives of implicit functionality.

===Abbreviate statements and prevent mistakes===
A lot of programming languages make you write really verbose statements to do really simple things. Code-generating programs allow you to abbreviate such statements and save a lot of typing, which also prevents a lot of mistakes because there is less chance of mistyping.

=Metaprogramming Framework in Java=
==Reflection==
===Introduction to reflection===
Reflection is the ability to introspect metalevel information about the program structure itself at runtime. Usually this metalevel information is modeled using the general abstraction mechanisms available in the language. In Java, reflection enables to discover information about the loaded classes:
* Fields,
* Methods, and
* Constructors
* Generics information
* Metadata annotations
It also enables to use these metaobjects to their instances in runtime environment.

The following is the Java metalevel architecture

[[File:Metalevel architecture.PNG]]

===Dynamic proxy classes===
A dynamic proxy class implements a list of interfaces specified at runtime when the class is created.
* A proxy interface is an interface that is implemented by a proxy class.
* A proxy instance is an instance of a proxy class which has an associated invocation handler object.
The following is an example of dynamic proxy classes

[[File:Dynamic_proxy_class.PNG]]

==Generics==
Generics are a facility of generic programming that was added to the Java programming language in 2004 as part of J2SE 5.0. They allow "a type or method to operate on objects of various types while providing compile-time type safety." The generics can be used in classes, interfaces, methods and constructors.
===Two new types in generics===
Two new types in generics:
* Parametrized types
* Type variables

A type variable is an unqualified identifier. Class and interface declarations can have type arguments (type variables). Method and constructors definitions can have type arguments (type variables).

The following is an example for type variables

List<String> anExample = new ArrayList<String>()

* List : interface
* ArrayList : class
* String : class (the actual type argument)
* List<String> and ArrayList<String> : parametrized type

===Class/Interface Declarations===
The following is an example of class declaration:

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

==Metadata annotation==
An annotation, in the Java computer programming language, is a form of syntactic metadata that can be added to Java source code. Classes, methods, variables, parameters and packages may be annotated.

The following is an example of annotation:

/**
* Designates a formatter to pretty-print the annotated class.
*/
public @interface PrettyPrinter{
Class<? extends Formatter> value();
}
// Single-member annotation with Class
// member restricted by bounded wildcard
// The annotation presumes the existence of this class.
class GorgeousFormatterimplements Formatter { ... }
@PrettyPrinter(GorgeousFormatter.class)
public class Petunia { ... }

‘@’ indicates the start of an annotation definition.

=References=
[1] Jonathan Bartlett, "The art of metaprogramming, Part 1: Introduction to metaprogramming", 20 Oct 2005 http://www.ibm.com/developerworks/library/l-metaprog1/index.html#N10052

[2] Jonathan Bartlett, "The art of metaprogramming, Part 2: Metaprogramming using Scheme", 02 May 2006 http://www.ibm.com/developerworks/linux/library/l-metaprog2/index.html

[3] Abdelmonaim Remani, "The Art of Metaprogramming in Java", Jul 19, 2012 http://www.slideshare.net/PolymathicCoder/the-art-of-metaprogramming-in-java

[4] Mika Haapakorpi, "Meta Programming In Java"

[5] K. Czarnecki, "Generative Programming" chapter 8, Static Metaprogramming in C++

CSC/ECE 517 Spring 2013/ch1 1h jc

2013-02-19T03:30:23Z

Jrwills2: /* Metaprogramming in statically typed languages */

Metaprogramming in statically typed languages
=Metaprogramming in statically typed languages=
==Introduction==
===What is metaprogramming===

Metaprogramming refers to writing programs that can manipulate other programs or themselves. The program that is doing the manipulating is called the ''metaprogram'', and the program that is being manipulated is called the ''object program''. The language of the ''metaprogram'' is referred to as the ''metalanguage'' and the language of the object program is called the ''object language''. A language has the ability of ''reflection'' if it can be used to write a metaprogram that can manipulate a program written in the same language.

===Metaprogramming in statically typed languages===

Metaprogramming can be accomplished in both statically and dynamically typed languages. Dynamically type languages have some advantages over statically typed languages when it comes to metaprogramming.

One example of a metaprogramming task is to add a method to a particular class at runtime. Sample code in Ruby to perform this task is outlined below. First is a definition of a Ruby class called TestAddMethodAtRuntime:

class TestAddMethodAtRuntime
def originalMethod
puts "Original Method"
end
end

The code below created a new instance of the class. After that, it defines a new method called newlyAddedMethod. Then the original method is called, follow by the newly added method at runtime:

t = TestAddMethodAtRuntime.new
def t.newlyAddedMethod
puts "Newly Added Method"
end
t.originalMethod
puts "\n"
t.newlyAddedMethod

Below is the output of the code above:

Original Method
Newly Added Method

Accomplishing something like this in a statically typed language would be much more difficult or impossible depending on the language. It is for this reason that dynamically typed languages are usually viewed as being better equipped to handle metaprogramming overall.

==Implementation==
===Programming Language API===

One way that metaprogramming can be possible in a language is through an API that helps programmers achieve a metaprogramming task. An example of this is a language that provides an API for reflection. One type of reflection is ''introspection'' in which the program can access the source code of the program itself.

Below is an example from the Java API to illustrate how an API can be used to achieve some metaprogramming tasks:

import java.lang.reflect.*;
public class DumpMethods {
public static void main(String args[]) {
try {
Class c = Class.forName(args[0]);
Method m[] = c.getDeclaredMethods();
for (int i = 0; i < m.length; i++) {
System.out.println(m[i].toString());
}
}
catch (Throwable e) {
System.err.println(e);
}
}

The above example prints out all of the methods that are declared for a particular class. This is an example of metaprogramming since the program is accessing the source code of itself.

===Program transformation system===

A program transformation system is something that takes a program as the input, and outputs a different program. One example of a program transformation system is the Java compiler. The Java compiler takes a Java program as its input, and outputs a .class file with platform independent bytecode in it. Another example of a program transformation system is a Java decompiler, which takes bytecode as an input and outputs a Java program.

In the case of the Java compiler, the program input is being output into another program in a different "language". There are other types of transformation systems that take a program as an input and output a different program in the same language. One example of this would be ''program migration'' which migrates source code to a newer or older version of the same language. This can be useful if upgrading a software system to run on a newer version of a framework.

===Metaprogramming using Scheme===
==Common Uses==
===Pre-generate static data at compile time===
One common use of metaprogramming in statically typed languages is to write programs that will pre-generate tables of data for use at runtime.

One simple but useful code generator is to build static lookup tables. Often, in order to build fast functions in C programming, we simply create a lookup table of all of the answers. This means that we either need to pre-compute them by hand (which is wasteful of your time) or build them at runtime (which is wasteful of the user's time).

In following example we will build a generator that will take a function or set of functions on an integer and build lookup tables for the answer.

To think of how to make such a program, we can start from the end and work backward. Firstly we need a lookup table that will return square roots of numbers between 5 and 20. A simple program can be written to generate such a table like this:

Generate and use a lookup table of square roots

/* our lookup table */
double square_roots[21];
/* function to load the table at runtime */
void init_square_roots()
{
int i;
for(i = 5; i < 21; i++)
{
square_roots[i] = sqrt((double)i);
}
}

With that single macro, we can take away a lot of work for any program that has to generate mathematical tables indexed by integer. A little extra work would also allow tables containing full struct definitions; a little more would ensure that space isn't wasted at the front of the array with useless empty entries.
/* program that uses the table */
int main ()
{
init_square_roots();
printf("The square root of 5 is %f\n", square_roots[5]);
return 0;
}

Now, to convert this to a statically initialized array, you would remove the first part of the program and replace it with something like this, calculated by hand:

Square root program with a static lookup table

double square_roots[] = {
/* these are the ones we skipped */ 0.0, 0.0, 0.0, 0.0, 0.0
2.236068, /* Square root of 5 */
2.449490, /* Square root of 6 */
2.645751, /* Square root of 7 */
2.828427, /* Square root of 8 */
3.0, /* Square root of 9 */
...
4.472136 /* Square root of 20 */
};

What is needed is a program that will produce these values and print them out in a table like the previous one so they are loaded in at compile-time.

Code generator for the table macro

#!/usr/bin/perl
#
#tablegen.pl
#
##Puts each program line into $line
while(my $line = <>)
{
#Is this a macro invocation?
if($line =~ m/TABLE:/)
{
#If so, split it apart into its component pieces
my ($dummy, $table_name, $type, $start_idx, $end_idx, $default, $procedure) = split(m/:/, $line, 7);
#The main difference between C and Perl for mathematical expressions is that
#Perl prefixes its variables with a dollar sign, so we will add that here
$procedure =~ s/VAL/\$VAL/g;
#Print out the array declaration
print "${type} ${table_name} [] = {\n";
#Go through each array element
foreach my $VAL (0 .. $end_idx)
{
#Only process an answer if we have reached our starting index
if($VAL >= $start_idx)
{
#evaluate the procedure specified (this sets $@ if there are any errors)
$result = eval $procedure;
die("Error processing: $@") if $@;
}
else
{
#if we haven't reached the starting index, just use the default
$result = $default;
}
#Print out the value
print "\t${result}";
#If there are more to be processed, add a comma after the value
if($VAL != $end_idx)
{
print ",";
}
print "\n"
}
#Finish the declaration
print "};\n";
}
else
{
#If this is not a macro invocation, just copy the line directly to the output
print $line;
}
}

To run this program, do this:

Running the code generator

./tablegen.pl < sqrt.in > sqrt.c
gcc sqrt.c -o sqrt
./a.out

===Mini-language for boiler-plate===
If you have a large application where many of the functions include a lot of boilerplate code, it is often a good idea to create a mini-language that allows you to work with your boilerplate code in an easier fashion. This mini-language will then be converted into your regular source code language before compiling.

The following is an example:

Let's say that we are building a CGI application consisting of many independent CGI scripts. In most CGI applications, much of the state is stored in a database, but only a session ID is passed to each script via a cookie.

However, in nearly every page we need to know the other standard information (such as the username, group number, the current job being worked on, whatever else information is pertinent). In addition, we need to redirect the user if they do not have an appropriate cookie.

(define (handle-cgi-request req)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
;;Code for processing goes here
))))

While some of that can be handled by a procedure, the bindings certainly cannot. However, we can turn most of it into a macro. The macro can be implemented like this:

(define-syntax cgi-boilerplate
(lambda (x)
(syntax-case x ()
(
(cgi-boilerplate expr)
(datum->syntax-object
(syntax k)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
(syntax-object->datum (syntax expr))))))
)
)))

We can now create new forms based on our boilerplate code by doing the following:

(define (handle-cgi-request req)
(cgi-boilerplate
(begin
;;Do whatever I want here
)))

In addition, since we are not defining our variables explicitly, adding new variable definitions to our boilerplate won't affect its calling conventions, so new features can be added without having to create a whole new function.

In any large project, there are inevitably templates to follow which cannot be reduced to functions, usually because of the bindings being created. Using boilerplate macros can make maintenance of such templated code much easier.

Likewise, other standard macros can be created which make use of variables defined in the boilerplate. Using macros like this significantly reduces typing because you do not have to constantly be writing and rewriting variable bindings, derivations, and parameter passing. This also reduces the potential for errors in such code.

Realize though that boilerplate macros are not a panacea. There are many significant problems that can occur, including:
* Accidentally overwriting bindings by introducing a variable name that was previously defined in a macro.
* Difficulty tracing problems because the inputs and the outputs of the macros are implicit, not explicit.

These can be largely avoided by doing a few things in conjunction with your boilerplate macros:
* Have a naming convention which clearly labels macros as such, as well as indicate that a variable came from boilerplate code. This could be done by affixing -m to macros and -b to variables defined within a boilerplate.
* Carefully document all boilerplate macros, especially the introduced variable bindings and all changes between versions.
* Only use boilerplate macros when the savings in repetitiveness clearly outweigh the negatives of implicit functionality.

===Abbreviate statements and prevent mistakes===
A lot of programming languages make you write really verbose statements to do really simple things. Code-generating programs allow you to abbreviate such statements and save a lot of typing, which also prevents a lot of mistakes because there is less chance of mistyping.

=Metaprogramming Framework in Java=
==Reflection==
===Introduction to reflection===
Reflection is the ability to introspect metalevel information about the program structure itself at runtime. Usually this metalevel information is modeled using the general abstraction mechanisms available in the language. In Java, reflection enables to discover information about the loaded classes:
* Fields,
* Methods, and
* Constructors
* Generics information
* Metadata annotations
It also enables to use these metaobjects to their instances in runtime environment.

The following is the Java metalevel architecture

[[File:Metalevel architecture.PNG]]

===Dynamic proxy classes===
A dynamic proxy class implements a list of interfaces specified at runtime when the class is created.
* A proxy interface is an interface that is implemented by a proxy class.
* A proxy instance is an instance of a proxy class which has an associated invocation handler object.
The following is an example of dynamic proxy classes

[[File:Dynamic_proxy_class.PNG]]

==Generics==
Generics are a facility of generic programming that was added to the Java programming language in 2004 as part of J2SE 5.0. They allow "a type or method to operate on objects of various types while providing compile-time type safety." The generics can be used in classes, interfaces, methods and constructors.
===Two new types in generics===
Two new types in generics:
* Parametrized types
* Type variables

A type variable is an unqualified identifier. Class and interface declarations can have type arguments (type variables). Method and constructors definitions can have type arguments (type variables).

The following is an example for type variables

List<String> anExample = new ArrayList<String>()

* List : interface
* ArrayList : class
* String : class (the actual type argument)
* List<String> and ArrayList<String> : parametrized type

===Class/Interface Declarations===
The following is an example of class declaration:

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

==Metadata annotation==
An annotation, in the Java computer programming language, is a form of syntactic metadata that can be added to Java source code. Classes, methods, variables, parameters and packages may be annotated.

The following is an example of annotation:

/**
* Designates a formatter to pretty-print the annotated class.
*/
public @interface PrettyPrinter{
Class<? extends Formatter> value();
}
// Single-member annotation with Class
// member restricted by bounded wildcard
// The annotation presumes the existence of this class.
class GorgeousFormatterimplements Formatter { ... }
@PrettyPrinter(GorgeousFormatter.class)
public class Petunia { ... }

‘@’ indicates the start of an annotation definition.

=Limitations=

=References=
[1] Jonathan Bartlett, "The art of metaprogramming, Part 1: Introduction to metaprogramming", 20 Oct 2005 http://www.ibm.com/developerworks/library/l-metaprog1/index.html#N10052

[2] Jonathan Bartlett, "The art of metaprogramming, Part 2: Metaprogramming using Scheme", 02 May 2006 http://www.ibm.com/developerworks/linux/library/l-metaprog2/index.html

[3] Abdelmonaim Remani, "The Art of Metaprogramming in Java", Jul 19, 2012 http://www.slideshare.net/PolymathicCoder/the-art-of-metaprogramming-in-java

[4] Mika Haapakorpi, "Meta Programming In Java"

[5] K. Czarnecki, "Generative Programming" chapter 8, Static Metaprogramming in C++

CSC/ECE 517 Spring 2013/ch1 1h jc

2013-02-19T03:20:52Z

Jrwills2: /* Metaprogramming in statically typed languages */

Metaprogramming in statically typed languages
=Metaprogramming in statically typed languages=
==Introduction==
===What is metaprogramming===

Metaprogramming refers to writing programs that can manipulate other programs or themselves. The program that is doing the manipulating is called the ''metaprogram'', and the program that is being manipulated is called the ''object program''. The language of the ''metaprogram'' is referred to as the ''metalanguage'' and the language of the object program is called the ''object language''. A language has the ability of ''reflection'' if it can be used to write a metaprogram that can manipulate a program written in the same language.

===Metaprogramming in statically typed languages===

Metaprogramming can be accomplished in both statically and dynamically typed languages. Dynamically type languages have some advantages over statically typed languages when it comes to metaprogramming.

One example of a metaprogramming task is to add a method to a particular class at runtime. Sample code in Ruby to perform this task is outlined below. First is a definition of a Ruby class called TestAddMethodAtRuntime:

class TestAddMethodAtRuntime
def originalMethod
puts "Original Method"
end
end

The code below created a new instance of the class. After that, it defines a new method called newlyAddedMethod. Then the original method is called, follow by the newly added method at runtime:

t = TestAddMethodAtRuntime.new
def t.newlyAddedMethod
puts "Newly Added Method"
end
t.originalMethod
puts "\n"
t.newlyAddedMethod

Below is the output of the code above:

Original Method
Newly Added Method

==Implementation==
===Programming Language API===

One way that metaprogramming can be possible in a language is through an API that helps programmers achieve a metaprogramming task. An example of this is a language that provides an API for reflection. One type of reflection is ''introspection'' in which the program can access the source code of the program itself.

Below is an example from the Java API to illustrate how an API can be used to achieve some metaprogramming tasks:

import java.lang.reflect.*;
public class DumpMethods {
public static void main(String args[]) {
try {
Class c = Class.forName(args[0]);
Method m[] = c.getDeclaredMethods();
for (int i = 0; i < m.length; i++) {
System.out.println(m[i].toString());
}
}
catch (Throwable e) {
System.err.println(e);
}
}

The above example prints out all of the methods that are declared for a particular class. This is an example of metaprogramming since the program is accessing the source code of itself.

===Program transformation system===

A program transformation system is something that takes a program as the input, and outputs a different program. One example of a program transformation system is the Java compiler. The Java compiler takes a Java program as its input, and outputs a .class file with platform independent bytecode in it. Another example of a program transformation system is a Java decompiler, which takes bytecode as an input and outputs a Java program.

In the case of the Java compiler, the program input is being output into another program in a different "language". There are other types of transformation systems that take a program as an input and output a different program in the same language. One example of this would be ''program migration'' which migrates source code to a newer or older version of the same language. This can be useful if upgrading a software system to run on a newer version of a framework.

===Metaprogramming using Scheme===
==Common Uses==
===Pre-generate static data at compile time===
One common use of metaprogramming in statically typed languages is to write programs that will pre-generate tables of data for use at runtime.

One simple but useful code generator is to build static lookup tables. Often, in order to build fast functions in C programming, we simply create a lookup table of all of the answers. This means that we either need to pre-compute them by hand (which is wasteful of your time) or build them at runtime (which is wasteful of the user's time).

In following example we will build a generator that will take a function or set of functions on an integer and build lookup tables for the answer.

To think of how to make such a program, we can start from the end and work backward. Firstly we need a lookup table that will return square roots of numbers between 5 and 20. A simple program can be written to generate such a table like this:

Generate and use a lookup table of square roots

/* our lookup table */
double square_roots[21];
/* function to load the table at runtime */
void init_square_roots()
{
int i;
for(i = 5; i < 21; i++)
{
square_roots[i] = sqrt((double)i);
}
}

With that single macro, we can take away a lot of work for any program that has to generate mathematical tables indexed by integer. A little extra work would also allow tables containing full struct definitions; a little more would ensure that space isn't wasted at the front of the array with useless empty entries.
/* program that uses the table */
int main ()
{
init_square_roots();
printf("The square root of 5 is %f\n", square_roots[5]);
return 0;
}

Now, to convert this to a statically initialized array, you would remove the first part of the program and replace it with something like this, calculated by hand:

Square root program with a static lookup table

double square_roots[] = {
/* these are the ones we skipped */ 0.0, 0.0, 0.0, 0.0, 0.0
2.236068, /* Square root of 5 */
2.449490, /* Square root of 6 */
2.645751, /* Square root of 7 */
2.828427, /* Square root of 8 */
3.0, /* Square root of 9 */
...
4.472136 /* Square root of 20 */
};

What is needed is a program that will produce these values and print them out in a table like the previous one so they are loaded in at compile-time.

Code generator for the table macro

#!/usr/bin/perl
#
#tablegen.pl
#
##Puts each program line into $line
while(my $line = <>)
{
#Is this a macro invocation?
if($line =~ m/TABLE:/)
{
#If so, split it apart into its component pieces
my ($dummy, $table_name, $type, $start_idx, $end_idx, $default, $procedure) = split(m/:/, $line, 7);
#The main difference between C and Perl for mathematical expressions is that
#Perl prefixes its variables with a dollar sign, so we will add that here
$procedure =~ s/VAL/\$VAL/g;
#Print out the array declaration
print "${type} ${table_name} [] = {\n";
#Go through each array element
foreach my $VAL (0 .. $end_idx)
{
#Only process an answer if we have reached our starting index
if($VAL >= $start_idx)
{
#evaluate the procedure specified (this sets $@ if there are any errors)
$result = eval $procedure;
die("Error processing: $@") if $@;
}
else
{
#if we haven't reached the starting index, just use the default
$result = $default;
}
#Print out the value
print "\t${result}";
#If there are more to be processed, add a comma after the value
if($VAL != $end_idx)
{
print ",";
}
print "\n"
}
#Finish the declaration
print "};\n";
}
else
{
#If this is not a macro invocation, just copy the line directly to the output
print $line;
}
}

To run this program, do this:

Running the code generator

./tablegen.pl < sqrt.in > sqrt.c
gcc sqrt.c -o sqrt
./a.out

===Mini-language for boiler-plate===
If you have a large application where many of the functions include a lot of boilerplate code, it is often a good idea to create a mini-language that allows you to work with your boilerplate code in an easier fashion. This mini-language will then be converted into your regular source code language before compiling.

The following is an example:

Let's say that we are building a CGI application consisting of many independent CGI scripts. In most CGI applications, much of the state is stored in a database, but only a session ID is passed to each script via a cookie.

However, in nearly every page we need to know the other standard information (such as the username, group number, the current job being worked on, whatever else information is pertinent). In addition, we need to redirect the user if they do not have an appropriate cookie.

(define (handle-cgi-request req)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
;;Code for processing goes here
))))

While some of that can be handled by a procedure, the bindings certainly cannot. However, we can turn most of it into a macro. The macro can be implemented like this:

(define-syntax cgi-boilerplate
(lambda (x)
(syntax-case x ()
(
(cgi-boilerplate expr)
(datum->syntax-object
(syntax k)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
(syntax-object->datum (syntax expr))))))
)
)))

We can now create new forms based on our boilerplate code by doing the following:

(define (handle-cgi-request req)
(cgi-boilerplate
(begin
;;Do whatever I want here
)))

In addition, since we are not defining our variables explicitly, adding new variable definitions to our boilerplate won't affect its calling conventions, so new features can be added without having to create a whole new function.

In any large project, there are inevitably templates to follow which cannot be reduced to functions, usually because of the bindings being created. Using boilerplate macros can make maintenance of such templated code much easier.

Likewise, other standard macros can be created which make use of variables defined in the boilerplate. Using macros like this significantly reduces typing because you do not have to constantly be writing and rewriting variable bindings, derivations, and parameter passing. This also reduces the potential for errors in such code.

Realize though that boilerplate macros are not a panacea. There are many significant problems that can occur, including:
* Accidentally overwriting bindings by introducing a variable name that was previously defined in a macro.
* Difficulty tracing problems because the inputs and the outputs of the macros are implicit, not explicit.

These can be largely avoided by doing a few things in conjunction with your boilerplate macros:
* Have a naming convention which clearly labels macros as such, as well as indicate that a variable came from boilerplate code. This could be done by affixing -m to macros and -b to variables defined within a boilerplate.
* Carefully document all boilerplate macros, especially the introduced variable bindings and all changes between versions.
* Only use boilerplate macros when the savings in repetitiveness clearly outweigh the negatives of implicit functionality.

===Abbreviate statements and prevent mistakes===
A lot of programming languages make you write really verbose statements to do really simple things. Code-generating programs allow you to abbreviate such statements and save a lot of typing, which also prevents a lot of mistakes because there is less chance of mistyping.

=Metaprogramming Framework in Java=
==Reflection==
===Introduction to reflection===
Reflection is the ability to introspect metalevel information about the program structure itself at runtime. Usually this metalevel information is modeled using the general abstraction mechanisms available in the language. In Java, reflection enables to discover information about the loaded classes:
* Fields,
* Methods, and
* Constructors
* Generics information
* Metadata annotations
It also enables to use these metaobjects to their instances in runtime environment.

The following is the Java metalevel architecture

[[File:Metalevel architecture.PNG]]

===Dynamic proxy classes===
A dynamic proxy class implements a list of interfaces specified at runtime when the class is created.
* A proxy interface is an interface that is implemented by a proxy class.
* A proxy instance is an instance of a proxy class which has an associated invocation handler object.
The following is an example of dynamic proxy classes

[[File:Dynamic_proxy_class.PNG]]

==Generics==
Generics are a facility of generic programming that was added to the Java programming language in 2004 as part of J2SE 5.0. They allow "a type or method to operate on objects of various types while providing compile-time type safety." The generics can be used in classes, interfaces, methods and constructors.
===Two new types in generics===
Two new types in generics:
* Parametrized types
* Type variables

A type variable is an unqualified identifier. Class and interface declarations can have type arguments (type variables). Method and constructors definitions can have type arguments (type variables).

The following is an example for type variables

List<String> anExample = new ArrayList<String>()

* List : interface
* ArrayList : class
* String : class (the actual type argument)
* List<String> and ArrayList<String> : parametrized type

===Class/Interface Declarations===
The following is an example of class declaration:

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

==Metadata annotation==
An annotation, in the Java computer programming language, is a form of syntactic metadata that can be added to Java source code. Classes, methods, variables, parameters and packages may be annotated.

The following is an example of annotation:

/**
* Designates a formatter to pretty-print the annotated class.
*/
public @interface PrettyPrinter{
Class<? extends Formatter> value();
}
// Single-member annotation with Class
// member restricted by bounded wildcard
// The annotation presumes the existence of this class.
class GorgeousFormatterimplements Formatter { ... }
@PrettyPrinter(GorgeousFormatter.class)
public class Petunia { ... }

‘@’ indicates the start of an annotation definition.

=Limitations=

=References=
[1] Jonathan Bartlett, "The art of metaprogramming, Part 1: Introduction to metaprogramming", 20 Oct 2005 http://www.ibm.com/developerworks/library/l-metaprog1/index.html#N10052

[2] Jonathan Bartlett, "The art of metaprogramming, Part 2: Metaprogramming using Scheme", 02 May 2006 http://www.ibm.com/developerworks/linux/library/l-metaprog2/index.html

[3] Abdelmonaim Remani, "The Art of Metaprogramming in Java", Jul 19, 2012 http://www.slideshare.net/PolymathicCoder/the-art-of-metaprogramming-in-java

[4] Mika Haapakorpi, "Meta Programming In Java"

[5] K. Czarnecki, "Generative Programming" chapter 8, Static Metaprogramming in C++

CSC/ECE 517 Spring 2013/ch1 1h jc

2013-02-19T03:12:59Z

Jrwills2: /* Metaprogramming in statically typed languages */

Metaprogramming in statically typed languages
=Metaprogramming in statically typed languages=
==Introduction==
===What is metaprogramming===

Metaprogramming refers to writing programs that can manipulate other programs or themselves. The program that is doing the manipulating is called the ''metaprogram'', and the program that is being manipulated is called the ''object program''. The language of the ''metaprogram'' is referred to as the ''metalanguage'' and the language of the object program is called the ''object language''. A language has the ability of ''reflection'' if it can be used to write a metaprogram that can manipulate a program written in the same language.

===Metaprogramming in statically typed languages===

Metaprogramming can be accomplished in both statically and dynamically typed languages. Dynamically type languages have some advantages over statically typed languages when it comes to metaprogramming.

One example of a metaprogramming task is to add a method to a particular class at runtime. Below is the sample code in Ruby to perform this task:

class TestAddMethodAtRuntime
def originalMethod
puts "Original Method"
end
end

t = TestAddMethodAtRuntime.new

def t.newlyAddedMethod
puts "Newly Added Method"
end

t.originalMethod
puts "\n"
t.newlyAddedMethod

==Implementation==
===Programming Language API===

One way that metaprogramming can be possible in a language is through an API that helps programmers achieve a metaprogramming task. An example of this is a language that provides an API for reflection. One type of reflection is ''introspection'' in which the program can access the source code of the program itself.

Below is an example from the Java API to illustrate how an API can be used to achieve some metaprogramming tasks:

import java.lang.reflect.*;
public class DumpMethods {
public static void main(String args[]) {
try {
Class c = Class.forName(args[0]);
Method m[] = c.getDeclaredMethods();
for (int i = 0; i < m.length; i++) {
System.out.println(m[i].toString());
}
}
catch (Throwable e) {
System.err.println(e);
}
}

The above example prints out all of the methods that are declared for a particular class. This is an example of metaprogramming since the program is accessing the source code of itself.

===Program transformation system===

A program transformation system is something that takes a program as the input, and outputs a different program. One example of a program transformation system is the Java compiler. The Java compiler takes a Java program as its input, and outputs a .class file with platform independent bytecode in it. Another example of a program transformation system is a Java decompiler, which takes bytecode as an input and outputs a Java program.

In the case of the Java compiler, the program input is being output into another program in a different "language". There are other types of transformation systems that take a program as an input and output a different program in the same language. One example of this would be ''program migration'' which migrates source code to a newer or older version of the same language. This can be useful if upgrading a software system to run on a newer version of a framework.

===Metaprogramming using Scheme===
==Common Uses==
===Pre-generate static data at compile time===
One common use of metaprogramming in statically typed languages is to write programs that will pre-generate tables of data for use at runtime.

One simple but useful code generator is to build static lookup tables. Often, in order to build fast functions in C programming, we simply create a lookup table of all of the answers. This means that we either need to pre-compute them by hand (which is wasteful of your time) or build them at runtime (which is wasteful of the user's time).

In following example we will build a generator that will take a function or set of functions on an integer and build lookup tables for the answer.

To think of how to make such a program, we can start from the end and work backward. Firstly we need a lookup table that will return square roots of numbers between 5 and 20. A simple program can be written to generate such a table like this:

Generate and use a lookup table of square roots

/* our lookup table */
double square_roots[21];
/* function to load the table at runtime */
void init_square_roots()
{
int i;
for(i = 5; i < 21; i++)
{
square_roots[i] = sqrt((double)i);
}
}

With that single macro, we can take away a lot of work for any program that has to generate mathematical tables indexed by integer. A little extra work would also allow tables containing full struct definitions; a little more would ensure that space isn't wasted at the front of the array with useless empty entries.
/* program that uses the table */
int main ()
{
init_square_roots();
printf("The square root of 5 is %f\n", square_roots[5]);
return 0;
}

Now, to convert this to a statically initialized array, you would remove the first part of the program and replace it with something like this, calculated by hand:

Square root program with a static lookup table

double square_roots[] = {
/* these are the ones we skipped */ 0.0, 0.0, 0.0, 0.0, 0.0
2.236068, /* Square root of 5 */
2.449490, /* Square root of 6 */
2.645751, /* Square root of 7 */
2.828427, /* Square root of 8 */
3.0, /* Square root of 9 */
...
4.472136 /* Square root of 20 */
};

What is needed is a program that will produce these values and print them out in a table like the previous one so they are loaded in at compile-time.

Code generator for the table macro

#!/usr/bin/perl
#
#tablegen.pl
#
##Puts each program line into $line
while(my $line = <>)
{
#Is this a macro invocation?
if($line =~ m/TABLE:/)
{
#If so, split it apart into its component pieces
my ($dummy, $table_name, $type, $start_idx, $end_idx, $default, $procedure) = split(m/:/, $line, 7);
#The main difference between C and Perl for mathematical expressions is that
#Perl prefixes its variables with a dollar sign, so we will add that here
$procedure =~ s/VAL/\$VAL/g;
#Print out the array declaration
print "${type} ${table_name} [] = {\n";
#Go through each array element
foreach my $VAL (0 .. $end_idx)
{
#Only process an answer if we have reached our starting index
if($VAL >= $start_idx)
{
#evaluate the procedure specified (this sets $@ if there are any errors)
$result = eval $procedure;
die("Error processing: $@") if $@;
}
else
{
#if we haven't reached the starting index, just use the default
$result = $default;
}
#Print out the value
print "\t${result}";
#If there are more to be processed, add a comma after the value
if($VAL != $end_idx)
{
print ",";
}
print "\n"
}
#Finish the declaration
print "};\n";
}
else
{
#If this is not a macro invocation, just copy the line directly to the output
print $line;
}
}

To run this program, do this:

Running the code generator

./tablegen.pl < sqrt.in > sqrt.c
gcc sqrt.c -o sqrt
./a.out

===Mini-language for boiler-plate===
If you have a large application where many of the functions include a lot of boilerplate code, it is often a good idea to create a mini-language that allows you to work with your boilerplate code in an easier fashion. This mini-language will then be converted into your regular source code language before compiling.

The following is an example:

Let's say that we are building a CGI application consisting of many independent CGI scripts. In most CGI applications, much of the state is stored in a database, but only a session ID is passed to each script via a cookie.

However, in nearly every page we need to know the other standard information (such as the username, group number, the current job being worked on, whatever else information is pertinent). In addition, we need to redirect the user if they do not have an appropriate cookie.

(define (handle-cgi-request req)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
;;Code for processing goes here
))))

While some of that can be handled by a procedure, the bindings certainly cannot. However, we can turn most of it into a macro. The macro can be implemented like this:

(define-syntax cgi-boilerplate
(lambda (x)
(syntax-case x ()
(
(cgi-boilerplate expr)
(datum->syntax-object
(syntax k)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
(syntax-object->datum (syntax expr))))))
)
)))

We can now create new forms based on our boilerplate code by doing the following:

(define (handle-cgi-request req)
(cgi-boilerplate
(begin
;;Do whatever I want here
)))

In addition, since we are not defining our variables explicitly, adding new variable definitions to our boilerplate won't affect its calling conventions, so new features can be added without having to create a whole new function.

In any large project, there are inevitably templates to follow which cannot be reduced to functions, usually because of the bindings being created. Using boilerplate macros can make maintenance of such templated code much easier.

Likewise, other standard macros can be created which make use of variables defined in the boilerplate. Using macros like this significantly reduces typing because you do not have to constantly be writing and rewriting variable bindings, derivations, and parameter passing. This also reduces the potential for errors in such code.

Realize though that boilerplate macros are not a panacea. There are many significant problems that can occur, including:
* Accidentally overwriting bindings by introducing a variable name that was previously defined in a macro.
* Difficulty tracing problems because the inputs and the outputs of the macros are implicit, not explicit.

These can be largely avoided by doing a few things in conjunction with your boilerplate macros:
* Have a naming convention which clearly labels macros as such, as well as indicate that a variable came from boilerplate code. This could be done by affixing -m to macros and -b to variables defined within a boilerplate.
* Carefully document all boilerplate macros, especially the introduced variable bindings and all changes between versions.
* Only use boilerplate macros when the savings in repetitiveness clearly outweigh the negatives of implicit functionality.

===Abbreviate statements and prevent mistakes===
A lot of programming languages make you write really verbose statements to do really simple things. Code-generating programs allow you to abbreviate such statements and save a lot of typing, which also prevents a lot of mistakes because there is less chance of mistyping.

=Metaprogramming Framework in Java=
==Reflection==
===Introduction to reflection===
Reflection is the ability to introspect metalevel information about the program structure itself at runtime. Usually this metalevel information is modeled using the general abstraction mechanisms available in the language. In Java, reflection enables to discover information about the loaded classes:
* Fields,
* Methods, and
* Constructors
* Generics information
* Metadata annotations
It also enables to use these metaobjects to their instances in runtime environment.

The following is the Java metalevel architecture

[[File:Metalevel architecture.PNG]]

===Dynamic proxy classes===
A dynamic proxy class implements a list of interfaces specified at runtime when the class is created.
* A proxy interface is an interface that is implemented by a proxy class.
* A proxy instance is an instance of a proxy class which has an associated invocation handler object.
The following is an example of dynamic proxy classes

[[File:Dynamic_proxy_class.PNG]]

==Generics==
Generics are a facility of generic programming that was added to the Java programming language in 2004 as part of J2SE 5.0. They allow "a type or method to operate on objects of various types while providing compile-time type safety." The generics can be used in classes, interfaces, methods and constructors.
===Two new types in generics===
Two new types in generics:
* Parametrized types
* Type variables

A type variable is an unqualified identifier. Class and interface declarations can have type arguments (type variables). Method and constructors definitions can have type arguments (type variables).

The following is an example for type variables

List<String> anExample = new ArrayList<String>()

* List : interface
* ArrayList : class
* String : class (the actual type argument)
* List<String> and ArrayList<String> : parametrized type

===Class/Interface Declarations===
The following is an example of class declaration:

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

==Metadata annotation==
An annotation, in the Java computer programming language, is a form of syntactic metadata that can be added to Java source code. Classes, methods, variables, parameters and packages may be annotated.

The following is an example of annotation:

/**
* Designates a formatter to pretty-print the annotated class.
*/
public @interface PrettyPrinter{
Class<? extends Formatter> value();
}
// Single-member annotation with Class
// member restricted by bounded wildcard
// The annotation presumes the existence of this class.
class GorgeousFormatterimplements Formatter { ... }
@PrettyPrinter(GorgeousFormatter.class)
public class Petunia { ... }

‘@’ indicates the start of an annotation definition.

=Limitations=

=References=
[1] Jonathan Bartlett, "The art of metaprogramming, Part 1: Introduction to metaprogramming", 20 Oct 2005 http://www.ibm.com/developerworks/library/l-metaprog1/index.html#N10052

[2] Jonathan Bartlett, "The art of metaprogramming, Part 2: Metaprogramming using Scheme", 02 May 2006 http://www.ibm.com/developerworks/linux/library/l-metaprog2/index.html

[3] Abdelmonaim Remani, "The Art of Metaprogramming in Java", Jul 19, 2012 http://www.slideshare.net/PolymathicCoder/the-art-of-metaprogramming-in-java

[4] Mika Haapakorpi, "Meta Programming In Java"

[5] K. Czarnecki, "Generative Programming" chapter 8, Static Metaprogramming in C++

CSC/ECE 517 Spring 2013/ch1 1h jc

2013-02-19T03:12:34Z

Jrwills2: /* Metaprogramming in statically typed languages */

Metaprogramming in statically typed languages
=Metaprogramming in statically typed languages=
==Introduction==
===What is metaprogramming===

Metaprogramming refers to writing programs that can manipulate other programs or themselves. The program that is doing the manipulating is called the ''metaprogram'', and the program that is being manipulated is called the ''object program''. The language of the ''metaprogram'' is referred to as the ''metalanguage'' and the language of the object program is called the ''object language''. A language has the ability of ''reflection'' if it can be used to write a metaprogram that can manipulate a program written in the same language.

===Metaprogramming in statically typed languages===

Metaprogramming can be accomplished in both statically and dynamically typed languages. Dynamically type languages have some advantages over statically typed languages when it comes to metaprogramming.

One example of a metaprogramming task is to add a method to a particular class at runtime. Below is the sample code in Ruby to perform this task:

class TestAddMethodAtRuntime
def originalMethod
puts "Original Method"
end
end
t = TestAddMethodAtRuntime.new

def t.newlyAddedMethod
puts "Newly Added Method"
end

t.originalMethod
puts "\n"
t.newlyAddedMethod

==Implementation==
===Programming Language API===

One way that metaprogramming can be possible in a language is through an API that helps programmers achieve a metaprogramming task. An example of this is a language that provides an API for reflection. One type of reflection is ''introspection'' in which the program can access the source code of the program itself.

Below is an example from the Java API to illustrate how an API can be used to achieve some metaprogramming tasks:

import java.lang.reflect.*;
public class DumpMethods {
public static void main(String args[]) {
try {
Class c = Class.forName(args[0]);
Method m[] = c.getDeclaredMethods();
for (int i = 0; i < m.length; i++) {
System.out.println(m[i].toString());
}
}
catch (Throwable e) {
System.err.println(e);
}
}

The above example prints out all of the methods that are declared for a particular class. This is an example of metaprogramming since the program is accessing the source code of itself.

===Program transformation system===

A program transformation system is something that takes a program as the input, and outputs a different program. One example of a program transformation system is the Java compiler. The Java compiler takes a Java program as its input, and outputs a .class file with platform independent bytecode in it. Another example of a program transformation system is a Java decompiler, which takes bytecode as an input and outputs a Java program.

In the case of the Java compiler, the program input is being output into another program in a different "language". There are other types of transformation systems that take a program as an input and output a different program in the same language. One example of this would be ''program migration'' which migrates source code to a newer or older version of the same language. This can be useful if upgrading a software system to run on a newer version of a framework.

===Metaprogramming using Scheme===
==Common Uses==
===Pre-generate static data at compile time===
One common use of metaprogramming in statically typed languages is to write programs that will pre-generate tables of data for use at runtime.

One simple but useful code generator is to build static lookup tables. Often, in order to build fast functions in C programming, we simply create a lookup table of all of the answers. This means that we either need to pre-compute them by hand (which is wasteful of your time) or build them at runtime (which is wasteful of the user's time).

In following example we will build a generator that will take a function or set of functions on an integer and build lookup tables for the answer.

To think of how to make such a program, we can start from the end and work backward. Firstly we need a lookup table that will return square roots of numbers between 5 and 20. A simple program can be written to generate such a table like this:

Generate and use a lookup table of square roots

/* our lookup table */
double square_roots[21];
/* function to load the table at runtime */
void init_square_roots()
{
int i;
for(i = 5; i < 21; i++)
{
square_roots[i] = sqrt((double)i);
}
}

With that single macro, we can take away a lot of work for any program that has to generate mathematical tables indexed by integer. A little extra work would also allow tables containing full struct definitions; a little more would ensure that space isn't wasted at the front of the array with useless empty entries.
/* program that uses the table */
int main ()
{
init_square_roots();
printf("The square root of 5 is %f\n", square_roots[5]);
return 0;
}

Now, to convert this to a statically initialized array, you would remove the first part of the program and replace it with something like this, calculated by hand:

Square root program with a static lookup table

double square_roots[] = {
/* these are the ones we skipped */ 0.0, 0.0, 0.0, 0.0, 0.0
2.236068, /* Square root of 5 */
2.449490, /* Square root of 6 */
2.645751, /* Square root of 7 */
2.828427, /* Square root of 8 */
3.0, /* Square root of 9 */
...
4.472136 /* Square root of 20 */
};

What is needed is a program that will produce these values and print them out in a table like the previous one so they are loaded in at compile-time.

Code generator for the table macro

#!/usr/bin/perl
#
#tablegen.pl
#
##Puts each program line into $line
while(my $line = <>)
{
#Is this a macro invocation?
if($line =~ m/TABLE:/)
{
#If so, split it apart into its component pieces
my ($dummy, $table_name, $type, $start_idx, $end_idx, $default, $procedure) = split(m/:/, $line, 7);
#The main difference between C and Perl for mathematical expressions is that
#Perl prefixes its variables with a dollar sign, so we will add that here
$procedure =~ s/VAL/\$VAL/g;
#Print out the array declaration
print "${type} ${table_name} [] = {\n";
#Go through each array element
foreach my $VAL (0 .. $end_idx)
{
#Only process an answer if we have reached our starting index
if($VAL >= $start_idx)
{
#evaluate the procedure specified (this sets $@ if there are any errors)
$result = eval $procedure;
die("Error processing: $@") if $@;
}
else
{
#if we haven't reached the starting index, just use the default
$result = $default;
}
#Print out the value
print "\t${result}";
#If there are more to be processed, add a comma after the value
if($VAL != $end_idx)
{
print ",";
}
print "\n"
}
#Finish the declaration
print "};\n";
}
else
{
#If this is not a macro invocation, just copy the line directly to the output
print $line;
}
}

To run this program, do this:

Running the code generator

./tablegen.pl < sqrt.in > sqrt.c
gcc sqrt.c -o sqrt
./a.out

===Mini-language for boiler-plate===
If you have a large application where many of the functions include a lot of boilerplate code, it is often a good idea to create a mini-language that allows you to work with your boilerplate code in an easier fashion. This mini-language will then be converted into your regular source code language before compiling.

The following is an example:

Let's say that we are building a CGI application consisting of many independent CGI scripts. In most CGI applications, much of the state is stored in a database, but only a session ID is passed to each script via a cookie.

However, in nearly every page we need to know the other standard information (such as the username, group number, the current job being worked on, whatever else information is pertinent). In addition, we need to redirect the user if they do not have an appropriate cookie.

(define (handle-cgi-request req)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
;;Code for processing goes here
))))

While some of that can be handled by a procedure, the bindings certainly cannot. However, we can turn most of it into a macro. The macro can be implemented like this:

(define-syntax cgi-boilerplate
(lambda (x)
(syntax-case x ()
(
(cgi-boilerplate expr)
(datum->syntax-object
(syntax k)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
(syntax-object->datum (syntax expr))))))
)
)))

We can now create new forms based on our boilerplate code by doing the following:

(define (handle-cgi-request req)
(cgi-boilerplate
(begin
;;Do whatever I want here
)))

In addition, since we are not defining our variables explicitly, adding new variable definitions to our boilerplate won't affect its calling conventions, so new features can be added without having to create a whole new function.

In any large project, there are inevitably templates to follow which cannot be reduced to functions, usually because of the bindings being created. Using boilerplate macros can make maintenance of such templated code much easier.

Likewise, other standard macros can be created which make use of variables defined in the boilerplate. Using macros like this significantly reduces typing because you do not have to constantly be writing and rewriting variable bindings, derivations, and parameter passing. This also reduces the potential for errors in such code.

Realize though that boilerplate macros are not a panacea. There are many significant problems that can occur, including:
* Accidentally overwriting bindings by introducing a variable name that was previously defined in a macro.
* Difficulty tracing problems because the inputs and the outputs of the macros are implicit, not explicit.

These can be largely avoided by doing a few things in conjunction with your boilerplate macros:
* Have a naming convention which clearly labels macros as such, as well as indicate that a variable came from boilerplate code. This could be done by affixing -m to macros and -b to variables defined within a boilerplate.
* Carefully document all boilerplate macros, especially the introduced variable bindings and all changes between versions.
* Only use boilerplate macros when the savings in repetitiveness clearly outweigh the negatives of implicit functionality.

===Abbreviate statements and prevent mistakes===
A lot of programming languages make you write really verbose statements to do really simple things. Code-generating programs allow you to abbreviate such statements and save a lot of typing, which also prevents a lot of mistakes because there is less chance of mistyping.

=Metaprogramming Framework in Java=
==Reflection==
===Introduction to reflection===
Reflection is the ability to introspect metalevel information about the program structure itself at runtime. Usually this metalevel information is modeled using the general abstraction mechanisms available in the language. In Java, reflection enables to discover information about the loaded classes:
* Fields,
* Methods, and
* Constructors
* Generics information
* Metadata annotations
It also enables to use these metaobjects to their instances in runtime environment.

The following is the Java metalevel architecture

[[File:Metalevel architecture.PNG]]

===Dynamic proxy classes===
A dynamic proxy class implements a list of interfaces specified at runtime when the class is created.
* A proxy interface is an interface that is implemented by a proxy class.
* A proxy instance is an instance of a proxy class which has an associated invocation handler object.
The following is an example of dynamic proxy classes

[[File:Dynamic_proxy_class.PNG]]

==Generics==
Generics are a facility of generic programming that was added to the Java programming language in 2004 as part of J2SE 5.0. They allow "a type or method to operate on objects of various types while providing compile-time type safety." The generics can be used in classes, interfaces, methods and constructors.
===Two new types in generics===
Two new types in generics:
* Parametrized types
* Type variables

A type variable is an unqualified identifier. Class and interface declarations can have type arguments (type variables). Method and constructors definitions can have type arguments (type variables).

The following is an example for type variables

List<String> anExample = new ArrayList<String>()

* List : interface
* ArrayList : class
* String : class (the actual type argument)
* List<String> and ArrayList<String> : parametrized type

===Class/Interface Declarations===
The following is an example of class declaration:

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

==Metadata annotation==
An annotation, in the Java computer programming language, is a form of syntactic metadata that can be added to Java source code. Classes, methods, variables, parameters and packages may be annotated.

The following is an example of annotation:

/**
* Designates a formatter to pretty-print the annotated class.
*/
public @interface PrettyPrinter{
Class<? extends Formatter> value();
}
// Single-member annotation with Class
// member restricted by bounded wildcard
// The annotation presumes the existence of this class.
class GorgeousFormatterimplements Formatter { ... }
@PrettyPrinter(GorgeousFormatter.class)
public class Petunia { ... }

‘@’ indicates the start of an annotation definition.

=Limitations=

=References=
[1] Jonathan Bartlett, "The art of metaprogramming, Part 1: Introduction to metaprogramming", 20 Oct 2005 http://www.ibm.com/developerworks/library/l-metaprog1/index.html#N10052

[2] Jonathan Bartlett, "The art of metaprogramming, Part 2: Metaprogramming using Scheme", 02 May 2006 http://www.ibm.com/developerworks/linux/library/l-metaprog2/index.html

[3] Abdelmonaim Remani, "The Art of Metaprogramming in Java", Jul 19, 2012 http://www.slideshare.net/PolymathicCoder/the-art-of-metaprogramming-in-java

[4] Mika Haapakorpi, "Meta Programming In Java"

[5] K. Czarnecki, "Generative Programming" chapter 8, Static Metaprogramming in C++

CSC/ECE 517 Spring 2013/ch1 1h jc

2013-02-19T03:12:07Z

Jrwills2: /* Metaprogramming in statically typed languages */

Metaprogramming in statically typed languages
=Metaprogramming in statically typed languages=
==Introduction==
===What is metaprogramming===

Metaprogramming refers to writing programs that can manipulate other programs or themselves. The program that is doing the manipulating is called the ''metaprogram'', and the program that is being manipulated is called the ''object program''. The language of the ''metaprogram'' is referred to as the ''metalanguage'' and the language of the object program is called the ''object language''. A language has the ability of ''reflection'' if it can be used to write a metaprogram that can manipulate a program written in the same language.

===Metaprogramming in statically typed languages===

Metaprogramming can be accomplished in both statically and dynamically typed languages. Dynamically type languages have some advantages over statically typed languages when it comes to metaprogramming.

One example of a metaprogramming task is to add a method to a particular class at runtime. Below is the sample code in Ruby to perform this task:

class TestAddMethodAtRuntime
def originalMethod
puts "Original Method"
end
end

t = TestAddMethodAtRuntime.new

def t.newlyAddedMethod
puts "Newly Added Method"
end

t.originalMethod
puts "\n"
t.newlyAddedMethod

==Implementation==
===Programming Language API===

One way that metaprogramming can be possible in a language is through an API that helps programmers achieve a metaprogramming task. An example of this is a language that provides an API for reflection. One type of reflection is ''introspection'' in which the program can access the source code of the program itself.

Below is an example from the Java API to illustrate how an API can be used to achieve some metaprogramming tasks:

import java.lang.reflect.*;
public class DumpMethods {
public static void main(String args[]) {
try {
Class c = Class.forName(args[0]);
Method m[] = c.getDeclaredMethods();
for (int i = 0; i < m.length; i++) {
System.out.println(m[i].toString());
}
}
catch (Throwable e) {
System.err.println(e);
}
}

The above example prints out all of the methods that are declared for a particular class. This is an example of metaprogramming since the program is accessing the source code of itself.

===Program transformation system===

A program transformation system is something that takes a program as the input, and outputs a different program. One example of a program transformation system is the Java compiler. The Java compiler takes a Java program as its input, and outputs a .class file with platform independent bytecode in it. Another example of a program transformation system is a Java decompiler, which takes bytecode as an input and outputs a Java program.

In the case of the Java compiler, the program input is being output into another program in a different "language". There are other types of transformation systems that take a program as an input and output a different program in the same language. One example of this would be ''program migration'' which migrates source code to a newer or older version of the same language. This can be useful if upgrading a software system to run on a newer version of a framework.

===Metaprogramming using Scheme===
==Common Uses==
===Pre-generate static data at compile time===
One common use of metaprogramming in statically typed languages is to write programs that will pre-generate tables of data for use at runtime.

One simple but useful code generator is to build static lookup tables. Often, in order to build fast functions in C programming, we simply create a lookup table of all of the answers. This means that we either need to pre-compute them by hand (which is wasteful of your time) or build them at runtime (which is wasteful of the user's time).

In following example we will build a generator that will take a function or set of functions on an integer and build lookup tables for the answer.

To think of how to make such a program, we can start from the end and work backward. Firstly we need a lookup table that will return square roots of numbers between 5 and 20. A simple program can be written to generate such a table like this:

Generate and use a lookup table of square roots

/* our lookup table */
double square_roots[21];
/* function to load the table at runtime */
void init_square_roots()
{
int i;
for(i = 5; i < 21; i++)
{
square_roots[i] = sqrt((double)i);
}
}

With that single macro, we can take away a lot of work for any program that has to generate mathematical tables indexed by integer. A little extra work would also allow tables containing full struct definitions; a little more would ensure that space isn't wasted at the front of the array with useless empty entries.
/* program that uses the table */
int main ()
{
init_square_roots();
printf("The square root of 5 is %f\n", square_roots[5]);
return 0;
}

Now, to convert this to a statically initialized array, you would remove the first part of the program and replace it with something like this, calculated by hand:

Square root program with a static lookup table

double square_roots[] = {
/* these are the ones we skipped */ 0.0, 0.0, 0.0, 0.0, 0.0
2.236068, /* Square root of 5 */
2.449490, /* Square root of 6 */
2.645751, /* Square root of 7 */
2.828427, /* Square root of 8 */
3.0, /* Square root of 9 */
...
4.472136 /* Square root of 20 */
};

What is needed is a program that will produce these values and print them out in a table like the previous one so they are loaded in at compile-time.

Code generator for the table macro

#!/usr/bin/perl
#
#tablegen.pl
#
##Puts each program line into $line
while(my $line = <>)
{
#Is this a macro invocation?
if($line =~ m/TABLE:/)
{
#If so, split it apart into its component pieces
my ($dummy, $table_name, $type, $start_idx, $end_idx, $default, $procedure) = split(m/:/, $line, 7);
#The main difference between C and Perl for mathematical expressions is that
#Perl prefixes its variables with a dollar sign, so we will add that here
$procedure =~ s/VAL/\$VAL/g;
#Print out the array declaration
print "${type} ${table_name} [] = {\n";
#Go through each array element
foreach my $VAL (0 .. $end_idx)
{
#Only process an answer if we have reached our starting index
if($VAL >= $start_idx)
{
#evaluate the procedure specified (this sets $@ if there are any errors)
$result = eval $procedure;
die("Error processing: $@") if $@;
}
else
{
#if we haven't reached the starting index, just use the default
$result = $default;
}
#Print out the value
print "\t${result}";
#If there are more to be processed, add a comma after the value
if($VAL != $end_idx)
{
print ",";
}
print "\n"
}
#Finish the declaration
print "};\n";
}
else
{
#If this is not a macro invocation, just copy the line directly to the output
print $line;
}
}

To run this program, do this:

Running the code generator

./tablegen.pl < sqrt.in > sqrt.c
gcc sqrt.c -o sqrt
./a.out

===Mini-language for boiler-plate===
If you have a large application where many of the functions include a lot of boilerplate code, it is often a good idea to create a mini-language that allows you to work with your boilerplate code in an easier fashion. This mini-language will then be converted into your regular source code language before compiling.

The following is an example:

Let's say that we are building a CGI application consisting of many independent CGI scripts. In most CGI applications, much of the state is stored in a database, but only a session ID is passed to each script via a cookie.

However, in nearly every page we need to know the other standard information (such as the username, group number, the current job being worked on, whatever else information is pertinent). In addition, we need to redirect the user if they do not have an appropriate cookie.

(define (handle-cgi-request req)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
;;Code for processing goes here
))))

While some of that can be handled by a procedure, the bindings certainly cannot. However, we can turn most of it into a macro. The macro can be implemented like this:

(define-syntax cgi-boilerplate
(lambda (x)
(syntax-case x ()
(
(cgi-boilerplate expr)
(datum->syntax-object
(syntax k)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
(syntax-object->datum (syntax expr))))))
)
)))

We can now create new forms based on our boilerplate code by doing the following:

(define (handle-cgi-request req)
(cgi-boilerplate
(begin
;;Do whatever I want here
)))

In addition, since we are not defining our variables explicitly, adding new variable definitions to our boilerplate won't affect its calling conventions, so new features can be added without having to create a whole new function.

In any large project, there are inevitably templates to follow which cannot be reduced to functions, usually because of the bindings being created. Using boilerplate macros can make maintenance of such templated code much easier.

Likewise, other standard macros can be created which make use of variables defined in the boilerplate. Using macros like this significantly reduces typing because you do not have to constantly be writing and rewriting variable bindings, derivations, and parameter passing. This also reduces the potential for errors in such code.

Realize though that boilerplate macros are not a panacea. There are many significant problems that can occur, including:
* Accidentally overwriting bindings by introducing a variable name that was previously defined in a macro.
* Difficulty tracing problems because the inputs and the outputs of the macros are implicit, not explicit.

These can be largely avoided by doing a few things in conjunction with your boilerplate macros:
* Have a naming convention which clearly labels macros as such, as well as indicate that a variable came from boilerplate code. This could be done by affixing -m to macros and -b to variables defined within a boilerplate.
* Carefully document all boilerplate macros, especially the introduced variable bindings and all changes between versions.
* Only use boilerplate macros when the savings in repetitiveness clearly outweigh the negatives of implicit functionality.

===Abbreviate statements and prevent mistakes===
A lot of programming languages make you write really verbose statements to do really simple things. Code-generating programs allow you to abbreviate such statements and save a lot of typing, which also prevents a lot of mistakes because there is less chance of mistyping.

=Metaprogramming Framework in Java=
==Reflection==
===Introduction to reflection===
Reflection is the ability to introspect metalevel information about the program structure itself at runtime. Usually this metalevel information is modeled using the general abstraction mechanisms available in the language. In Java, reflection enables to discover information about the loaded classes:
* Fields,
* Methods, and
* Constructors
* Generics information
* Metadata annotations
It also enables to use these metaobjects to their instances in runtime environment.

The following is the Java metalevel architecture

[[File:Metalevel architecture.PNG]]

===Dynamic proxy classes===
A dynamic proxy class implements a list of interfaces specified at runtime when the class is created.
* A proxy interface is an interface that is implemented by a proxy class.
* A proxy instance is an instance of a proxy class which has an associated invocation handler object.
The following is an example of dynamic proxy classes

[[File:Dynamic_proxy_class.PNG]]

==Generics==
Generics are a facility of generic programming that was added to the Java programming language in 2004 as part of J2SE 5.0. They allow "a type or method to operate on objects of various types while providing compile-time type safety." The generics can be used in classes, interfaces, methods and constructors.
===Two new types in generics===
Two new types in generics:
* Parametrized types
* Type variables

A type variable is an unqualified identifier. Class and interface declarations can have type arguments (type variables). Method and constructors definitions can have type arguments (type variables).

The following is an example for type variables

List<String> anExample = new ArrayList<String>()

* List : interface
* ArrayList : class
* String : class (the actual type argument)
* List<String> and ArrayList<String> : parametrized type

===Class/Interface Declarations===
The following is an example of class declaration:

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

==Metadata annotation==
An annotation, in the Java computer programming language, is a form of syntactic metadata that can be added to Java source code. Classes, methods, variables, parameters and packages may be annotated.

The following is an example of annotation:

/**
* Designates a formatter to pretty-print the annotated class.
*/
public @interface PrettyPrinter{
Class<? extends Formatter> value();
}
// Single-member annotation with Class
// member restricted by bounded wildcard
// The annotation presumes the existence of this class.
class GorgeousFormatterimplements Formatter { ... }
@PrettyPrinter(GorgeousFormatter.class)
public class Petunia { ... }

‘@’ indicates the start of an annotation definition.

=Limitations=

=References=
[1] Jonathan Bartlett, "The art of metaprogramming, Part 1: Introduction to metaprogramming", 20 Oct 2005 http://www.ibm.com/developerworks/library/l-metaprog1/index.html#N10052

[2] Jonathan Bartlett, "The art of metaprogramming, Part 2: Metaprogramming using Scheme", 02 May 2006 http://www.ibm.com/developerworks/linux/library/l-metaprog2/index.html

[3] Abdelmonaim Remani, "The Art of Metaprogramming in Java", Jul 19, 2012 http://www.slideshare.net/PolymathicCoder/the-art-of-metaprogramming-in-java

[4] Mika Haapakorpi, "Meta Programming In Java"

[5] K. Czarnecki, "Generative Programming" chapter 8, Static Metaprogramming in C++

CSC/ECE 517 Spring 2013/ch1 1h jc

2013-02-19T02:14:38Z

Jrwills2: /* Metaprogramming in statically typed languages */

Metaprogramming in statically typed languages
=Metaprogramming in statically typed languages=
==Introduction==
===What is metaprogramming===

Metaprogramming refers to writing programs that can manipulate other programs or themselves. The program that is doing the manipulating is called the ''metaprogram'', and the program that is being manipulated is called the ''object program''. The language of the ''metaprogram'' is referred to as the ''metalanguage'' and the language of the object program is called the ''object language''. A language has the ability of ''reflection'' if it can be used to write a metaprogram that can manipulate a program written in the same language.

===Metaprogramming in statically typed languages===

Metaprogramming can be accomplished in both statically and dynamically typed languages. Dynamically type languages have some advantages over statically typed languages when it comes to metaprogramming.

One example of a metaprogramming task is to add a method to a particular class at runtime.

==Implementation==
===Programming Language API===

One way that metaprogramming can be possible in a language is through an API that helps programmers achieve a metaprogramming task. An example of this is a language that provides an API for reflection. One type of reflection is ''introspection'' in which the program can access the source code of the program itself.

Below is an example from the Java API to illustrate how an API can be used to achieve some metaprogramming tasks:

import java.lang.reflect.*;
public class DumpMethods {
public static void main(String args[]) {
try {
Class c = Class.forName(args[0]);
Method m[] = c.getDeclaredMethods();
for (int i = 0; i < m.length; i++) {
System.out.println(m[i].toString());
}
}
catch (Throwable e) {
System.err.println(e);
}
}

The above example prints out all of the methods that are declared for a particular class. This is an example of metaprogramming since the program is accessing the source code of itself.

===Program transformation system===

A program transformation system is something that takes a program as the input, and outputs a different program. One example of a program transformation system is the Java compiler. The Java compiler takes a Java program as its input, and outputs a .class file with platform independent bytecode in it. Another example of a program transformation system is a Java decompiler, which takes bytecode as an input and outputs a Java program.

In the case of the Java compiler, the program input is being output into another program in a different "language". There are other types of transformation systems that take a program as an input and output a different program in the same language. One example of this would be ''program migration'' which migrates source code to a newer or older version of the same language. This can be useful if upgrading a software system to run on a newer version of a framework.

===Metaprogramming using Scheme===
==Common Uses==
===Pre-generate static data at compile time===
One common use of metaprogramming in statically typed languages is to write programs that will pre-generate tables of data for use at runtime.

One simple but useful code generator is to build static lookup tables. Often, in order to build fast functions in C programming, we simply create a lookup table of all of the answers. This means that we either need to pre-compute them by hand (which is wasteful of your time) or build them at runtime (which is wasteful of the user's time).

In following example we will build a generator that will take a function or set of functions on an integer and build lookup tables for the answer.

To think of how to make such a program, we can start from the end and work backward. Firstly we need a lookup table that will return square roots of numbers between 5 and 20. A simple program can be written to generate such a table like this:

Generate and use a lookup table of square roots

/* our lookup table */
double square_roots[21];
/* function to load the table at runtime */
void init_square_roots()
{
int i;
for(i = 5; i < 21; i++)
{
square_roots[i] = sqrt((double)i);
}
}

With that single macro, we can take away a lot of work for any program that has to generate mathematical tables indexed by integer. A little extra work would also allow tables containing full struct definitions; a little more would ensure that space isn't wasted at the front of the array with useless empty entries.
/* program that uses the table */
int main ()
{
init_square_roots();
printf("The square root of 5 is %f\n", square_roots[5]);
return 0;
}

Now, to convert this to a statically initialized array, you would remove the first part of the program and replace it with something like this, calculated by hand:

Square root program with a static lookup table

double square_roots[] = {
/* these are the ones we skipped */ 0.0, 0.0, 0.0, 0.0, 0.0
2.236068, /* Square root of 5 */
2.449490, /* Square root of 6 */
2.645751, /* Square root of 7 */
2.828427, /* Square root of 8 */
3.0, /* Square root of 9 */
...
4.472136 /* Square root of 20 */
};

What is needed is a program that will produce these values and print them out in a table like the previous one so they are loaded in at compile-time.

Code generator for the table macro

#!/usr/bin/perl
#
#tablegen.pl
#
##Puts each program line into $line
while(my $line = <>)
{
#Is this a macro invocation?
if($line =~ m/TABLE:/)
{
#If so, split it apart into its component pieces
my ($dummy, $table_name, $type, $start_idx, $end_idx, $default, $procedure) = split(m/:/, $line, 7);
#The main difference between C and Perl for mathematical expressions is that
#Perl prefixes its variables with a dollar sign, so we will add that here
$procedure =~ s/VAL/\$VAL/g;
#Print out the array declaration
print "${type} ${table_name} [] = {\n";
#Go through each array element
foreach my $VAL (0 .. $end_idx)
{
#Only process an answer if we have reached our starting index
if($VAL >= $start_idx)
{
#evaluate the procedure specified (this sets $@ if there are any errors)
$result = eval $procedure;
die("Error processing: $@") if $@;
}
else
{
#if we haven't reached the starting index, just use the default
$result = $default;
}
#Print out the value
print "\t${result}";
#If there are more to be processed, add a comma after the value
if($VAL != $end_idx)
{
print ",";
}
print "\n"
}
#Finish the declaration
print "};\n";
}
else
{
#If this is not a macro invocation, just copy the line directly to the output
print $line;
}
}

To run this program, do this:

Running the code generator

./tablegen.pl < sqrt.in > sqrt.c
gcc sqrt.c -o sqrt
./a.out

===Mini-language for boiler-plate===
If you have a large application where many of the functions include a lot of boilerplate code, it is often a good idea to create a mini-language that allows you to work with your boilerplate code in an easier fashion. This mini-language will then be converted into your regular source code language before compiling.

The following is an example:

Let's say that we are building a CGI application consisting of many independent CGI scripts. In most CGI applications, much of the state is stored in a database, but only a session ID is passed to each script via a cookie.

However, in nearly every page we need to know the other standard information (such as the username, group number, the current job being worked on, whatever else information is pertinent). In addition, we need to redirect the user if they do not have an appropriate cookie.

(define (handle-cgi-request req)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
;;Code for processing goes here
))))

While some of that can be handled by a procedure, the bindings certainly cannot. However, we can turn most of it into a macro. The macro can be implemented like this:

(define-syntax cgi-boilerplate
(lambda (x)
(syntax-case x ()
(
(cgi-boilerplate expr)
(datum->syntax-object
(syntax k)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
(syntax-object->datum (syntax expr))))))
)
)))

We can now create new forms based on our boilerplate code by doing the following:

(define (handle-cgi-request req)
(cgi-boilerplate
(begin
;;Do whatever I want here
)))

In addition, since we are not defining our variables explicitly, adding new variable definitions to our boilerplate won't affect its calling conventions, so new features can be added without having to create a whole new function.

In any large project, there are inevitably templates to follow which cannot be reduced to functions, usually because of the bindings being created. Using boilerplate macros can make maintenance of such templated code much easier.

Likewise, other standard macros can be created which make use of variables defined in the boilerplate. Using macros like this significantly reduces typing because you do not have to constantly be writing and rewriting variable bindings, derivations, and parameter passing. This also reduces the potential for errors in such code.

Realize though that boilerplate macros are not a panacea. There are many significant problems that can occur, including:
* Accidentally overwriting bindings by introducing a variable name that was previously defined in a macro.
* Difficulty tracing problems because the inputs and the outputs of the macros are implicit, not explicit.

These can be largely avoided by doing a few things in conjunction with your boilerplate macros:
* Have a naming convention which clearly labels macros as such, as well as indicate that a variable came from boilerplate code. This could be done by affixing -m to macros and -b to variables defined within a boilerplate.
* Carefully document all boilerplate macros, especially the introduced variable bindings and all changes between versions.
* Only use boilerplate macros when the savings in repetitiveness clearly outweigh the negatives of implicit functionality.

===Abbreviate statements and prevent mistakes===
A lot of programming languages make you write really verbose statements to do really simple things. Code-generating programs allow you to abbreviate such statements and save a lot of typing, which also prevents a lot of mistakes because there is less chance of mistyping.

=Metaprogramming Framework in Java=
==Reflection==
===Introduction to reflection===
Reflection is the ability to introspect metalevel information about the program structure itself at runtime. Usually this metalevel information is modeled using the general abstraction mechanisms available in the language. In Java, reflection enables to discover information about the loaded classes:
* Fields,
* Methods, and
* Constructors
* Generics information
* Metadata annotations
It also enables to use these metaobjects to their instances in runtime environment.

The following is the Java metalevel architecture

[[File:Metalevel architecture.PNG]]

===Dynamic proxy classes===
A dynamic proxy class implements a list of interfaces specified at runtime when the class is created.
* A proxy interface is an interface that is implemented by a proxy class.
* A proxy instance is an instance of a proxy class which has an associated invocation handler object.
The following is an example of dynamic proxy classes

[[File:Dynamic_proxy_class.PNG]]

==Generics==
Generics are a facility of generic programming that was added to the Java programming language in 2004 as part of J2SE 5.0. They allow "a type or method to operate on objects of various types while providing compile-time type safety." The generics can be used in classes, interfaces, methods and constructors.
===Two new types in generics===
Two new types in generics:
* Parametrized types
* Type variables

A type variable is an unqualified identifier. Class and interface declarations can have type arguments (type variables). Method and constructors definitions can have type arguments (type variables).

The following is an example for type variables

List<String> anExample = new ArrayList<String>()

* List : interface
* ArrayList : class
* String : class (the actual type argument)
* List<String> and ArrayList<String> : parametrized type

===Class/Interface Declarations===
The following is an example of class declaration:

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

==Metadata annotation==
An annotation, in the Java computer programming language, is a form of syntactic metadata that can be added to Java source code. Classes, methods, variables, parameters and packages may be annotated.

The following is an example of annotation:

/**
* Designates a formatter to pretty-print the annotated class.
*/
public @interface PrettyPrinter{
Class<? extends Formatter> value();
}
// Single-member annotation with Class
// member restricted by bounded wildcard
// The annotation presumes the existence of this class.
class GorgeousFormatterimplements Formatter { ... }
@PrettyPrinter(GorgeousFormatter.class)
public class Petunia { ... }

‘@’ indicates the start of an annotation definition.

=Limitations=

=References=

CSC/ECE 517 Spring 2013/ch1 1h jc

2013-02-18T04:46:12Z

Jrwills2: /* Program transformation system */

Metaprogramming in statically typed languages
=Metaprogramming in statically typed languages=
==Introduction==
===What is metaprogramming===

Metaprogramming refers to writing programs that can manipulate other programs or themselves. The program that is doing the manipulating is called the ''metaprogram'', and the program that is being manipulated is called the ''object program''. The language of the ''metaprogram'' is referred to as the ''metalanguage'' and the language of the object program is called the ''object language''. A language has the ability of ''reflection'' if it can be used to write a metaprogram that can manipulate a program written in the same language.

===Metaprogramming in statically typed languages===
==Implementation==
===Programming Language API===

One way that metaprogramming can be possible in a language is through an API that helps programmers achieve a metaprogramming task. An example of this is a language that provides an API for reflection. One type of reflection is ''introspection'' in which the program can access the source code of the program itself.

Below is an example from the Java API to illustrate how an API can be used to achieve some metaprogramming tasks:

import java.lang.reflect.*;
public class DumpMethods {
public static void main(String args[]) {
try {
Class c = Class.forName(args[0]);
Method m[] = c.getDeclaredMethods();
for (int i = 0; i < m.length; i++) {
System.out.println(m[i].toString());
}
}
catch (Throwable e) {
System.err.println(e);
}
}

The above example prints out all of the methods that are declared for a particular class. This is an example of metaprogramming since the program is accessing the source code of itself.

===Program transformation system===

A program transformation system is something that takes a program as the input, and outputs a different program. One example of a program transformation system is the Java compiler. The Java compiler takes a Java program as its input, and outputs a .class file with platform independent bytecode in it. Another example of a program transformation system is a Java decompiler, which takes bytecode as an input and outputs a Java program.

In the case of the Java compiler, the program input is being output into another program in a different "language". There are other types of transformation systems that take a program as an input and output a different program in the same language. One example of this would be ''program migration'' which migrates source code to a newer or older version of the same language. This can be useful if upgrading a software system to run on a newer version of a framework.

===Metaprogramming using Scheme===
==Common Uses==
===Pre-generate static data at compile time===
One common use of metaprogramming in statically typed languages is to write programs that will pre-generate tables of data for use at runtime.

One simple but useful code generator is to build static lookup tables. Often, in order to build fast functions in C programming, we simply create a lookup table of all of the answers. This means that we either need to pre-compute them by hand (which is wasteful of your time) or build them at runtime (which is wasteful of the user's time).

In following example we will build a generator that will take a function or set of functions on an integer and build lookup tables for the answer.

To think of how to make such a program, we can start from the end and work backward. Firstly we need a lookup table that will return square roots of numbers between 5 and 20. A simple program can be written to generate such a table like this:

Generate and use a lookup table of square roots

/* our lookup table */
double square_roots[21];
/* function to load the table at runtime */
void init_square_roots()
{
int i;
for(i = 5; i < 21; i++)
{
square_roots[i] = sqrt((double)i);
}
}

With that single macro, we can take away a lot of work for any program that has to generate mathematical tables indexed by integer. A little extra work would also allow tables containing full struct definitions; a little more would ensure that space isn't wasted at the front of the array with useless empty entries.
/* program that uses the table */
int main ()
{
init_square_roots();
printf("The square root of 5 is %f\n", square_roots[5]);
return 0;
}

Now, to convert this to a statically initialized array, you would remove the first part of the program and replace it with something like this, calculated by hand:

Square root program with a static lookup table

double square_roots[] = {
/* these are the ones we skipped */ 0.0, 0.0, 0.0, 0.0, 0.0
2.236068, /* Square root of 5 */
2.449490, /* Square root of 6 */
2.645751, /* Square root of 7 */
2.828427, /* Square root of 8 */
3.0, /* Square root of 9 */
...
4.472136 /* Square root of 20 */
};

What is needed is a program that will produce these values and print them out in a table like the previous one so they are loaded in at compile-time.

Code generator for the table macro

#!/usr/bin/perl
#
#tablegen.pl
#
##Puts each program line into $line
while(my $line = <>)
{
#Is this a macro invocation?
if($line =~ m/TABLE:/)
{
#If so, split it apart into its component pieces
my ($dummy, $table_name, $type, $start_idx, $end_idx, $default, $procedure) = split(m/:/, $line, 7);
#The main difference between C and Perl for mathematical expressions is that
#Perl prefixes its variables with a dollar sign, so we will add that here
$procedure =~ s/VAL/\$VAL/g;
#Print out the array declaration
print "${type} ${table_name} [] = {\n";
#Go through each array element
foreach my $VAL (0 .. $end_idx)
{
#Only process an answer if we have reached our starting index
if($VAL >= $start_idx)
{
#evaluate the procedure specified (this sets $@ if there are any errors)
$result = eval $procedure;
die("Error processing: $@") if $@;
}
else
{
#if we haven't reached the starting index, just use the default
$result = $default;
}
#Print out the value
print "\t${result}";
#If there are more to be processed, add a comma after the value
if($VAL != $end_idx)
{
print ",";
}
print "\n"
}
#Finish the declaration
print "};\n";
}
else
{
#If this is not a macro invocation, just copy the line directly to the output
print $line;
}
}

To run this program, do this:

Running the code generator

./tablegen.pl < sqrt.in > sqrt.c
gcc sqrt.c -o sqrt
./a.out

===Mini-language for boiler-plate===
If you have a large application where many of the functions include a lot of boilerplate code, it is often a good idea to create a mini-language that allows you to work with your boilerplate code in an easier fashion. This mini-language will then be converted into your regular source code language before compiling.

The following is an example:

Let's say that we are building a CGI application consisting of many independent CGI scripts. In most CGI applications, much of the state is stored in a database, but only a session ID is passed to each script via a cookie.

However, in nearly every page we need to know the other standard information (such as the username, group number, the current job being worked on, whatever else information is pertinent). In addition, we need to redirect the user if they do not have an appropriate cookie.

(define (handle-cgi-request req)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
;;Code for processing goes here
))))

While some of that can be handled by a procedure, the bindings certainly cannot. However, we can turn most of it into a macro. The macro can be implemented like this:

(define-syntax cgi-boilerplate
(lambda (x)
(syntax-case x ()
(
(cgi-boilerplate expr)
(datum->syntax-object
(syntax k)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
(syntax-object->datum (syntax expr))))))
)
)))

We can now create new forms based on our boilerplate code by doing the following:

(define (handle-cgi-request req)
(cgi-boilerplate
(begin
;;Do whatever I want here
)))

In addition, since we are not defining our variables explicitly, adding new variable definitions to our boilerplate won't affect its calling conventions, so new features can be added without having to create a whole new function.

In any large project, there are inevitably templates to follow which cannot be reduced to functions, usually because of the bindings being created. Using boilerplate macros can make maintenance of such templated code much easier.

Likewise, other standard macros can be created which make use of variables defined in the boilerplate. Using macros like this significantly reduces typing because you do not have to constantly be writing and rewriting variable bindings, derivations, and parameter passing. This also reduces the potential for errors in such code.

Realize though that boilerplate macros are not a panacea. There are many significant problems that can occur, including:
* Accidentally overwriting bindings by introducing a variable name that was previously defined in a macro.
* Difficulty tracing problems because the inputs and the outputs of the macros are implicit, not explicit.

These can be largely avoided by doing a few things in conjunction with your boilerplate macros:
* Have a naming convention which clearly labels macros as such, as well as indicate that a variable came from boilerplate code. This could be done by affixing -m to macros and -b to variables defined within a boilerplate.
* Carefully document all boilerplate macros, especially the introduced variable bindings and all changes between versions.
* Only use boilerplate macros when the savings in repetitiveness clearly outweigh the negatives of implicit functionality.

===Abbreviate statements and prevent mistakes===
A lot of programming languages make you write really verbose statements to do really simple things. Code-generating programs allow you to abbreviate such statements and save a lot of typing, which also prevents a lot of mistakes because there is less chance of mistyping.

=Metaprogramming Framework in Java=
==Reflection==
===Introduction to reflection===
Reflection is the ability to introspect metalevel information about the program structure itself at runtime. Usually this metalevel information is modeled using the general abstraction mechanisms available in the language. In Java, reflection enables to discover information about the loaded classes:
* Fields,
* Methods, and
* Constructors
* Generics information
* Metadata annotations
It also enables to use these metaobjects to their instances in runtime environment.

The following is the Java metalevel architecture

[[File:Metalevel architecture.PNG]]

===Dynamic proxy classes===
A dynamic proxy class implements a list of interfaces specified at runtime when the class is created.
* A proxy interface is an interface that is implemented by a proxy class.
* A proxy instance is an instance of a proxy class which has an associated invocation handler object.
The following is an example of dynamic proxy classes

[[File:Dynamic_proxy_class.PNG]]

==Generics==
Generics are a facility of generic programming that was added to the Java programming language in 2004 as part of J2SE 5.0. They allow "a type or method to operate on objects of various types while providing compile-time type safety." The generics can be used in classes, interfaces, methods and constructors.
===Two new types in generics===
Two new types in generics:
* Parametrized types
* Type variables

A type variable is an unqualified identifier. Class and interface declarations can have type arguments (type variables). Method and constructors definitions can have type arguments (type variables).

The following is an example for type variables

List<String> anExample = new ArrayList<String>()

* List : interface
* ArrayList : class
* String : class (the actual type argument)
* List<String> and ArrayList<String> : parametrized type

===Class/Interface Declarations===
The following is an example of class declaration:

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

==Metadata annotation==
An annotation, in the Java computer programming language, is a form of syntactic metadata that can be added to Java source code. Classes, methods, variables, parameters and packages may be annotated.

The following is an example of annotation:

/**
* Designates a formatter to pretty-print the annotated class.
*/
public @interface PrettyPrinter{
Class<? extends Formatter> value();
}
// Single-member annotation with Class
// member restricted by bounded wildcard
// The annotation presumes the existence of this class.
class GorgeousFormatterimplements Formatter { ... }
@PrettyPrinter(GorgeousFormatter.class)
public class Petunia { ... }

‘@’ indicates the start of an annotation definition.

=Limitations=

=References=

CSC/ECE 517 Spring 2013/ch1 1h jc

2013-02-18T03:18:12Z

Jrwills2: /* Program transformation system */

Metaprogramming in statically typed languages
=Metaprogramming in statically typed languages=
==Introduction==
===What is metaprogramming===

Metaprogramming refers to writing programs that can manipulate other programs or themselves. The program that is doing the manipulating is called the ''metaprogram'', and the program that is being manipulated is called the ''object program''. The language of the ''metaprogram'' is referred to as the ''metalanguage'' and the language of the object program is called the ''object language''. A language has the ability of ''reflection'' if it can be used to write a metaprogram that can manipulate a program written in the same language.

===Metaprogramming in statically typed languages===
==Implementation==
===Programming Language API===

One way that metaprogramming can be possible in a language is through an API that helps programmers achieve a metaprogramming task. An example of this is a language that provides an API for reflection. One type of reflection is ''introspection'' in which the program can access the source code of the program itself.

Below is an example from the Java API to illustrate how an API can be used to achieve some metaprogramming tasks:

import java.lang.reflect.*;
public class DumpMethods {
public static void main(String args[]) {
try {
Class c = Class.forName(args[0]);
Method m[] = c.getDeclaredMethods();
for (int i = 0; i < m.length; i++) {
System.out.println(m[i].toString());
}
}
catch (Throwable e) {
System.err.println(e);
}
}

The above example prints out all of the methods that are declared for a particular class. This is an example of metaprogramming since the program is accessing the source code of itself.

===Program transformation system===

A program transformation system is something that takes a program as the input, and outputs a different program. One example of a program transformation system is the Java compiler. The Java compiler takes a Java program as its input, and outputs a .class file with platform independent bytecode in it. Another example of a program transformation system is a Java decompiler, which takes bytecode as an input and outputs a Java program.

===Metaprogramming using Scheme===
==Common Uses==
===Pre-generate static data at compile time===
One common use of metaprogramming in statically typed languages is to write programs that will pre-generate tables of data for use at runtime.

One simple but useful code generator is to build static lookup tables. Often, in order to build fast functions in C programming, we simply create a lookup table of all of the answers. This means that we either need to pre-compute them by hand (which is wasteful of your time) or build them at runtime (which is wasteful of the user's time).

In following example we will build a generator that will take a function or set of functions on an integer and build lookup tables for the answer.

To think of how to make such a program, we can start from the end and work backward. Firstly we need a lookup table that will return square roots of numbers between 5 and 20. A simple program can be written to generate such a table like this:

Generate and use a lookup table of square roots

/* our lookup table */
double square_roots[21];
/* function to load the table at runtime */
void init_square_roots()
{
int i;
for(i = 5; i < 21; i++)
{
square_roots[i] = sqrt((double)i);
}
}

With that single macro, we can take away a lot of work for any program that has to generate mathematical tables indexed by integer. A little extra work would also allow tables containing full struct definitions; a little more would ensure that space isn't wasted at the front of the array with useless empty entries.
/* program that uses the table */
int main ()
{
init_square_roots();
printf("The square root of 5 is %f\n", square_roots[5]);
return 0;
}

Now, to convert this to a statically initialized array, you would remove the first part of the program and replace it with something like this, calculated by hand:

Square root program with a static lookup table

double square_roots[] = {
/* these are the ones we skipped */ 0.0, 0.0, 0.0, 0.0, 0.0
2.236068, /* Square root of 5 */
2.449490, /* Square root of 6 */
2.645751, /* Square root of 7 */
2.828427, /* Square root of 8 */
3.0, /* Square root of 9 */
...
4.472136 /* Square root of 20 */
};

What is needed is a program that will produce these values and print them out in a table like the previous one so they are loaded in at compile-time.

Code generator for the table macro

#!/usr/bin/perl
#
#tablegen.pl
#
##Puts each program line into $line
while(my $line = <>)
{
#Is this a macro invocation?
if($line =~ m/TABLE:/)
{
#If so, split it apart into its component pieces
my ($dummy, $table_name, $type, $start_idx, $end_idx, $default, $procedure) = split(m/:/, $line, 7);
#The main difference between C and Perl for mathematical expressions is that
#Perl prefixes its variables with a dollar sign, so we will add that here
$procedure =~ s/VAL/\$VAL/g;
#Print out the array declaration
print "${type} ${table_name} [] = {\n";
#Go through each array element
foreach my $VAL (0 .. $end_idx)
{
#Only process an answer if we have reached our starting index
if($VAL >= $start_idx)
{
#evaluate the procedure specified (this sets $@ if there are any errors)
$result = eval $procedure;
die("Error processing: $@") if $@;
}
else
{
#if we haven't reached the starting index, just use the default
$result = $default;
}
#Print out the value
print "\t${result}";
#If there are more to be processed, add a comma after the value
if($VAL != $end_idx)
{
print ",";
}
print "\n"
}
#Finish the declaration
print "};\n";
}
else
{
#If this is not a macro invocation, just copy the line directly to the output
print $line;
}
}

To run this program, do this:

Running the code generator

./tablegen.pl < sqrt.in > sqrt.c
gcc sqrt.c -o sqrt
./a.out

===Mini-language for boiler-plate===
If you have a large application where many of the functions include a lot of boilerplate code, it is often a good idea to create a mini-language that allows you to work with your boilerplate code in an easier fashion. This mini-language will then be converted into your regular source code language before compiling.

The following is an example:

Let's say that we are building a CGI application consisting of many independent CGI scripts. In most CGI applications, much of the state is stored in a database, but only a session ID is passed to each script via a cookie.

However, in nearly every page we need to know the other standard information (such as the username, group number, the current job being worked on, whatever else information is pertinent). In addition, we need to redirect the user if they do not have an appropriate cookie.

(define (handle-cgi-request req)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
;;Code for processing goes here
))))

While some of that can be handled by a procedure, the bindings certainly cannot. However, we can turn most of it into a macro. The macro can be implemented like this:

(define-syntax cgi-boilerplate
(lambda (x)
(syntax-case x ()
(
(cgi-boilerplate expr)
(datum->syntax-object
(syntax k)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
(syntax-object->datum (syntax expr))))))
)
)))

We can now create new forms based on our boilerplate code by doing the following:

(define (handle-cgi-request req)
(cgi-boilerplate
(begin
;;Do whatever I want here
)))

In addition, since we are not defining our variables explicitly, adding new variable definitions to our boilerplate won't affect its calling conventions, so new features can be added without having to create a whole new function.

In any large project, there are inevitably templates to follow which cannot be reduced to functions, usually because of the bindings being created. Using boilerplate macros can make maintenance of such templated code much easier.

Likewise, other standard macros can be created which make use of variables defined in the boilerplate. Using macros like this significantly reduces typing because you do not have to constantly be writing and rewriting variable bindings, derivations, and parameter passing. This also reduces the potential for errors in such code.

Realize though that boilerplate macros are not a panacea. There are many significant problems that can occur, including:
* Accidentally overwriting bindings by introducing a variable name that was previously defined in a macro.
* Difficulty tracing problems because the inputs and the outputs of the macros are implicit, not explicit.

These can be largely avoided by doing a few things in conjunction with your boilerplate macros:
* Have a naming convention which clearly labels macros as such, as well as indicate that a variable came from boilerplate code. This could be done by affixing -m to macros and -b to variables defined within a boilerplate.
* Carefully document all boilerplate macros, especially the introduced variable bindings and all changes between versions.
* Only use boilerplate macros when the savings in repetitiveness clearly outweigh the negatives of implicit functionality.

===Abbreviate statements and prevent mistakes===
A lot of programming languages make you write really verbose statements to do really simple things. Code-generating programs allow you to abbreviate such statements and save a lot of typing, which also prevents a lot of mistakes because there is less chance of mistyping.

=Metaprogramming Framework in Java=
==Reflection==
===Introduction to reflection===
Reflection is the ability to introspect metalevel information about the program structure itself at runtime. Usually this metalevel information is modeled using the general abstraction mechanisms available in the language. In Java, reflection enables to discover information about the loaded classes:
* Fields,
* Methods, and
* Constructors
* Generics information
* Metadata annotations
It also enables to use these metaobjects to their instances in runtime environment.

The following is the Java metalevel architecture

[[File:Metalevel architecture.PNG]]

===Dynamic proxy classes===
A dynamic proxy class implements a list of interfaces specified at runtime when the class is created.
* A proxy interface is an interface that is implemented by a proxy class.
* A proxy instance is an instance of a proxy class which has an associated invocation handler object.
The following is an example of dynamic proxy classes

[[File:Dynamic_proxy_class.PNG]]

==Generics==
Generics are a facility of generic programming that was added to the Java programming language in 2004 as part of J2SE 5.0. They allow "a type or method to operate on objects of various types while providing compile-time type safety." The generics can be used in classes, interfaces, methods and constructors.
===Two new types in generics===
Two new types in generics:
* Parametrized types
* Type variables

A type variable is an unqualified identifier. Class and interface declarations can have type arguments (type variables). Method and constructors definitions can have type arguments (type variables).

The following is an example for type variables

List<String> anExample = new ArrayList<String>()

* List : interface
* ArrayList : class
* String : class (the actual type argument)
* List<String> and ArrayList<String> : parametrized type

===Class/Interface Declarations===
The following is an example of class declaration:

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

==Metadata annotation==
An annotation, in the Java computer programming language, is a form of syntactic metadata that can be added to Java source code. Classes, methods, variables, parameters and packages may be annotated.

The following is an example of annotation:

/**
* Designates a formatter to pretty-print the annotated class.
*/
public @interface PrettyPrinter{
Class<? extends Formatter> value();
}
// Single-member annotation with Class
// member restricted by bounded wildcard
// The annotation presumes the existence of this class.
class GorgeousFormatterimplements Formatter { ... }
@PrettyPrinter(GorgeousFormatter.class)
public class Petunia { ... }

‘@’ indicates the start of an annotation definition.

=Limitations=

=References=

CSC/ECE 517 Spring 2013/ch1 1h jc

2013-02-18T02:44:03Z

Jrwills2: /* Programming Language API */

Metaprogramming in statically typed languages
=Metaprogramming in statically typed languages=
==Introduction==
===What is metaprogramming===

Metaprogramming refers to writing programs that can manipulate other programs or themselves. The program that is doing the manipulating is called the ''metaprogram'', and the program that is being manipulated is called the ''object program''. The language of the ''metaprogram'' is referred to as the ''metalanguage'' and the language of the object program is called the ''object language''. A language has the ability of ''reflection'' if it can be used to write a metaprogram that can manipulate a program written in the same language.

===Metaprogramming in statically typed languages===
==Implementation==
===Programming Language API===

One way that metaprogramming can be possible in a language is through an API that helps programmers achieve a metaprogramming task. An example of this is a language that provides an API for reflection. One type of reflection is ''introspection'' in which the program can access the source code of the program itself.

Below is an example from the Java API to illustrate how an API can be used to achieve some metaprogramming tasks:

import java.lang.reflect.*;
public class DumpMethods {
public static void main(String args[]) {
try {
Class c = Class.forName(args[0]);
Method m[] = c.getDeclaredMethods();
for (int i = 0; i < m.length; i++) {
System.out.println(m[i].toString());
}
}
catch (Throwable e) {
System.err.println(e);
}
}

The above example prints out all of the methods that are declared for a particular class. This is an example of metaprogramming since the program is accessing the source code of itself.

===Program transformation system===
===Metaprogramming using Scheme===
==Common Uses==
===Pre-generate static data at compile time===
One common use of metaprogramming in statically typed languages is to write programs that will pre-generate tables of data for use at runtime.

One simple but useful code generator is to build static lookup tables. Often, in order to build fast functions in C programming, we simply create a lookup table of all of the answers. This means that we either need to pre-compute them by hand (which is wasteful of your time) or build them at runtime (which is wasteful of the user's time).

In following example we will build a generator that will take a function or set of functions on an integer and build lookup tables for the answer.

To think of how to make such a program, we can start from the end and work backward. Firstly we need a lookup table that will return square roots of numbers between 5 and 20. A simple program can be written to generate such a table like this:

Generate and use a lookup table of square roots

/* our lookup table */
double square_roots[21];
/* function to load the table at runtime */
void init_square_roots()
{
int i;
for(i = 5; i < 21; i++)
{
square_roots[i] = sqrt((double)i);
}
}

With that single macro, we can take away a lot of work for any program that has to generate mathematical tables indexed by integer. A little extra work would also allow tables containing full struct definitions; a little more would ensure that space isn't wasted at the front of the array with useless empty entries.
/* program that uses the table */
int main ()
{
init_square_roots();
printf("The square root of 5 is %f\n", square_roots[5]);
return 0;
}

Now, to convert this to a statically initialized array, you would remove the first part of the program and replace it with something like this, calculated by hand:

Square root program with a static lookup table

double square_roots[] = {
/* these are the ones we skipped */ 0.0, 0.0, 0.0, 0.0, 0.0
2.236068, /* Square root of 5 */
2.449490, /* Square root of 6 */
2.645751, /* Square root of 7 */
2.828427, /* Square root of 8 */
3.0, /* Square root of 9 */
...
4.472136 /* Square root of 20 */
};

What is needed is a program that will produce these values and print them out in a table like the previous one so they are loaded in at compile-time.

Code generator for the table macro

#!/usr/bin/perl
#
#tablegen.pl
#
##Puts each program line into $line
while(my $line = <>)
{
#Is this a macro invocation?
if($line =~ m/TABLE:/)
{
#If so, split it apart into its component pieces
my ($dummy, $table_name, $type, $start_idx, $end_idx, $default, $procedure) = split(m/:/, $line, 7);
#The main difference between C and Perl for mathematical expressions is that
#Perl prefixes its variables with a dollar sign, so we will add that here
$procedure =~ s/VAL/\$VAL/g;
#Print out the array declaration
print "${type} ${table_name} [] = {\n";
#Go through each array element
foreach my $VAL (0 .. $end_idx)
{
#Only process an answer if we have reached our starting index
if($VAL >= $start_idx)
{
#evaluate the procedure specified (this sets $@ if there are any errors)
$result = eval $procedure;
die("Error processing: $@") if $@;
}
else
{
#if we haven't reached the starting index, just use the default
$result = $default;
}
#Print out the value
print "\t${result}";
#If there are more to be processed, add a comma after the value
if($VAL != $end_idx)
{
print ",";
}
print "\n"
}
#Finish the declaration
print "};\n";
}
else
{
#If this is not a macro invocation, just copy the line directly to the output
print $line;
}
}

To run this program, do this:

Running the code generator

./tablegen.pl < sqrt.in > sqrt.c
gcc sqrt.c -o sqrt
./a.out

===Mini-language for boiler-plate===
If you have a large application where many of the functions include a lot of boilerplate code, it is often a good idea to create a mini-language that allows you to work with your boilerplate code in an easier fashion. This mini-language will then be converted into your regular source code language before compiling.

The following is an example:

Let's say that we are building a CGI application consisting of many independent CGI scripts. In most CGI applications, much of the state is stored in a database, but only a session ID is passed to each script via a cookie.

However, in nearly every page we need to know the other standard information (such as the username, group number, the current job being worked on, whatever else information is pertinent). In addition, we need to redirect the user if they do not have an appropriate cookie.

(define (handle-cgi-request req)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
;;Code for processing goes here
))))

While some of that can be handled by a procedure, the bindings certainly cannot. However, we can turn most of it into a macro. The macro can be implemented like this:

(define-syntax cgi-boilerplate
(lambda (x)
(syntax-case x ()
(
(cgi-boilerplate expr)
(datum->syntax-object
(syntax k)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
(syntax-object->datum (syntax expr))))))
)
)))

We can now create new forms based on our boilerplate code by doing the following:

(define (handle-cgi-request req)
(cgi-boilerplate
(begin
;;Do whatever I want here
)))

In addition, since we are not defining our variables explicitly, adding new variable definitions to our boilerplate won't affect its calling conventions, so new features can be added without having to create a whole new function.

In any large project, there are inevitably templates to follow which cannot be reduced to functions, usually because of the bindings being created. Using boilerplate macros can make maintenance of such templated code much easier.

Likewise, other standard macros can be created which make use of variables defined in the boilerplate. Using macros like this significantly reduces typing because you do not have to constantly be writing and rewriting variable bindings, derivations, and parameter passing. This also reduces the potential for errors in such code.

Realize though that boilerplate macros are not a panacea. There are many significant problems that can occur, including:
* Accidentally overwriting bindings by introducing a variable name that was previously defined in a macro.
* Difficulty tracing problems because the inputs and the outputs of the macros are implicit, not explicit.

These can be largely avoided by doing a few things in conjunction with your boilerplate macros:
* Have a naming convention which clearly labels macros as such, as well as indicate that a variable came from boilerplate code. This could be done by affixing -m to macros and -b to variables defined within a boilerplate.
* Carefully document all boilerplate macros, especially the introduced variable bindings and all changes between versions.
* Only use boilerplate macros when the savings in repetitiveness clearly outweigh the negatives of implicit functionality.

===Abbreviate statements and prevent mistakes===
A lot of programming languages make you write really verbose statements to do really simple things. Code-generating programs allow you to abbreviate such statements and save a lot of typing, which also prevents a lot of mistakes because there is less chance of mistyping.

=Metaprogramming Framework in Java=
==Reflection==
===Introduction to reflection===
Reflection is the ability to introspect metalevel information about the program structure itself at runtime. Usually this metalevel information is modeled using the general abstraction mechanisms available in the language. In Java, reflection enables to discover information about the loaded classes:
* Fields,
* Methods, and
* Constructors
* Generics information
* Metadata annotations
It also enables to use these metaobjects to their instances in runtime environment.

The following is the Java metalevel architecture

[[File:Metalevel architecture.PNG]]

===Dynamic proxy classes===
A dynamic proxy class implements a list of interfaces specified at runtime when the class is created.
* A proxy interface is an interface that is implemented by a proxy class.
* A proxy instance is an instance of a proxy class which has an associated invocation handler object.
The following is an example of dynamic proxy classes

[[File:Dynamic_proxy_class.PNG]]

==Generics==
Generics are a facility of generic programming that was added to the Java programming language in 2004 as part of J2SE 5.0. They allow "a type or method to operate on objects of various types while providing compile-time type safety." The generics can be used in classes, interfaces, methods and constructors.
===Two new types in generics===
Two new types in generics:
* Parametrized types
* Type variables

A type variable is an unqualified identifier. Class and interface declarations can have type arguments (type variables). Method and constructors definitions can have type arguments (type variables).

The following is an example for type variables

List<String> anExample = new ArrayList<String>()

* List : interface
* ArrayList : class
* String : class (the actual type argument)
* List<String> and ArrayList<String> : parametrized type

===Class/Interface Declarations===
The following is an example of class declaration:

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

==Metadata annotation==
An annotation, in the Java computer programming language, is a form of syntactic metadata that can be added to Java source code. Classes, methods, variables, parameters and packages may be annotated.

The following is an example of annotation:

/**
* Designates a formatter to pretty-print the annotated class.
*/
public @interface PrettyPrinter{
Class<? extends Formatter> value();
}
// Single-member annotation with Class
// member restricted by bounded wildcard
// The annotation presumes the existence of this class.
class GorgeousFormatterimplements Formatter { ... }
@PrettyPrinter(GorgeousFormatter.class)
public class Petunia { ... }

‘@’ indicates the start of an annotation definition.

=Limitations=

=References=

CSC/ECE 517 Spring 2013/ch1 1h jc

2013-02-18T02:39:52Z

Jrwills2: /* Programming Language API */

Metaprogramming in statically typed languages
=Metaprogramming in statically typed languages=
==Introduction==
===What is metaprogramming===

Metaprogramming refers to writing programs that can manipulate other programs or themselves. The program that is doing the manipulating is called the ''metaprogram'', and the program that is being manipulated is called the ''object program''. The language of the ''metaprogram'' is referred to as the ''metalanguage'' and the language of the object program is called the ''object language''. A language has the ability of ''reflection'' if it can be used to write a metaprogram that can manipulate a program written in the same language.

===Metaprogramming in statically typed languages===
==Implementation==
===Programming Language API===

One way that metaprogramming can be possible in a language is through an API that helps programmers achieve a metaprogramming task. An example of this is a language that provides an API for reflection. One type of reflection is ''introspection'' in which the program can access the source code of the program itself.

Below is an example from the Java API to illustrate how an API can be used to achieve some metaprogramming tasks:

import java.lang.reflect.*;
public class DumpMethods {
public static void main(String args[]) {
try {
Class c = Class.forName(args[0]);
Method m[] = c.getDeclaredMethods();
for (int i = 0; i < m.length; i++) {
System.out.println(m[i].toString());
}
}
catch (Throwable e) {
System.err.println(e);
}
}

The above example prints out all of the methods that are declared for a particular class. This is an example of metaprogramming since the program is is accessing the source code of itself.

===Program transformation system===
===Metaprogramming using Scheme===
==Common Uses==
===Pre-generate static data at compile time===
One common use of metaprogramming in statically typed languages is to write programs that will pre-generate tables of data for use at runtime.

One simple but useful code generator is to build static lookup tables. Often, in order to build fast functions in C programming, we simply create a lookup table of all of the answers. This means that we either need to pre-compute them by hand (which is wasteful of your time) or build them at runtime (which is wasteful of the user's time).

In following example we will build a generator that will take a function or set of functions on an integer and build lookup tables for the answer.

To think of how to make such a program, we can start from the end and work backward. Firstly we need a lookup table that will return square roots of numbers between 5 and 20. A simple program can be written to generate such a table like this:

Generate and use a lookup table of square roots

/* our lookup table */
double square_roots[21];
/* function to load the table at runtime */
void init_square_roots()
{
int i;
for(i = 5; i < 21; i++)
{
square_roots[i] = sqrt((double)i);
}
}

With that single macro, we can take away a lot of work for any program that has to generate mathematical tables indexed by integer. A little extra work would also allow tables containing full struct definitions; a little more would ensure that space isn't wasted at the front of the array with useless empty entries.
/* program that uses the table */
int main ()
{
init_square_roots();
printf("The square root of 5 is %f\n", square_roots[5]);
return 0;
}

Now, to convert this to a statically initialized array, you would remove the first part of the program and replace it with something like this, calculated by hand:

Square root program with a static lookup table

double square_roots[] = {
/* these are the ones we skipped */ 0.0, 0.0, 0.0, 0.0, 0.0
2.236068, /* Square root of 5 */
2.449490, /* Square root of 6 */
2.645751, /* Square root of 7 */
2.828427, /* Square root of 8 */
3.0, /* Square root of 9 */
...
4.472136 /* Square root of 20 */
};

What is needed is a program that will produce these values and print them out in a table like the previous one so they are loaded in at compile-time.

Code generator for the table macro

#!/usr/bin/perl
#
#tablegen.pl
#
##Puts each program line into $line
while(my $line = <>)
{
#Is this a macro invocation?
if($line =~ m/TABLE:/)
{
#If so, split it apart into its component pieces
my ($dummy, $table_name, $type, $start_idx, $end_idx, $default, $procedure) = split(m/:/, $line, 7);
#The main difference between C and Perl for mathematical expressions is that
#Perl prefixes its variables with a dollar sign, so we will add that here
$procedure =~ s/VAL/\$VAL/g;
#Print out the array declaration
print "${type} ${table_name} [] = {\n";
#Go through each array element
foreach my $VAL (0 .. $end_idx)
{
#Only process an answer if we have reached our starting index
if($VAL >= $start_idx)
{
#evaluate the procedure specified (this sets $@ if there are any errors)
$result = eval $procedure;
die("Error processing: $@") if $@;
}
else
{
#if we haven't reached the starting index, just use the default
$result = $default;
}
#Print out the value
print "\t${result}";
#If there are more to be processed, add a comma after the value
if($VAL != $end_idx)
{
print ",";
}
print "\n"
}
#Finish the declaration
print "};\n";
}
else
{
#If this is not a macro invocation, just copy the line directly to the output
print $line;
}
}

To run this program, do this:

Running the code generator

./tablegen.pl < sqrt.in > sqrt.c
gcc sqrt.c -o sqrt
./a.out

===Mini-language for boiler-plate===
If you have a large application where many of the functions include a lot of boilerplate code, it is often a good idea to create a mini-language that allows you to work with your boilerplate code in an easier fashion. This mini-language will then be converted into your regular source code language before compiling.

The following is an example:

Let's say that we are building a CGI application consisting of many independent CGI scripts. In most CGI applications, much of the state is stored in a database, but only a session ID is passed to each script via a cookie.

However, in nearly every page we need to know the other standard information (such as the username, group number, the current job being worked on, whatever else information is pertinent). In addition, we need to redirect the user if they do not have an appropriate cookie.

(define (handle-cgi-request req)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
;;Code for processing goes here
))))

While some of that can be handled by a procedure, the bindings certainly cannot. However, we can turn most of it into a macro. The macro can be implemented like this:

(define-syntax cgi-boilerplate
(lambda (x)
(syntax-case x ()
(
(cgi-boilerplate expr)
(datum->syntax-object
(syntax k)
(let (
(session-id (webserver:cookie req "sessionid")))
(if (not (webserver:valid-session-id session-id))
(webserver:redirect-to-login-page)
(let (
(username (webserver:username-for-session session-id))
(group (webserver:group-for-user username))
(current-job (webserver:current-job-for-user username)))
(syntax-object->datum (syntax expr))))))
)
)))

We can now create new forms based on our boilerplate code by doing the following:

(define (handle-cgi-request req)
(cgi-boilerplate
(begin
;;Do whatever I want here
)))

In addition, since we are not defining our variables explicitly, adding new variable definitions to our boilerplate won't affect its calling conventions, so new features can be added without having to create a whole new function.

In any large project, there are inevitably templates to follow which cannot be reduced to functions, usually because of the bindings being created. Using boilerplate macros can make maintenance of such templated code much easier.

Likewise, other standard macros can be created which make use of variables defined in the boilerplate. Using macros like this significantly reduces typing because you do not have to constantly be writing and rewriting variable bindings, derivations, and parameter passing. This also reduces the potential for errors in such code.

Realize though that boilerplate macros are not a panacea. There are many significant problems that can occur, including:
* Accidentally overwriting bindings by introducing a variable name that was previously defined in a macro.
* Difficulty tracing problems because the inputs and the outputs of the macros are implicit, not explicit.

These can be largely avoided by doing a few things in conjunction with your boilerplate macros:
* Have a naming convention which clearly labels macros as such, as well as indicate that a variable came from boilerplate code. This could be done by affixing -m to macros and -b to variables defined within a boilerplate.
* Carefully document all boilerplate macros, especially the introduced variable bindings and all changes between versions.
* Only use boilerplate macros when the savings in repetitiveness clearly outweigh the negatives of implicit functionality.

===Abbreviate statements and prevent mistakes===
A lot of programming languages make you write really verbose statements to do really simple things. Code-generating programs allow you to abbreviate such statements and save a lot of typing, which also prevents a lot of mistakes because there is less chance of mistyping.

=Metaprogramming Framework in Java=
==Reflection==
===Introduction to reflection===
Reflection is the ability to introspect metalevel information about the program structure itself at runtime. Usually this metalevel information is modeled using the general abstraction mechanisms available in the language. In Java, reflection enables to discover information about the loaded classes:
* Fields,
* Methods, and
* Constructors
* Generics information
* Metadata annotations
It also enables to use these metaobjects to their instances in runtime environment.

The following is the Java metalevel architecture

[[File:Metalevel architecture.PNG]]

===Dynamic proxy classes===
A dynamic proxy class implements a list of interfaces specified at runtime when the class is created.
* A proxy interface is an interface that is implemented by a proxy class.
* A proxy instance is an instance of a proxy class which has an associated invocation handler object.
The following is an example of dynamic proxy classes

[[File:Dynamic_proxy_class.PNG]]

==Generics==
Generics are a facility of generic programming that was added to the Java programming language in 2004 as part of J2SE 5.0. They allow "a type or method to operate on objects of various types while providing compile-time type safety." The generics can be used in classes, interfaces, methods and constructors.
===Two new types in generics===
Two new types in generics:
* Parametrized types
* Type variables

A type variable is an unqualified identifier. Class and interface declarations can have type arguments (type variables). Method and constructors definitions can have type arguments (type variables).

The following is an example for type variables

List<String> anExample = new ArrayList<String>()

* List : interface
* ArrayList : class
* String : class (the actual type argument)
* List<String> and ArrayList<String> : parametrized type

===Class/Interface Declarations===
The following is an example of class declaration:

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

==Metadata annotation==
An annotation, in the Java computer programming language, is a form of syntactic metadata that can be added to Java source code. Classes, methods, variables, parameters and packages may be annotated.

The following is an example of annotation:

/**
* Designates a formatter to pretty-print the annotated class.
*/
public @interface PrettyPrinter{
Class<? extends Formatter> value();
}
// Single-member annotation with Class
// member restricted by bounded wildcard
// The annotation presumes the existence of this class.
class GorgeousFormatterimplements Formatter { ... }
@PrettyPrinter(GorgeousFormatter.class)
public class Petunia { ... }

‘@’ indicates the start of an annotation definition.

=Limitations=

=References=