Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Spring 2013/OSS E734

2013-04-29T03:07:38Z

Cyang14: /* Introduction */

Developers:
*Hao Liu (hliu11@ncsu.edu)
*Zhuowei Wang (zwang18@ncsu.edu)
*Chunxue Yang (cyang14@ncsu.edu)

[https://docs.google.com/a/ncsu.edu/document/d/11YTjxFXFR13vJ769yFBbqn9qOueK2Ktz0Pd-gyS2W5U/edit# Write-up of This Topic.]

This page is the design documentation for Expertiza project E734 conducted in the CSC/ECE 517 Spring 2003 class at North Carolina State University. Learn more about Expertiza by visiting its main
page: http://wikis.lib.ncsu.edu/index.php/Expertiza

__TOC__

= Introduction =
The Expertiza project is system for using peer review to create reusable learning objects. Students do different assignments; then peer review selects the best work in each category, and assembles it to create a single unit.

The process of reviewing includes reviews, re-reviews and meta reviews of assignments submitted by students for a course. This method of evaluation also inherently suggests that there will be vagaries in the way reviews have been performed.

This project aim to provide a way for the users to examine various type of statistic about the courses, assignments and reviews.

== Objective ==
The original objective of the project is to extend the Analytic project E732 from previous semester to incorporate new features.
Upon examination the implementation of E732 we decided to start from scratch and create a developer friendly and easily extendable framework for providing analytic data and displaying analytic data.

To fulfill our purpose of providing a better experience for Expertiza users, we have several different aspects of to focus on.

The primary focus of this project is on reviews and the related aspects that go hand in hand with reviews like meta reviews, re-reviews etc. To be more specific, we will be working on an advanced search interface in which different criteria can be selected more flexibly to make a comparison for each review or meta review.

Moreover, we will dedicate in developing a more dynamic and clear chart graph. In our project, JavaScript libraries such as jQuery.js (GPL), highchart.js(CC by 3.0) are included to support the dynamic behaviors of the chart graph. Multi chart areas are supported by Dom Tree.

= Graphical User Interface (GUI) Design =
== Original Design ==
[[File:Original_analytic_gui.png]]

In the original GUI design of analytic the user can select from a list of cryptically worded data comparison:
*Review: Question Text And Review Comment vs Assignment
*Review: Question Count And Review Comment vs Assignment
*Review: Sub Question Count And Review Comment vs Assignment
*Average Review Parameters And Student Experience vs Assignment
*Average Metareview Parameters And Student Experience vs Assignment
*Assignment Strategy And Review Parameter

Besides the unfathomable meaning options, the design does not provide much room for the user of the page to explore and discover interesting correlations between data. Since the objective is to enable user to discover correlations between data, this implementation does not really meet the requirement.

After selecting a graph type the user can add courses to the graph. Upon selection the all of the assignments from the course are added to the graph than the user can un-select the assignments from a drop down menu. Once a course is selected there's no way to remove a course from the selection.

There are no option for selecting how the data are presented, data are displayed as a bar graph which restrict the type of data that can be displayed.

The specific numeric value for the graph are displayed below the graph as a chart.

== New Design ==
[[File:New_analytic_gui.png]]
=== Graph Type and Comparison Scope Selection ===
When the user arrive at the analytic page they are prevented with two options: Graph Type and Comparison Scope.

[[File:New_analytic_gui_1.png]]

First, in the new design we would like to offer the user and developer more options for displaying the data, instead of the restriction of only using bar graph.

Graph type let the user select what kind of graph do they want the data to be displayed currently there are four different options:
*Bar Graph - useful for displaying simple numeric comparisons (i.e: average scores, number of participants)
[[File:New_analytic_gui_bar.png]]
*Line Graph - useful for displaying comparison of distributions (i.e: grade distribution for assignments)
[[File:New_analytic_gui_line.png]]
*Scatter Plot - useful for displaying raw data points (i.e: grades for all of the student for assignments)
[[File:New_analytic_gui_scatter.png]]
*Pie Chart - useful for displaying percentage related data (i.e: percentage of grade distribution for an single assignment)
[[File:New_analytic_gui_pie.png]]

Second, we would like to offer the user more scope of comparison instead restricting to only assignment wise comparison

Comparison scope give user options to select what do they want to compare:Course, Assignment, Team

=== Comparison Object Selection===
After the user select the graph type and comparison scope the user are presented with options to select comparison object and comparison data. These options changes depending on the graph type and comparison type.

Comparison object depends on what comparison scope the user selected. For example:

If the user select course wise comparison scope than the user will be presented with a check-box list of courses that they are allow to view.

[[File:New_analytic_gui_2_1.png‎]]

However if the user select assignment wise comparison scope the user will be presented with drop down menu with list of courses that they are allow to view and once the user select the course that they are interested in the are presented with a check-box list of assignments that are within the courses.

[[File:New_analytic_gui_2_2.png‎]]

User can select multiple object that they want to compare and the graph will update dynamically.

=== Comparison Data Selection ===
Options for comparison data depends on both comparison scope and graph type. A check-box list will be displayed containing the appropriate data type that are available for the selected graph type and selected comparison scope.

'''Development Note:''' Currently we only finish the options related to for bar graph, however the framework for adding options related to other type of graph has been completed.

[[File:New_analytic_gui_3.png]]

The user can select multiple type of graph data and the graph will be updated dynamiclly

=== Graph Display ===
Once all of the selections are complete a graph containing the data will be rendered. We would like to retain the ability to display the numeric value for the data, however table containing all of the data in the graph is not the most efficient way to to percent the data instead in the new implementation the numeric value for the data will be display when the user hover the curer over the graph.

[[File:New_analytic_gui_4.png]]

= Framework Design =
Architecture of the Expertiza Analytic Framework is based on the model-view-controller design pattern used in Rails application.
[[File:Analytic_framwork_archtecture.png]]

== Model ==
There are two tasks that analytic require the model to perform: data mining and data formating.

=== Data Mining ===
The data mining operations performed by model classes gathers the data requested by the controller.

==== Original Implementation ====
In the original implementation of analytic, data mining methods use to extract the data are scattered between the assignment model class and controller. There are several problems with this method of implementation.

First, assignment model is crucial class for the correct operation of the Expertiza and the data mining methods are not related to the normal operation that the model performs this reduces the readability and maintainability of the model.

Second, the data mining methods seem to recursively traverse through the data structure hierarchy level by level (for example: to obtain average grades for assignment, the original implementation do assignment->for each teams-> for each responses->score->grade) in-order to obtain the data that they need. This design violates basic object oriented programming principle, instead the data mining methods should be layered and methods should be added to the corresponding models to avoid this behavior.

==== New Implementation ====
The new implementation of analytic the data mining methods are implemented as mixin modules for the corresponding models. The modules are gathered into the /models/analytic folder. The modules contains the analytic methods for the model that they relates to. The analytic modules only calls the methods that are defined in model that they corresponds to and methods defined in other analytic module.

This implementation creates a clear separation between the normal model operation and data mining operation; abstract away the complexity of the structure of the underlying databases; improves the readability for the developer.

==== Related Files ====
Analytic modules and their corresponding models:
*expertiza/app/models/analytic/course_analytic.rb => expertiza/app/models/course.rb
*expertiza/app/models/analytic/assignment_analytic.rb => expertiza/app/models/assignment.rb
*expertiza/app/models/analytic/assignment_team_analytic.rb => expertiza/app/models/assignment_team.rb
*expertiza/app/models/analytic/questionnaire_analytic.rb => expertiza/app/models/questionnaire.rb
*expertiza/app/models/analytic/question_analytic.rb => expertiza/app/models/question.rb
*expertiza/app/models/analytic/response_analytic.rb => expertiza/app/models/response.rb
*expertiza/app/models/analytic/question_analytic.rb => expertiza/app/models/question.rb
*expertiza/app/models/analytic/score_analytic.rb => expertiza/app/models/score.rb

=== Data Formatting ===
The data formatting operations take the gathered data and formatted turn it into the format that are require by the methods that draws the charts that display the data.

==== Original Implementation ====
The original implementation of analytic have the controller handles data formatting function. In the MVC structure used in rails application, formatting the data is not a responsibility for the controller.

==== New Implementation ====
The new implementation of analytic a Chart class was created to handle the formatting of data. The Chart class serve as a interface between the java script based front-end in view and the ruby model back-end. The controller passes the graph type and data into the Chart class and the Chart class will handle all formatting and return the data that controller can pass into view.

The example for the input data format and how to use the Chart class will be provided in later section.

==== Related files ====
*expertiza/app/helpers/chart.rb

'''Development Note:''' currently the Chart class located in the helper folder, this is not the proper location for the file. The file should be move to the models folder and rename to analytic.rb.

== View ==
In analytic view displays options for the user, send user input to the controller and presents graph in a particular format, triggered by a controller's decision based on the user input.

=== Original Implementation ===
The original implementation of analytic leverages the google chart ruby gem to generate the graph in a static fashion. The graph data type that the user can request are hard coded into the view with lots of switch statements and if else statements to handle different cases. This method of implementation which limits what the user can see and dramatically increases the difficult for adding new data options that user can see. According to the documentation for the MVC architecture used in Rails, the decision for what to display should be handle by the controller.

Using google chart ruby gem is an acceptable implementation however the google chart gem have limited capabilities and a somewhat outdated look. Further more, the gem it might have the risk running into compatibly issues with future Rails version if the gem is not kept up to date.

=== New Implementation ===
For our new implementation of analytic we decided to move to jQuery. jQuery is a powerful, popular, and well maintained webpage UI library for java script.
(Steven... add more)

== Controller ==

=== Method Overview ===
methods with post fix _list (graph_data_type_list, course_list, assignment_list, team_list) are use to populate the different selection in view.

get_graph_data_bundle method is use to generate the data for the graph in view

bar_chart_data, line_chart_data, scatter_chart_data, pie_chart_data located in analytic helper (expertiza/app/helpers/analytic_helper.rb) are the interface function between the analytic modules and chart class

=== Access Control ===
Goldberg menu system provided control for who can access the analytic page however it does not control what courses are displayed once they are in the analytic page. By assigning permission of administer assignment to the controller in Goldberg menu system we restricted the access of analytic to user with role of super-admin, admin, instructor and teaching assistant. However we would like the user to only be able to see the courses that they are associated with. To achieve that we the method associated_courses was added to the course helper (expertiza/app/helpers/course_helper.rb)

The associated_courses method returns a list of courses depending on the user's role. For super-admin and admin it will return all of the courses that are in the database. For instructor it will return the courses that belongs to the instructor. For teaching assistant it will return all the courses that they are TA-ing.

The course_list method in the analytic controller uses this method to determine which list should be listed on the course selection section of the view.

=== Adding New Option for the Data Type ===
The method graph_data_type_list is use to return a list of appropriate options for the data type selection in view.

@available_data_type is a hash of comparison_scope and graph_type with method names in the analytic modules initialized in the init method.

all of the methods within the analytic modules will be automatically pull into the @available_data_type[comparison_scope] (i.e: @available_data_type[:course] will contain all of the methods defined in the CourseAanlytic module) @available_data_type[graph_type] contain the subset of methods that in the analytic modules that are suited for the particular graph_type.

The method uses the cross section of @available_data_type[comparison_scope] and @available_data_type[graph_type] to determine the appropriated data type options in view

To add new data type simply add a the data mining method in the corresponding analytic module than add the name of the method as a string into @available_data_type for the appropriate graph_type

= Developer Resources =
[https://github.com/q115288339/expertiza github repository for the project]
the content of this repository might change suggest using [https://github.com/expertiza/expertiza the main repository for expertiza] if the branch has already been merged

[http://www.youtube.com/watch?v=nGRxQtqaqOo&list=PLqv3LmpyB8wB76ZZjKnHBGfYqSBBnVt81 Youtube playlist about E734]

== Development Environment Setup ==
*follow the instruction on expertiza wiki page to setup the development environment http://wikis.lib.ncsu.edu/index.php/Creating_a_Linux_Development_Environment_for_the_Expertiza_Application
''note:'' you might need to delete the automated_metareview table from the database before you can successfully run db:migrate
*launch expertiza server (ruby script/server)
*visit the page from your browser (0.0.0.0:3000)
*login as admin (username: admin, password: password)
*setup access permission for the controller
**on the menu bar navigates to administration->setup->controller/action
**under the missing tab you should see analytic, click on it and select administer_assignment for the permission than click add
**under the application tab click on analytic and add index and render_sample to the action list
*add analytic to menu bar for easy access (alternatively just enter 0.0.0.0:3000/analytic in your browser)
**on the menu bar navigates to administration->setup->menu editor
**add an menu option for analytic/index
''note:'' not all of the courses and assignments in scrubbed database are real (with actual data), in order to get courses and assignments that have real data you might want to consider impersonate a real instructor in the scrubbed data base (i.e: Dr.Geringer, user id: efg) this can be done by navigating to manage...->impersonate_user from the menu bar.

== Rendering Example ==
For the benefit of future developers we provided examples on how to use the Chart class (chart.rb) to format data for the chart and how to use the jQuery stubs (_chart.html.erb) to render the chart

The example is located at expertiza/app/views/analytic/render_sample

To access the webpage created by this example visit 0.0.0.0:3000/analytic/render_sample (assuming you follow the setup instruction above)

= Future Works =
Sorted by task difficulty
*Move expertiza/app/helpers/chart.rb to expertiza/app/model and rename to analytic.rb
*Rename Chart class to Analytic
*Unit test
*Add data mining methods for meta-review
*Add options for displaying raw data point related data using scatter plot(for example: raw grades)
*Come up with other interesting data for the comparison scope
*Improve the performance of data mining methods especially score related methods.
*Add user comparisons (comparing student with student)
*Give control of options in the of graph type selection and comparison scope selection drop down to controller (require java script experience)
*Implement a static version of the index page using ruby (require java script experience)
*Strengthen access control by checking if the current user have permission to access to the data that they requested

'''IMPORTANT NOTE:''' There is a bug in the get_average_score function in the response module class WATCH OUT!

CSC/ECE 517 Spring 2013/OSS E629

2013-03-24T14:20:38Z

Cyang14: /* Our Work */

=E629: Integrating game frontend for Expertiza=

==Project Introduction==
This is a game made for the [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza] system (Ed Gehringer, NCSU). It transforms an assignment-based course into a "game" in which the player levels up and completes areas. The player doesn't receive grades; rather, he gains experience, and the professor would convert the experience values of the players at the end of the course into grades. The map is split up into distinct "rooms" unlocked by completing assignments; these are arrayed around a "center" in the middle of the map which contains portals to each room (portals which unlock as the player progresses).

==Project Requirement==
Students will need to develop a page that runs the Expertiza game in JavaScript when a user is logged in and calls the code from E407 to get the JSON string to be parsed by the frontend.

The page should basically load the frontend [http://en.wikipedia.org/wiki/JavaScript JavaScript] and point it to the [http://en.wikipedia.org/wiki/JSON JSON] string (a URL that will check to make sure that the current user is logged in correctly).

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

==Our Work==

===Experience Point Report===
In this game, the player doesn't receive grades; rather, he gains experience(XP), the most important thing about the XP points is that they can accumulate instead of just getting average as student’s final score. As an example, if a student scored 80 in the first several assignments may eventually lower his/her grade if he decides to do some extra work on extra assignment and got 70 in the extra assignment. The grade can either automatically generated by multiplying percentage score with the weight of assignment, it can also be set by the instructor manually. The professor would convert the experience values of the players at the end of the course into grades.

The previous XP logic in JSON string generating module is a piece of static code which always just sends a manually set percentage score as the XP point. A part of our work is to rewrite this XP point system.

The new XP point system is a weighted score system, where instructor can assign or automatically generate the XP point.

===Assignment Group Modules===
Assignment group module is used to group similar assignments in to one assignment group, such that as long as the student accumulates enough XP points in one assignment group, he can continue to the next group regardless whether there is any assignment in this group left untouched.

Previous assignment group from the previous project E407 is a fake module. We believe the fake module is there for testing proposes. So we rewrite the MVC code for the assignment group module and assign access privilege to it.

In addition, in previous version of backend code, the code to decide whether an assignment group is “available” to a student appears in both frontend and backend, but neither of them works. So we also rewrite that part and have it implemented at backend.

===JavaScript Code Reconstruction===
When the game is running on the Expertiza system, Expertiza should send the game the info it needs to generate the level and game state at load-time. The page should basically load the frontend JavaScript and point it to the JSON string.

Previous system fetches JSON string by sending the request and by [http://en.wikipedia.org/wiki/Polling_(computer_science) polling] the socket for response. In this strategy, the computer does nothing other than check the status of the socket until it get hit, at which point the device is accessed. In order to improve the utilization of the CPU time, we introduced [http://en.wikipedia.org/wiki/Event-driven_programming Event Driven Programming (EDP)] into our design. In EDP, the flow of the program is now driven by events. In our case, a callback closure is called when the JSON data hit the frontend.

We also Change the ig module a little bit to support visiting module variable in closure.

===Fixing Mega Bugs===
====Uncaught Exception====
Previous JSON backend throws an uncaught exception when the user has an unsubmitted assignment and he is participating in that assignment.

'''Cause''': previous code checks the submitting status prior to the privilege checking.

'''Reproduce''': imitate a new assignment, add a student as participant. Then login to the game interface as the student directly.

'''Status''': Fixed

====Gate Name Error====
Previous JSON backend didn’t set gate name correctly. Thus when having multiple assignment group (>3) and at least one hub threshold is higher than current user’s XP point, JavaScript frontend falls into infinite loop.

'''Cause''': frontend gate control code not working, we moive that part of code into backend.

'''Reproduce''': Just create multiple assignment groups, each group with a XP threshold. Depend on the browsers and browser versions, the front end may stop responding, show black screen or some portal gates not functioning.

'''Status''': Fixed

====Assignment Group Error====
In previous JSON backend, if an assignment group has X assignment in it, it will return X copy of that an assignment group, thus there’ll be X*X assignment in total. X times greater than it should be.

'''Cause''': the backend uses inner join to query the database where it should be left join.

'''Reproduce''': Create 3 assignment groups, each contains 3 assignments. Make all assignments available to student. Then log into game interface as student. One should see much more assignments there than it should be.

'''Status''': Fixed.

===Fixing Minor Bugs===
* Previous backend send all assignment data to frontend even if the student is not participate in the assignment.

* Previous JSON backend didn’t set MIME type correctly. That result in frontend code can only use low layer API to capture JSON data, when using high layer API, a silent error will occur.

* Previous MIME type result in IE and Chrome has different behavior.

* Sending a JSON string “null” to frontend will make it stop responding.

==General Introduction to the System Setup==
Please follow these steps to setup the program:

a) Download and deploy the code from
http://commondatastorage.googleapis.com/silverwzw/expertiza-json.zip

b) Drop the database “pg_development”

c) Create an empty database “pg_development”

d) Run “db:migrate”

e) Start the server

f) Login as admin

g) Go to Navigation bar -> Administration -> Setup -> Menu Editor

h) In Menu Editor page, find “Assignment Group” row (it should be the last but six row)

i) You should see an up arrow at the left column of that row, click it.

j) Then the “Assignment Group” row goes up, click the 2nd column of that “Assignment Group” row, in which it should say “assignment_groups:list”

k) In the pop up page named “Editing controller_action” there’s a drop down box with label ”Permission”, choose “administer assignment” in that drop down box, then click button “Edit”

l) Create a student account, let’s say its name is “st1”.

m) Create 2 additional assignment groups (then we will have 3 assignment groups). Set the XP value of the “Default Group” to -1. Set the XP value of the “2nd Group” to 200. Set the XP value of the “3rd Group” to 3000. (XP value of an assignment group is the threshold to open that assignment room).

n) Create 5 assignment:
Please do it carefully and ONE BY ONE in order, set all deadlines to anytime LATER than May, 2013, select the “available to student” check button.

a1 : Group = Default Group | XP = 120 | directory = /submitted_content/edit/1

a2 : Group = Default Group | XP = 200 | directory = /submitted_content/edit/2

a3 : Group = 2nd Group | XP = 2000 | directory = /submitted_content/edit/3

a4 : Group = 3rd Group | XP = 2000 | directory = /submitted_content/edit/4

a5 : Group = Default Group | XP = 2000 | directory = /submitted_content/edit/5

add participant “st1” to a1, a2, a3, a4 ( NOT for a5 )

CSC/ECE 517 Spring 2013/OSS E629

2013-03-24T14:20:04Z

Cyang14: /* Assignment Group Error */

CSC/ECE 517 Spring 2013/OSS E629

2013-03-24T14:19:30Z

Cyang14: /* Gate Name Error */

=E629: Integrating game frontend for Expertiza=

==Project Introduction==
This is a game made for the [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza] system (Ed Gehringer, NCSU). It transforms an assignment-based course into a "game" in which the player levels up and completes areas. The player doesn't receive grades; rather, he gains experience, and the professor would convert the experience values of the players at the end of the course into grades. The map is split up into distinct "rooms" unlocked by completing assignments; these are arrayed around a "center" in the middle of the map which contains portals to each room (portals which unlock as the player progresses).

==Project Requirement==
Students will need to develop a page that runs the Expertiza game in JavaScript when a user is logged in and calls the code from E407 to get the JSON string to be parsed by the frontend.

The page should basically load the frontend [http://en.wikipedia.org/wiki/JavaScript JavaScript] and point it to the [http://en.wikipedia.org/wiki/JSON JSON] string (a URL that will check to make sure that the current user is logged in correctly).

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

==Our Work==

===Experience Point Report===
In this game, the player doesn't receive grades; rather, he gains experience(XP), the most important thing about the XP points is that they can accumulate instead of just getting average as student’s final score. As an example, if a student scored 80 in the first several assignments may eventually lower his/her grade if he decides to do some extra work on extra assignment and got 70 in the extra assignment. The grade can either automatically generated by multiplying percentage score with the weight of assignment, it can also be set by the instructor manually. The professor would convert the experience values of the players at the end of the course into grades.

The previous XP logic in JSON string generating module is a piece of static code which always just sends a manually set percentage score as the XP point. A part of our work is to rewrite this XP point system.

The new XP point system is a weighted score system, where instructor can assign or automatically generate the XP point.

===Assignment Group Modules===
Assignment group module is used to group similar assignments in to one assignment group, such that as long as the student accumulates enough XP points in one assignment group, he can continue to the next group regardless whether there is any assignment in this group left untouched.

Previous assignment group from the previous project E407 is a fake module. We believe the fake module is there for testing proposes. So we rewrite the MVC code for the assignment group module and assign access privilege to it.

In addition, in previous version of backend code, the code to decide whether an assignment group is “available” to a student appears in both frontend and backend, but neither of them works. So we also rewrite that part and have it implemented at backend.

===JavaScript Code Reconstruction===
When the game is running on the Expertiza system, Expertiza should send the game the info it needs to generate the level and game state at load-time. The page should basically load the frontend JavaScript and point it to the JSON string.

Previous system fetches JSON string by sending the request and by [http://en.wikipedia.org/wiki/Polling_(computer_science) polling] the socket for response. In this strategy, the computer does nothing other than check the status of the socket until it get hit, at which point the device is accessed. In order to improve the utilization of the CPU time, we introduced [http://en.wikipedia.org/wiki/Event-driven_programming Event Driven Programming (EDP)] into our design. In EDP, the flow of the program is now driven by events. In our case, a callback closure is called when the JSON data hit the frontend.

We also Change the ig module a little bit to support visiting module variable in closure.

===Fixing Mega Bugs===
====Uncaught Exception====
Previous JSON backend throws an uncaught exception when the user has an unsubmitted assignment and he is participating in that assignment.

'''Cause''': previous code checks the submitting status prior to the privilege checking.

'''Reproduce''': imitate a new assignment, add a student as participant. Then login to the game interface as the student directly.

'''Status''': Fixed

====Gate Name Error====
Previous JSON backend didn’t set gate name correctly. Thus when having multiple assignment group (>3) and at least one hub threshold is higher than current user’s XP point, JavaScript frontend falls into infinite loop.

'''Cause''': frontend gate control code not working, we moive that part of code into backend.

'''Reproduce''': Just create multiple assignment groups, each group with a XP threshold. Depend on the browsers and browser versions, the front end may stop responding, show black screen or some portal gates not functioning.

'''Status''': Fixed

====Assignment Group Error====
In previous JSON backend, if an assignment group has X assignment in it, it will return X copy of that an assignment group, thus there’ll be X*X assignment in total. X times greater than it should be.

We fix this bug by

The following is the related code:

===Fixing Minor Bugs===
* Previous backend send all assignment data to frontend even if the student is not participate in the assignment.

* Previous JSON backend didn’t set MIME type correctly. That result in frontend code can only use low layer API to capture JSON data, when using high layer API, a silent error will occur.

* Previous MIME type result in IE and Chrome has different behavior.

* Sending a JSON string “null” to frontend will make it stop responding.

==General Introduction to the System Setup==
Please follow these steps to setup the program:

a) Download and deploy the code from
http://commondatastorage.googleapis.com/silverwzw/expertiza-json.zip

b) Drop the database “pg_development”

c) Create an empty database “pg_development”

d) Run “db:migrate”

e) Start the server

f) Login as admin

g) Go to Navigation bar -> Administration -> Setup -> Menu Editor

h) In Menu Editor page, find “Assignment Group” row (it should be the last but six row)

i) You should see an up arrow at the left column of that row, click it.

j) Then the “Assignment Group” row goes up, click the 2nd column of that “Assignment Group” row, in which it should say “assignment_groups:list”

k) In the pop up page named “Editing controller_action” there’s a drop down box with label ”Permission”, choose “administer assignment” in that drop down box, then click button “Edit”

l) Create a student account, let’s say its name is “st1”.

m) Create 2 additional assignment groups (then we will have 3 assignment groups). Set the XP value of the “Default Group” to -1. Set the XP value of the “2nd Group” to 200. Set the XP value of the “3rd Group” to 3000. (XP value of an assignment group is the threshold to open that assignment room).

n) Create 5 assignment:
Please do it carefully and ONE BY ONE in order, set all deadlines to anytime LATER than May, 2013, select the “available to student” check button.

a1 : Group = Default Group | XP = 120 | directory = /submitted_content/edit/1

a2 : Group = Default Group | XP = 200 | directory = /submitted_content/edit/2

a3 : Group = 2nd Group | XP = 2000 | directory = /submitted_content/edit/3

a4 : Group = 3rd Group | XP = 2000 | directory = /submitted_content/edit/4

a5 : Group = Default Group | XP = 2000 | directory = /submitted_content/edit/5

add participant “st1” to a1, a2, a3, a4 ( NOT for a5 )

CSC/ECE 517 Spring 2013/OSS E629

2013-03-24T14:19:01Z

Cyang14: /* Uncaught Exception */

=E629: Integrating game frontend for Expertiza=

==Project Introduction==
This is a game made for the [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza] system (Ed Gehringer, NCSU). It transforms an assignment-based course into a "game" in which the player levels up and completes areas. The player doesn't receive grades; rather, he gains experience, and the professor would convert the experience values of the players at the end of the course into grades. The map is split up into distinct "rooms" unlocked by completing assignments; these are arrayed around a "center" in the middle of the map which contains portals to each room (portals which unlock as the player progresses).

==Project Requirement==
Students will need to develop a page that runs the Expertiza game in JavaScript when a user is logged in and calls the code from E407 to get the JSON string to be parsed by the frontend.

The page should basically load the frontend [http://en.wikipedia.org/wiki/JavaScript JavaScript] and point it to the [http://en.wikipedia.org/wiki/JSON JSON] string (a URL that will check to make sure that the current user is logged in correctly).

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

==Our Work==

===Experience Point Report===
In this game, the player doesn't receive grades; rather, he gains experience(XP), the most important thing about the XP points is that they can accumulate instead of just getting average as student’s final score. As an example, if a student scored 80 in the first several assignments may eventually lower his/her grade if he decides to do some extra work on extra assignment and got 70 in the extra assignment. The grade can either automatically generated by multiplying percentage score with the weight of assignment, it can also be set by the instructor manually. The professor would convert the experience values of the players at the end of the course into grades.

The previous XP logic in JSON string generating module is a piece of static code which always just sends a manually set percentage score as the XP point. A part of our work is to rewrite this XP point system.

The new XP point system is a weighted score system, where instructor can assign or automatically generate the XP point.

===Assignment Group Modules===
Assignment group module is used to group similar assignments in to one assignment group, such that as long as the student accumulates enough XP points in one assignment group, he can continue to the next group regardless whether there is any assignment in this group left untouched.

Previous assignment group from the previous project E407 is a fake module. We believe the fake module is there for testing proposes. So we rewrite the MVC code for the assignment group module and assign access privilege to it.

In addition, in previous version of backend code, the code to decide whether an assignment group is “available” to a student appears in both frontend and backend, but neither of them works. So we also rewrite that part and have it implemented at backend.

===JavaScript Code Reconstruction===
When the game is running on the Expertiza system, Expertiza should send the game the info it needs to generate the level and game state at load-time. The page should basically load the frontend JavaScript and point it to the JSON string.

Previous system fetches JSON string by sending the request and by [http://en.wikipedia.org/wiki/Polling_(computer_science) polling] the socket for response. In this strategy, the computer does nothing other than check the status of the socket until it get hit, at which point the device is accessed. In order to improve the utilization of the CPU time, we introduced [http://en.wikipedia.org/wiki/Event-driven_programming Event Driven Programming (EDP)] into our design. In EDP, the flow of the program is now driven by events. In our case, a callback closure is called when the JSON data hit the frontend.

We also Change the ig module a little bit to support visiting module variable in closure.

===Fixing Mega Bugs===
====Uncaught Exception====
Previous JSON backend throws an uncaught exception when the user has an unsubmitted assignment and he is participating in that assignment.

'''Cause''': previous code checks the submitting status prior to the privilege checking.

'''Reproduce''': imitate a new assignment, add a student as participant. Then login to the game interface as the student directly.

'''Status''': Fixed

====Gate Name Error====
Previous JSON backend didn’t set gate name correctly. Thus when having multiple assignment group (>3) and at least one hub threshold is higher than current user’s XP point, JavaScript frontend falls into infinite loop.

We fix this bug by

The following is the related code:

====Assignment Group Error====
In previous JSON backend, if an assignment group has X assignment in it, it will return X copy of that an assignment group, thus there’ll be X*X assignment in total. X times greater than it should be.

We fix this bug by

The following is the related code:

===Fixing Minor Bugs===
* Previous backend send all assignment data to frontend even if the student is not participate in the assignment.

* Previous JSON backend didn’t set MIME type correctly. That result in frontend code can only use low layer API to capture JSON data, when using high layer API, a silent error will occur.

* Previous MIME type result in IE and Chrome has different behavior.

* Sending a JSON string “null” to frontend will make it stop responding.

==General Introduction to the System Setup==
Please follow these steps to setup the program:

a) Download and deploy the code from
http://commondatastorage.googleapis.com/silverwzw/expertiza-json.zip

b) Drop the database “pg_development”

c) Create an empty database “pg_development”

d) Run “db:migrate”

e) Start the server

f) Login as admin

g) Go to Navigation bar -> Administration -> Setup -> Menu Editor

h) In Menu Editor page, find “Assignment Group” row (it should be the last but six row)

i) You should see an up arrow at the left column of that row, click it.

j) Then the “Assignment Group” row goes up, click the 2nd column of that “Assignment Group” row, in which it should say “assignment_groups:list”

k) In the pop up page named “Editing controller_action” there’s a drop down box with label ”Permission”, choose “administer assignment” in that drop down box, then click button “Edit”

l) Create a student account, let’s say its name is “st1”.

m) Create 2 additional assignment groups (then we will have 3 assignment groups). Set the XP value of the “Default Group” to -1. Set the XP value of the “2nd Group” to 200. Set the XP value of the “3rd Group” to 3000. (XP value of an assignment group is the threshold to open that assignment room).

n) Create 5 assignment:
Please do it carefully and ONE BY ONE in order, set all deadlines to anytime LATER than May, 2013, select the “available to student” check button.

a1 : Group = Default Group | XP = 120 | directory = /submitted_content/edit/1

a2 : Group = Default Group | XP = 200 | directory = /submitted_content/edit/2

a3 : Group = 2nd Group | XP = 2000 | directory = /submitted_content/edit/3

a4 : Group = 3rd Group | XP = 2000 | directory = /submitted_content/edit/4

a5 : Group = Default Group | XP = 2000 | directory = /submitted_content/edit/5

add participant “st1” to a1, a2, a3, a4 ( NOT for a5 )

CSC/ECE 517 Spring 2013/OSS E629

2013-03-24T14:18:39Z

Cyang14: /* Uncaught Exception */

=E629: Integrating game frontend for Expertiza=

==Project Introduction==
This is a game made for the [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza] system (Ed Gehringer, NCSU). It transforms an assignment-based course into a "game" in which the player levels up and completes areas. The player doesn't receive grades; rather, he gains experience, and the professor would convert the experience values of the players at the end of the course into grades. The map is split up into distinct "rooms" unlocked by completing assignments; these are arrayed around a "center" in the middle of the map which contains portals to each room (portals which unlock as the player progresses).

==Project Requirement==
Students will need to develop a page that runs the Expertiza game in JavaScript when a user is logged in and calls the code from E407 to get the JSON string to be parsed by the frontend.

The page should basically load the frontend [http://en.wikipedia.org/wiki/JavaScript JavaScript] and point it to the [http://en.wikipedia.org/wiki/JSON JSON] string (a URL that will check to make sure that the current user is logged in correctly).

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

==Our Work==

===Experience Point Report===
In this game, the player doesn't receive grades; rather, he gains experience(XP), the most important thing about the XP points is that they can accumulate instead of just getting average as student’s final score. As an example, if a student scored 80 in the first several assignments may eventually lower his/her grade if he decides to do some extra work on extra assignment and got 70 in the extra assignment. The grade can either automatically generated by multiplying percentage score with the weight of assignment, it can also be set by the instructor manually. The professor would convert the experience values of the players at the end of the course into grades.

The previous XP logic in JSON string generating module is a piece of static code which always just sends a manually set percentage score as the XP point. A part of our work is to rewrite this XP point system.

The new XP point system is a weighted score system, where instructor can assign or automatically generate the XP point.

===Assignment Group Modules===
Assignment group module is used to group similar assignments in to one assignment group, such that as long as the student accumulates enough XP points in one assignment group, he can continue to the next group regardless whether there is any assignment in this group left untouched.

Previous assignment group from the previous project E407 is a fake module. We believe the fake module is there for testing proposes. So we rewrite the MVC code for the assignment group module and assign access privilege to it.

In addition, in previous version of backend code, the code to decide whether an assignment group is “available” to a student appears in both frontend and backend, but neither of them works. So we also rewrite that part and have it implemented at backend.

===JavaScript Code Reconstruction===
When the game is running on the Expertiza system, Expertiza should send the game the info it needs to generate the level and game state at load-time. The page should basically load the frontend JavaScript and point it to the JSON string.

Previous system fetches JSON string by sending the request and by [http://en.wikipedia.org/wiki/Polling_(computer_science) polling] the socket for response. In this strategy, the computer does nothing other than check the status of the socket until it get hit, at which point the device is accessed. In order to improve the utilization of the CPU time, we introduced [http://en.wikipedia.org/wiki/Event-driven_programming Event Driven Programming (EDP)] into our design. In EDP, the flow of the program is now driven by events. In our case, a callback closure is called when the JSON data hit the frontend.

We also Change the ig module a little bit to support visiting module variable in closure.

===Fixing Mega Bugs===
====Uncaught Exception====
Previous JSON backend throws an uncaught exception when the user has an unsubmitted assignment and he is participating in that assignment.

Cause: previous code checks the submitting status prior to the privilege checking.

Reproduce: imitate a new assignment, add a student as participant. Then login to the game interface as the student directly.

Status: Fixed

====Gate Name Error====
Previous JSON backend didn’t set gate name correctly. Thus when having multiple assignment group (>3) and at least one hub threshold is higher than current user’s XP point, JavaScript frontend falls into infinite loop.

We fix this bug by

The following is the related code:

====Assignment Group Error====
In previous JSON backend, if an assignment group has X assignment in it, it will return X copy of that an assignment group, thus there’ll be X*X assignment in total. X times greater than it should be.

We fix this bug by

The following is the related code:

===Fixing Minor Bugs===
* Previous backend send all assignment data to frontend even if the student is not participate in the assignment.

* Previous JSON backend didn’t set MIME type correctly. That result in frontend code can only use low layer API to capture JSON data, when using high layer API, a silent error will occur.

* Previous MIME type result in IE and Chrome has different behavior.

* Sending a JSON string “null” to frontend will make it stop responding.

==General Introduction to the System Setup==
Please follow these steps to setup the program:

a) Download and deploy the code from
http://commondatastorage.googleapis.com/silverwzw/expertiza-json.zip

b) Drop the database “pg_development”

c) Create an empty database “pg_development”

d) Run “db:migrate”

e) Start the server

f) Login as admin

g) Go to Navigation bar -> Administration -> Setup -> Menu Editor

h) In Menu Editor page, find “Assignment Group” row (it should be the last but six row)

i) You should see an up arrow at the left column of that row, click it.

j) Then the “Assignment Group” row goes up, click the 2nd column of that “Assignment Group” row, in which it should say “assignment_groups:list”

k) In the pop up page named “Editing controller_action” there’s a drop down box with label ”Permission”, choose “administer assignment” in that drop down box, then click button “Edit”

l) Create a student account, let’s say its name is “st1”.

m) Create 2 additional assignment groups (then we will have 3 assignment groups). Set the XP value of the “Default Group” to -1. Set the XP value of the “2nd Group” to 200. Set the XP value of the “3rd Group” to 3000. (XP value of an assignment group is the threshold to open that assignment room).

n) Create 5 assignment:
Please do it carefully and ONE BY ONE in order, set all deadlines to anytime LATER than May, 2013, select the “available to student” check button.

a1 : Group = Default Group | XP = 120 | directory = /submitted_content/edit/1

a2 : Group = Default Group | XP = 200 | directory = /submitted_content/edit/2

a3 : Group = 2nd Group | XP = 2000 | directory = /submitted_content/edit/3

a4 : Group = 3rd Group | XP = 2000 | directory = /submitted_content/edit/4

a5 : Group = Default Group | XP = 2000 | directory = /submitted_content/edit/5

add participant “st1” to a1, a2, a3, a4 ( NOT for a5 )

CSC/ECE 517 Spring 2013/OSS E629

2013-03-24T14:17:30Z

Cyang14: /* Our Work */

=E629: Integrating game frontend for Expertiza=

==Project Introduction==
This is a game made for the [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza] system (Ed Gehringer, NCSU). It transforms an assignment-based course into a "game" in which the player levels up and completes areas. The player doesn't receive grades; rather, he gains experience, and the professor would convert the experience values of the players at the end of the course into grades. The map is split up into distinct "rooms" unlocked by completing assignments; these are arrayed around a "center" in the middle of the map which contains portals to each room (portals which unlock as the player progresses).

==Project Requirement==
Students will need to develop a page that runs the Expertiza game in JavaScript when a user is logged in and calls the code from E407 to get the JSON string to be parsed by the frontend.

The page should basically load the frontend [http://en.wikipedia.org/wiki/JavaScript JavaScript] and point it to the [http://en.wikipedia.org/wiki/JSON JSON] string (a URL that will check to make sure that the current user is logged in correctly).

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

==Our Work==

===Experience Point Report===
In this game, the player doesn't receive grades; rather, he gains experience(XP), the most important thing about the XP points is that they can accumulate instead of just getting average as student’s final score. As an example, if a student scored 80 in the first several assignments may eventually lower his/her grade if he decides to do some extra work on extra assignment and got 70 in the extra assignment. The grade can either automatically generated by multiplying percentage score with the weight of assignment, it can also be set by the instructor manually. The professor would convert the experience values of the players at the end of the course into grades.

The previous XP logic in JSON string generating module is a piece of static code which always just sends a manually set percentage score as the XP point. A part of our work is to rewrite this XP point system.

The new XP point system is a weighted score system, where instructor can assign or automatically generate the XP point.

===Assignment Group Modules===
Assignment group module is used to group similar assignments in to one assignment group, such that as long as the student accumulates enough XP points in one assignment group, he can continue to the next group regardless whether there is any assignment in this group left untouched.

Previous assignment group from the previous project E407 is a fake module. We believe the fake module is there for testing proposes. So we rewrite the MVC code for the assignment group module and assign access privilege to it.

In addition, in previous version of backend code, the code to decide whether an assignment group is “available” to a student appears in both frontend and backend, but neither of them works. So we also rewrite that part and have it implemented at backend.

===JavaScript Code Reconstruction===
When the game is running on the Expertiza system, Expertiza should send the game the info it needs to generate the level and game state at load-time. The page should basically load the frontend JavaScript and point it to the JSON string.

Previous system fetches JSON string by sending the request and by [http://en.wikipedia.org/wiki/Polling_(computer_science) polling] the socket for response. In this strategy, the computer does nothing other than check the status of the socket until it get hit, at which point the device is accessed. In order to improve the utilization of the CPU time, we introduced [http://en.wikipedia.org/wiki/Event-driven_programming Event Driven Programming (EDP)] into our design. In EDP, the flow of the program is now driven by events. In our case, a callback closure is called when the JSON data hit the frontend.

We also Change the ig module a little bit to support visiting module variable in closure.

===Fixing Mega Bugs===
====Uncaught Exception====
Previous JSON backend throws an uncaught exception when the user has an unsubmitted assignment and he is participating in that assignment.

We fix this bug by

The following is the related code:

====Gate Name Error====
Previous JSON backend didn’t set gate name correctly. Thus when having multiple assignment group (>3) and at least one hub threshold is higher than current user’s XP point, JavaScript frontend falls into infinite loop.

We fix this bug by

The following is the related code:

====Assignment Group Error====
In previous JSON backend, if an assignment group has X assignment in it, it will return X copy of that an assignment group, thus there’ll be X*X assignment in total. X times greater than it should be.

We fix this bug by

The following is the related code:

===Fixing Minor Bugs===
* Previous backend send all assignment data to frontend even if the student is not participate in the assignment.

* Previous JSON backend didn’t set MIME type correctly. That result in frontend code can only use low layer API to capture JSON data, when using high layer API, a silent error will occur.

* Previous MIME type result in IE and Chrome has different behavior.

* Sending a JSON string “null” to frontend will make it stop responding.

==General Introduction to the System Setup==
Please follow these steps to setup the program:

a) Download and deploy the code from
http://commondatastorage.googleapis.com/silverwzw/expertiza-json.zip

b) Drop the database “pg_development”

c) Create an empty database “pg_development”

d) Run “db:migrate”

e) Start the server

f) Login as admin

g) Go to Navigation bar -> Administration -> Setup -> Menu Editor

h) In Menu Editor page, find “Assignment Group” row (it should be the last but six row)

i) You should see an up arrow at the left column of that row, click it.

j) Then the “Assignment Group” row goes up, click the 2nd column of that “Assignment Group” row, in which it should say “assignment_groups:list”

k) In the pop up page named “Editing controller_action” there’s a drop down box with label ”Permission”, choose “administer assignment” in that drop down box, then click button “Edit”

l) Create a student account, let’s say its name is “st1”.

m) Create 2 additional assignment groups (then we will have 3 assignment groups). Set the XP value of the “Default Group” to -1. Set the XP value of the “2nd Group” to 200. Set the XP value of the “3rd Group” to 3000. (XP value of an assignment group is the threshold to open that assignment room).

n) Create 5 assignment:
Please do it carefully and ONE BY ONE in order, set all deadlines to anytime LATER than May, 2013, select the “available to student” check button.

a1 : Group = Default Group | XP = 120 | directory = /submitted_content/edit/1

a2 : Group = Default Group | XP = 200 | directory = /submitted_content/edit/2

a3 : Group = 2nd Group | XP = 2000 | directory = /submitted_content/edit/3

a4 : Group = 3rd Group | XP = 2000 | directory = /submitted_content/edit/4

a5 : Group = Default Group | XP = 2000 | directory = /submitted_content/edit/5

add participant “st1” to a1, a2, a3, a4 ( NOT for a5 )

CSC/ECE 517 Spring 2013/OSS E629

2013-03-24T14:16:36Z

Cyang14: /* JavaScript Code Reconstruction */

=E629: Integrating game frontend for Expertiza=

==Project Introduction==
This is a game made for the [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza] system (Ed Gehringer, NCSU). It transforms an assignment-based course into a "game" in which the player levels up and completes areas. The player doesn't receive grades; rather, he gains experience, and the professor would convert the experience values of the players at the end of the course into grades. The map is split up into distinct "rooms" unlocked by completing assignments; these are arrayed around a "center" in the middle of the map which contains portals to each room (portals which unlock as the player progresses).

==Project Requirement==
Students will need to develop a page that runs the Expertiza game in JavaScript when a user is logged in and calls the code from E407 to get the JSON string to be parsed by the frontend.

The page should basically load the frontend [http://en.wikipedia.org/wiki/JavaScript JavaScript] and point it to the [http://en.wikipedia.org/wiki/JSON JSON] string (a URL that will check to make sure that the current user is logged in correctly).

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

==Our Work==

===Experience Point Report===
In this game, the player doesn't receive grades; rather, he gains experience(XP), the most important thing about the XP points is that they can accumulate instead of just getting average as student’s final score. As an example, if a student scored 80 in the first several assignments may eventually lower his/her grade if he decides to do some extra work on extra assignment and got 70 in the extra assignment. The grade can either automatically generated by multiplying percentage score with the weight of assignment, it can also be set by the instructor manually. The professor would convert the experience values of the players at the end of the course into grades.

The previous XP logic in JSON string generating module is a piece of static code which always just sends a manually set percentage score as the XP point. A part of our work is to rewrite this XP point system.

The new XP point system is a weighted score system, where instructor can assign or automatically generate the XP point.

===Assignment Group Modules===
Assignment group module is used to group similar assignments in to one assignment group, such that as long as the student accumulates enough XP points in one assignment group, he can continue to the next group regardless whether there is any assignment in this group left untouched.

Previous assignment group from the previous project E407 is a fake module. We believe the fake module is there for testing proposes. So we rewrite the MVC code for the assignment group module and assign access privilege to it.

In addition, in previous version of backend code, the code to decide whether an assignment group is “available” to a student appears in both frontend and backend, but neither of them works. So we also rewrite that part and have it implemented at backend.

===JavaScript Code Reconstruction===
When the game is running on the Expertiza system, Expertiza should send the game the info it needs to generate the level and game state at load-time. The page should basically load the frontend JavaScript and point it to the JSON string.

Previous system fetches JSON string by sending the request and by [http://en.wikipedia.org/wiki/Polling_(computer_science) polling] the socket for response. In this strategy, the computer does nothing other than check the status of the socket until it get hit, at which point the device is accessed. In order to improve the utilization of the CPU time, we introduced [http://en.wikipedia.org/wiki/Event-driven_programming Event Driven Programming (EDP)] into our design. In EDP, the flow of the program is now driven by events. In our case, a callback closure is called when the JSON data hit the frontend.

We also Change the ig module a little bit to support visiting module variable in closure.

===Fixing Mega Bugs===
====Uncaught Exception====
Previous JSON backend throws an uncaught exception when the user has an unsubmitted assignment and he is participating in that assignment.

We fix this bug by

The following is the related code:

====Gate Name Error====
Previous JSON backend didn’t set gate name correctly. Thus when having multiple assignment group (>3) and at least one hub threshold is higher than current user’s XP point, JavaScript frontend falls into infinite loop.

We fix this bug by

The following is the related code:

====Assignment Group Error====
In previous JSON backend, if an assignment group has X assignment in it, it will return X copy of that an assignment group, thus there’ll be X*X assignment in total. X times greater than it should be.

We fix this bug by

The following is the related code:

===Fixing Minor Bugs===
* Previous backend send all assignment data to frontend even if the student is not participate in the assignment.

* Previous JSON backend didn’t set MIME type correctly. That result in frontend code can only use low layer API to capture JSON data, when using high layer API, a silent error will occur.

* Previous MIME type result in IE and Chrome has different behavior.

* Sending a JSON string “null” to frontend will make it stop responding.

==General Introduction to the System Setup==
Please follow these steps to setup the program:

a) Download and deploy the code from
http://commondatastorage.googleapis.com/silverwzw/expertiza-json.zip

b) Drop the database “pg_development”

c) Create an empty database “pg_development”

d) Run “db:migrate”

e) Start the server

f) Login as admin

g) Go to Navigation bar -> Administration -> Setup -> Menu Editor

h) In Menu Editor page, find “Assignment Group” row (it should be the last but six row)

i) You should see an up arrow at the left column of that row, click it.

j) Then the “Assignment Group” row goes up, click the 2nd column of that “Assignment Group” row, in which it should say “assignment_groups:list”

k) In the pop up page named “Editing controller_action” there’s a drop down box with label ”Permission”, choose “administer assignment” in that drop down box, then click button “Edit”

l) Create a student account, let’s say its name is “st1”.

m) Create 2 additional assignment groups (then we will have 3 assignment groups). Set the XP value of the “Default Group” to -1. Set the XP value of the “2nd Group” to 200. Set the XP value of the “3rd Group” to 3000. (XP value of an assignment group is the threshold to open that assignment room).

n) Create 5 assignment:
Please do it carefully and ONE BY ONE in order, set all deadlines to anytime LATER than May, 2013, select the “available to student” check button.

a1 : Group = Default Group | XP = 120 | directory = /submitted_content/edit/1

a2 : Group = Default Group | XP = 200 | directory = /submitted_content/edit/2

a3 : Group = 2nd Group | XP = 2000 | directory = /submitted_content/edit/3

a4 : Group = 3rd Group | XP = 2000 | directory = /submitted_content/edit/4

a5 : Group = Default Group | XP = 2000 | directory = /submitted_content/edit/5

add participant “st1” to a1, a2, a3, a4 ( NOT for a5 )

CSC/ECE 517 Spring 2013/OSS E629

2013-03-24T14:12:13Z

Cyang14: /* Assignment Group Modules */

=E629: Integrating game frontend for Expertiza=

==Project Introduction==
This is a game made for the [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza] system (Ed Gehringer, NCSU). It transforms an assignment-based course into a "game" in which the player levels up and completes areas. The player doesn't receive grades; rather, he gains experience, and the professor would convert the experience values of the players at the end of the course into grades. The map is split up into distinct "rooms" unlocked by completing assignments; these are arrayed around a "center" in the middle of the map which contains portals to each room (portals which unlock as the player progresses).

==Project Requirement==
Students will need to develop a page that runs the Expertiza game in JavaScript when a user is logged in and calls the code from E407 to get the JSON string to be parsed by the frontend.

The page should basically load the frontend [http://en.wikipedia.org/wiki/JavaScript JavaScript] and point it to the [http://en.wikipedia.org/wiki/JSON JSON] string (a URL that will check to make sure that the current user is logged in correctly).

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

==Our Work==

===Experience Point Report===
In this game, the player doesn't receive grades; rather, he gains experience(XP), the most important thing about the XP points is that they can accumulate instead of just getting average as student’s final score. As an example, if a student scored 80 in the first several assignments may eventually lower his/her grade if he decides to do some extra work on extra assignment and got 70 in the extra assignment. The grade can either automatically generated by multiplying percentage score with the weight of assignment, it can also be set by the instructor manually. The professor would convert the experience values of the players at the end of the course into grades.

The previous XP logic in JSON string generating module is a piece of static code which always just sends a manually set percentage score as the XP point. A part of our work is to rewrite this XP point system.

The new XP point system is a weighted score system, where instructor can assign or automatically generate the XP point.

===Assignment Group Modules===
Assignment group module is used to group similar assignments in to one assignment group, such that as long as the student accumulates enough XP points in one assignment group, he can continue to the next group regardless whether there is any assignment in this group left untouched.

Previous assignment group from the previous project E407 is a fake module. We believe the fake module is there for testing proposes. So we rewrite the MVC code for the assignment group module and assign access privilege to it.

In addition, in previous version of backend code, the code to decide whether an assignment group is “available” to a student appears in both frontend and backend, but neither of them works. So we also rewrite that part and have it implemented at backend.

===JavaScript Code Reconstruction===
When the game is running on the Expertiza system, Expertiza should send the game the info it needs to generate the level and game state at load-time. The page should basically load the frontend JavaScript and point it to the JSON string.

Previous system get JSON by [http://en.wikipedia.org/wiki/Polling_(computer_science) polling] the server. In this strategy, the computer does nothing other than check the status of the backend until it is ready, at which point the device is accessed. In order to improve the efficiency of the CPU, we introduced [http://en.wikipedia.org/wiki/Event-driven_programming Event Driven Programming (EDP)] into our design. In EDP, the flow of the program is determined by events. In our case, a callback closure is called when the JSON data hit the frontend.

We also Change the ig module a little bit to support visiting module variable in closure.

The related code is as following:

===Fixing Mega Bugs===
====Uncaught Exception====
Previous JSON backend throws an uncaught exception when the user has an unsubmitted assignment and he is participating in that assignment.

We fix this bug by

The following is the related code:

====Gate Name Error====
Previous JSON backend didn’t set gate name correctly. Thus when having multiple assignment group (>3) and at least one hub threshold is higher than current user’s XP point, JavaScript frontend falls into infinite loop.

We fix this bug by

The following is the related code:

====Assignment Group Error====
In previous JSON backend, if an assignment group has X assignment in it, it will return X copy of that an assignment group, thus there’ll be X*X assignment in total. X times greater than it should be.

We fix this bug by

The following is the related code:

===Fixing Minor Bugs===
* Previous backend send all assignment data to frontend even if the student is not participate in the assignment.

* Previous JSON backend didn’t set MIME type correctly. That result in frontend code can only use low layer API to capture JSON data, when using high layer API, a silent error will occur.

* Previous MIME type result in IE and Chrome has different behavior.

* Sending a JSON string “null” to frontend will make it stop responding.

==General Introduction to the System Setup==
Please follow these steps to setup the program:

a) Download and deploy the code from
http://commondatastorage.googleapis.com/silverwzw/expertiza-json.zip

b) Drop the database “pg_development”

c) Create an empty database “pg_development”

d) Run “db:migrate”

e) Start the server

f) Login as admin

g) Go to Navigation bar -> Administration -> Setup -> Menu Editor

h) In Menu Editor page, find “Assignment Group” row (it should be the last but six row)

i) You should see an up arrow at the left column of that row, click it.

j) Then the “Assignment Group” row goes up, click the 2nd column of that “Assignment Group” row, in which it should say “assignment_groups:list”

k) In the pop up page named “Editing controller_action” there’s a drop down box with label ”Permission”, choose “administer assignment” in that drop down box, then click button “Edit”

l) Create a student account, let’s say its name is “st1”.

m) Create 2 additional assignment groups (then we will have 3 assignment groups). Set the XP value of the “Default Group” to -1. Set the XP value of the “2nd Group” to 200. Set the XP value of the “3rd Group” to 3000. (XP value of an assignment group is the threshold to open that assignment room).

n) Create 5 assignment:
Please do it carefully and ONE BY ONE in order, set all deadlines to anytime LATER than May, 2013, select the “available to student” check button.

a1 : Group = Default Group | XP = 120 | directory = /submitted_content/edit/1

a2 : Group = Default Group | XP = 200 | directory = /submitted_content/edit/2

a3 : Group = 2nd Group | XP = 2000 | directory = /submitted_content/edit/3

a4 : Group = 3rd Group | XP = 2000 | directory = /submitted_content/edit/4

a5 : Group = Default Group | XP = 2000 | directory = /submitted_content/edit/5

add participant “st1” to a1, a2, a3, a4 ( NOT for a5 )

CSC/ECE 517 Spring 2013/OSS E629

2013-03-24T14:10:41Z

Cyang14: /* Experience Point Report */

=E629: Integrating game frontend for Expertiza=

==Project Introduction==
This is a game made for the [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza] system (Ed Gehringer, NCSU). It transforms an assignment-based course into a "game" in which the player levels up and completes areas. The player doesn't receive grades; rather, he gains experience, and the professor would convert the experience values of the players at the end of the course into grades. The map is split up into distinct "rooms" unlocked by completing assignments; these are arrayed around a "center" in the middle of the map which contains portals to each room (portals which unlock as the player progresses).

==Project Requirement==
Students will need to develop a page that runs the Expertiza game in JavaScript when a user is logged in and calls the code from E407 to get the JSON string to be parsed by the frontend.

The page should basically load the frontend [http://en.wikipedia.org/wiki/JavaScript JavaScript] and point it to the [http://en.wikipedia.org/wiki/JSON JSON] string (a URL that will check to make sure that the current user is logged in correctly).

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

==Our Work==

===Experience Point Report===
In this game, the player doesn't receive grades; rather, he gains experience(XP), the most important thing about the XP points is that they can accumulate instead of just getting average as student’s final score. As an example, if a student scored 80 in the first several assignments may eventually lower his/her grade if he decides to do some extra work on extra assignment and got 70 in the extra assignment. The grade can either automatically generated by multiplying percentage score with the weight of assignment, it can also be set by the instructor manually. The professor would convert the experience values of the players at the end of the course into grades.

The previous XP logic in JSON string generating module is a piece of static code which always just sends a manually set percentage score as the XP point. A part of our work is to rewrite this XP point system.

The new XP point system is a weighted score system, where instructor can assign or automatically generate the XP point.

===Assignment Group Modules===
Assignment group module is used to

Previous assignment group from the previous project E407 is a fake module. In this version, the code to decide whether an assignment group is “available” to a student should appear in both frontend and backend, but neither of them works. So we rewrite it and assign privileges to it.

The following is the code for the assignment group module:

===JavaScript Code Reconstruction===
When the game is running on the Expertiza system, Expertiza should send the game the info it needs to generate the level and game state at load-time. The page should basically load the frontend JavaScript and point it to the JSON string.

Previous system get JSON by [http://en.wikipedia.org/wiki/Polling_(computer_science) polling] the server. In this strategy, the computer does nothing other than check the status of the backend until it is ready, at which point the device is accessed. In order to improve the efficiency of the CPU, we introduced [http://en.wikipedia.org/wiki/Event-driven_programming Event Driven Programming (EDP)] into our design. In EDP, the flow of the program is determined by events. In our case, a callback closure is called when the JSON data hit the frontend.

We also Change the ig module a little bit to support visiting module variable in closure.

The related code is as following:

===Fixing Mega Bugs===
====Uncaught Exception====
Previous JSON backend throws an uncaught exception when the user has an unsubmitted assignment and he is participating in that assignment.

We fix this bug by

The following is the related code:

====Gate Name Error====
Previous JSON backend didn’t set gate name correctly. Thus when having multiple assignment group (>3) and at least one hub threshold is higher than current user’s XP point, JavaScript frontend falls into infinite loop.

We fix this bug by

The following is the related code:

====Assignment Group Error====
In previous JSON backend, if an assignment group has X assignment in it, it will return X copy of that an assignment group, thus there’ll be X*X assignment in total. X times greater than it should be.

We fix this bug by

The following is the related code:

===Fixing Minor Bugs===
* Previous backend send all assignment data to frontend even if the student is not participate in the assignment.

* Previous JSON backend didn’t set MIME type correctly. That result in frontend code can only use low layer API to capture JSON data, when using high layer API, a silent error will occur.

* Previous MIME type result in IE and Chrome has different behavior.

* Sending a JSON string “null” to frontend will make it stop responding.

==General Introduction to the System Setup==
Please follow these steps to setup the program:

a) Download and deploy the code from
http://commondatastorage.googleapis.com/silverwzw/expertiza-json.zip

b) Drop the database “pg_development”

c) Create an empty database “pg_development”

d) Run “db:migrate”

e) Start the server

f) Login as admin

g) Go to Navigation bar -> Administration -> Setup -> Menu Editor

h) In Menu Editor page, find “Assignment Group” row (it should be the last but six row)

i) You should see an up arrow at the left column of that row, click it.

j) Then the “Assignment Group” row goes up, click the 2nd column of that “Assignment Group” row, in which it should say “assignment_groups:list”

k) In the pop up page named “Editing controller_action” there’s a drop down box with label ”Permission”, choose “administer assignment” in that drop down box, then click button “Edit”

l) Create a student account, let’s say its name is “st1”.

m) Create 2 additional assignment groups (then we will have 3 assignment groups). Set the XP value of the “Default Group” to -1. Set the XP value of the “2nd Group” to 200. Set the XP value of the “3rd Group” to 3000. (XP value of an assignment group is the threshold to open that assignment room).

n) Create 5 assignment:
Please do it carefully and ONE BY ONE in order, set all deadlines to anytime LATER than May, 2013, select the “available to student” check button.

a1 : Group = Default Group | XP = 120 | directory = /submitted_content/edit/1

a2 : Group = Default Group | XP = 200 | directory = /submitted_content/edit/2

a3 : Group = 2nd Group | XP = 2000 | directory = /submitted_content/edit/3

a4 : Group = 3rd Group | XP = 2000 | directory = /submitted_content/edit/4

a5 : Group = Default Group | XP = 2000 | directory = /submitted_content/edit/5

add participant “st1” to a1, a2, a3, a4 ( NOT for a5 )

CSC/ECE 517 Spring 2013/OSS E629

2013-03-24T14:10:09Z

Cyang14: /* Experience Point Report */

=E629: Integrating game frontend for Expertiza=

==Project Introduction==
This is a game made for the [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza] system (Ed Gehringer, NCSU). It transforms an assignment-based course into a "game" in which the player levels up and completes areas. The player doesn't receive grades; rather, he gains experience, and the professor would convert the experience values of the players at the end of the course into grades. The map is split up into distinct "rooms" unlocked by completing assignments; these are arrayed around a "center" in the middle of the map which contains portals to each room (portals which unlock as the player progresses).

==Project Requirement==
Students will need to develop a page that runs the Expertiza game in JavaScript when a user is logged in and calls the code from E407 to get the JSON string to be parsed by the frontend.

The page should basically load the frontend [http://en.wikipedia.org/wiki/JavaScript JavaScript] and point it to the [http://en.wikipedia.org/wiki/JSON JSON] string (a URL that will check to make sure that the current user is logged in correctly).

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

==Our Work==

===Experience Point Report===
In this game, the player doesn't receive grades; rather, he gains experience(XP), ), the most important thing about the XP points is that they can accumulate instead of just getting average as student’s final score. As an example, if a student scored 80 in the first several assignments may eventually lower his/her grade if he decides to do some extra work on extra assignment and got 70 in the extra assignment. The grade can either automatically generated by multiplying percentage score with the weight of assignment, it can also be set by the instructor manually. The professor would convert the experience values of the players at the end of the course into grades.

The previous XP logic in JSON string generating module is a piece of static code which always just sends a manually set percentage score as the XP point. A part of our work is to rewrite this XP point system.

The new XP point system is a weighted score system, where instructor can assign or automatically generate the XP point.

===Assignment Group Modules===
Assignment group module is used to

Previous assignment group from the previous project E407 is a fake module. In this version, the code to decide whether an assignment group is “available” to a student should appear in both frontend and backend, but neither of them works. So we rewrite it and assign privileges to it.

The following is the code for the assignment group module:

===JavaScript Code Reconstruction===
When the game is running on the Expertiza system, Expertiza should send the game the info it needs to generate the level and game state at load-time. The page should basically load the frontend JavaScript and point it to the JSON string.

Previous system get JSON by [http://en.wikipedia.org/wiki/Polling_(computer_science) polling] the server. In this strategy, the computer does nothing other than check the status of the backend until it is ready, at which point the device is accessed. In order to improve the efficiency of the CPU, we introduced [http://en.wikipedia.org/wiki/Event-driven_programming Event Driven Programming (EDP)] into our design. In EDP, the flow of the program is determined by events. In our case, a callback closure is called when the JSON data hit the frontend.

We also Change the ig module a little bit to support visiting module variable in closure.

The related code is as following:

===Fixing Mega Bugs===
====Uncaught Exception====
Previous JSON backend throws an uncaught exception when the user has an unsubmitted assignment and he is participating in that assignment.

We fix this bug by

The following is the related code:

====Gate Name Error====
Previous JSON backend didn’t set gate name correctly. Thus when having multiple assignment group (>3) and at least one hub threshold is higher than current user’s XP point, JavaScript frontend falls into infinite loop.

We fix this bug by

The following is the related code:

====Assignment Group Error====
In previous JSON backend, if an assignment group has X assignment in it, it will return X copy of that an assignment group, thus there’ll be X*X assignment in total. X times greater than it should be.

We fix this bug by

The following is the related code:

===Fixing Minor Bugs===
* Previous backend send all assignment data to frontend even if the student is not participate in the assignment.

* Previous JSON backend didn’t set MIME type correctly. That result in frontend code can only use low layer API to capture JSON data, when using high layer API, a silent error will occur.

* Previous MIME type result in IE and Chrome has different behavior.

* Sending a JSON string “null” to frontend will make it stop responding.

==General Introduction to the System Setup==
Please follow these steps to setup the program:

a) Download and deploy the code from
http://commondatastorage.googleapis.com/silverwzw/expertiza-json.zip

b) Drop the database “pg_development”

c) Create an empty database “pg_development”

d) Run “db:migrate”

e) Start the server

f) Login as admin

g) Go to Navigation bar -> Administration -> Setup -> Menu Editor

h) In Menu Editor page, find “Assignment Group” row (it should be the last but six row)

i) You should see an up arrow at the left column of that row, click it.

j) Then the “Assignment Group” row goes up, click the 2nd column of that “Assignment Group” row, in which it should say “assignment_groups:list”

k) In the pop up page named “Editing controller_action” there’s a drop down box with label ”Permission”, choose “administer assignment” in that drop down box, then click button “Edit”

l) Create a student account, let’s say its name is “st1”.

m) Create 2 additional assignment groups (then we will have 3 assignment groups). Set the XP value of the “Default Group” to -1. Set the XP value of the “2nd Group” to 200. Set the XP value of the “3rd Group” to 3000. (XP value of an assignment group is the threshold to open that assignment room).

n) Create 5 assignment:
Please do it carefully and ONE BY ONE in order, set all deadlines to anytime LATER than May, 2013, select the “available to student” check button.

a1 : Group = Default Group | XP = 120 | directory = /submitted_content/edit/1

a2 : Group = Default Group | XP = 200 | directory = /submitted_content/edit/2

a3 : Group = 2nd Group | XP = 2000 | directory = /submitted_content/edit/3

a4 : Group = 3rd Group | XP = 2000 | directory = /submitted_content/edit/4

a5 : Group = Default Group | XP = 2000 | directory = /submitted_content/edit/5

add participant “st1” to a1, a2, a3, a4 ( NOT for a5 )

CSC/ECE 517 Spring 2013/OSS E629

2013-03-23T18:16:07Z

Cyang14: /* JavaScript Code Reconstruction */

=E629: Integrating game frontend for Expertiza=

==Project Introduction==
This is a game made for the [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza] system (Ed Gehringer, NCSU). It transforms an assignment-based course into a "game" in which the player levels up and completes areas. The player doesn't receive grades; rather, he gains experience, and the professor would convert the experience values of the players at the end of the course into grades. The map is split up into distinct "rooms" unlocked by completing assignments; these are arrayed around a "center" in the middle of the map which contains portals to each room (portals which unlock as the player progresses).

==Project Requirement==
Students will need to develop a page that runs the Expertiza game in JavaScript when a user is logged in and calls the code from E407 to get the JSON string to be parsed by the frontend.

The page should basically load the frontend [http://en.wikipedia.org/wiki/JavaScript JavaScript] and point it to the [http://en.wikipedia.org/wiki/JSON JSON] string (a URL that will check to make sure that the current user is logged in correctly).

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

==Our Work==

===Experience Point Report===
In this game, the player doesn't receive grades; rather, he gains experience(XP), and the professor would convert the experience values of the players at the end of the course into grades.

The Previous XP is a fake one, they just send the "grade" score as the XP point. So one part of work is to rewrite this part.

The new XP point system is a weighted score system, where instructor can assign or automatically generate the XP point.

The following is the code for XP point report system:

===Assignment Group Modules===
Assignment group module is used to

Previous assignment group from the previous project E407 is a fake module. In this version, the code to decide whether an assignment group is “available” to a student should appear in both frontend and backend, but neither of them works. So we rewrite it and assign privileges to it.

The following is the code for the assignment group module:

===JavaScript Code Reconstruction===
When the game is running on the Expertiza system, Expertiza should send the game the info it needs to generate the level and game state at load-time. The page should basically load the frontend JavaScript and point it to the JSON string.

Previous system get JSON by [http://en.wikipedia.org/wiki/Polling_(computer_science) polling] the server. In this strategy, the computer does nothing other than check the status of the backend until it is ready, at which point the device is accessed. In order to improve the efficiency of the CPU, we introduced [http://en.wikipedia.org/wiki/Event-driven_programming Event Driven Programming (EDP)] into our design. In EDP, the flow of the program is determined by events. In our case, a callback closure is called when the JSON data hit the frontend.

We also Change the ig module a little bit to support visiting module variable in closure.

The related code is as following:

===Fixing Mega Bugs===
====Uncaught Exception====
Previous JSON backend throws an uncaught exception when the user has an unsubmitted assignment and he is participating in that assignment.

We fix this bug by

The following is the related code:

====Gate Name Error====
Previous JSON backend didn’t set gate name correctly. Thus when having multiple assignment group (>3) and at least one hub threshold is higher than current user’s XP point, JavaScript frontend falls into infinite loop.

We fix this bug by

The following is the related code:

====Assignment Group Error====
In previous JSON backend, if an assignment group has X assignment in it, it will return X copy of that an assignment group, thus there’ll be X*X assignment in total. X times greater than it should be.

We fix this bug by

The following is the related code:

===Fixing Minor Bugs===
* Previous backend send all assignment data to frontend even if the student is not participate in the assignment.

* Previous JSON backend didn’t set MIME type correctly. That result in frontend code can only use low layer API to capture JSON data, when using high layer API, a silent error will occur.

* Previous MIME type result in IE and Chrome has different behavior.

* Sending a JSON string “null” to frontend will make it stop responding.

==General Introduction to the System Setup==
Please follow these steps to setup the program:

a) Download and deploy the code from
http://commondatastorage.googleapis.com/silverwzw/expertiza-json.zip

b) Drop the database “pg_development”

c) Create an empty database “pg_development”

d) Run “db:migrate”

e) Start the server

f) Login as admin

g) Go to Navigation bar -> Administration -> Setup -> Menu Editor

h) In Menu Editor page, find “Assignment Group” row (it should be the last but six row)

i) You should see an up arrow at the left column of that row, click it.

j) Then the “Assignment Group” row goes up, click the 2nd column of that “Assignment Group” row, in which it should say “assignment_groups:list”

k) In the pop up page named “Editing controller_action” there’s a drop down box with label ”Permission”, choose “administer assignment” in that drop down box, then click button “Edit”

l) Create a student account, let’s say its name is “st1”.

m) Create 2 additional assignment groups (then we will have 3 assignment groups). Set the XP value of the “Default Group” to -1. Set the XP value of the “2nd Group” to 200. Set the XP value of the “3rd Group” to 3000. (XP value of an assignment group is the threshold to open that assignment room).

n) Create 5 assignment:
Please do it carefully and ONE BY ONE in order, set all deadlines to anytime LATER than May, 2013, select the “available to student” check button.

a1 : Group = Default Group | XP = 120 | directory = /submitted_content/edit/1

a2 : Group = Default Group | XP = 200 | directory = /submitted_content/edit/2

a3 : Group = 2nd Group | XP = 2000 | directory = /submitted_content/edit/3

a4 : Group = 3rd Group | XP = 2000 | directory = /submitted_content/edit/4

a5 : Group = Default Group | XP = 2000 | directory = /submitted_content/edit/5

add participant “st1” to a1, a2, a3, a4 ( NOT for a5 )

CSC/ECE 517 Spring 2013/OSS E629

2013-03-23T18:13:48Z

Cyang14: /* Project Requirement */

=E629: Integrating game frontend for Expertiza=

==Project Introduction==
This is a game made for the [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza] system (Ed Gehringer, NCSU). It transforms an assignment-based course into a "game" in which the player levels up and completes areas. The player doesn't receive grades; rather, he gains experience, and the professor would convert the experience values of the players at the end of the course into grades. The map is split up into distinct "rooms" unlocked by completing assignments; these are arrayed around a "center" in the middle of the map which contains portals to each room (portals which unlock as the player progresses).

==Project Requirement==
Students will need to develop a page that runs the Expertiza game in JavaScript when a user is logged in and calls the code from E407 to get the JSON string to be parsed by the frontend.

The page should basically load the frontend [http://en.wikipedia.org/wiki/JavaScript JavaScript] and point it to the [http://en.wikipedia.org/wiki/JSON JSON] string (a URL that will check to make sure that the current user is logged in correctly).

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

==Our Work==

===Experience Point Report===
In this game, the player doesn't receive grades; rather, he gains experience(XP), and the professor would convert the experience values of the players at the end of the course into grades.

The Previous XP is a fake one, they just send the "grade" score as the XP point. So one part of work is to rewrite this part.

The new XP point system is a weighted score system, where instructor can assign or automatically generate the XP point.

The following is the code for XP point report system:

===Assignment Group Modules===
Assignment group module is used to

Previous assignment group from the previous project E407 is a fake module. In this version, the code to decide whether an assignment group is “available” to a student should appear in both frontend and backend, but neither of them works. So we rewrite it and assign privileges to it.

The following is the code for the assignment group module:

===JavaScript Code Reconstruction===
When the game is running on the Expertiza system, Expertiza should send the game the info it needs to generate the level and game state at load-time. The page should basically load the frontend JavaScript and point it to the JSON string.

Previous system get JSON by polling the server. In this strategy, the computer does nothing other than check the status of the backend until it is ready, at which point the device is accessed. In order to improve the efficiency of the CPU, we introduced Event Driven Programming (EDP) into our design. In EDP, the flow of the program is determined by events. In our case, a callback closure is called when the JSON data hit the frontend.

We also Change the ig module a little bit to support visiting module variable in closure.

The related code is as following:

===Fixing Mega Bugs===
====Uncaught Exception====
Previous JSON backend throws an uncaught exception when the user has an unsubmitted assignment and he is participating in that assignment.

We fix this bug by

The following is the related code:

====Gate Name Error====
Previous JSON backend didn’t set gate name correctly. Thus when having multiple assignment group (>3) and at least one hub threshold is higher than current user’s XP point, JavaScript frontend falls into infinite loop.

We fix this bug by

The following is the related code:

====Assignment Group Error====
In previous JSON backend, if an assignment group has X assignment in it, it will return X copy of that an assignment group, thus there’ll be X*X assignment in total. X times greater than it should be.

We fix this bug by

The following is the related code:

===Fixing Minor Bugs===
* Previous backend send all assignment data to frontend even if the student is not participate in the assignment.

* Previous JSON backend didn’t set MIME type correctly. That result in frontend code can only use low layer API to capture JSON data, when using high layer API, a silent error will occur.

* Previous MIME type result in IE and Chrome has different behavior.

* Sending a JSON string “null” to frontend will make it stop responding.

==General Introduction to the System Setup==
Please follow these steps to setup the program:

a) Download and deploy the code from
http://commondatastorage.googleapis.com/silverwzw/expertiza-json.zip

b) Drop the database “pg_development”

c) Create an empty database “pg_development”

d) Run “db:migrate”

e) Start the server

f) Login as admin

g) Go to Navigation bar -> Administration -> Setup -> Menu Editor

h) In Menu Editor page, find “Assignment Group” row (it should be the last but six row)

i) You should see an up arrow at the left column of that row, click it.

j) Then the “Assignment Group” row goes up, click the 2nd column of that “Assignment Group” row, in which it should say “assignment_groups:list”

k) In the pop up page named “Editing controller_action” there’s a drop down box with label ”Permission”, choose “administer assignment” in that drop down box, then click button “Edit”

l) Create a student account, let’s say its name is “st1”.

m) Create 2 additional assignment groups (then we will have 3 assignment groups). Set the XP value of the “Default Group” to -1. Set the XP value of the “2nd Group” to 200. Set the XP value of the “3rd Group” to 3000. (XP value of an assignment group is the threshold to open that assignment room).

n) Create 5 assignment:
Please do it carefully and ONE BY ONE in order, set all deadlines to anytime LATER than May, 2013, select the “available to student” check button.

a1 : Group = Default Group | XP = 120 | directory = /submitted_content/edit/1

a2 : Group = Default Group | XP = 200 | directory = /submitted_content/edit/2

a3 : Group = 2nd Group | XP = 2000 | directory = /submitted_content/edit/3

a4 : Group = 3rd Group | XP = 2000 | directory = /submitted_content/edit/4

a5 : Group = Default Group | XP = 2000 | directory = /submitted_content/edit/5

add participant “st1” to a1, a2, a3, a4 ( NOT for a5 )

CSC/ECE 517 Spring 2013/OSS E629

2013-03-23T18:10:39Z

Cyang14: /* Project Introduction */

=E629: Integrating game frontend for Expertiza=

==Project Introduction==
This is a game made for the [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza] system (Ed Gehringer, NCSU). It transforms an assignment-based course into a "game" in which the player levels up and completes areas. The player doesn't receive grades; rather, he gains experience, and the professor would convert the experience values of the players at the end of the course into grades. The map is split up into distinct "rooms" unlocked by completing assignments; these are arrayed around a "center" in the middle of the map which contains portals to each room (portals which unlock as the player progresses).

==Project Requirement==
Students will need to develop a page that runs the Expertiza game in JavaScript when a user is logged in and calls the code from E407 to get the JSON string to be parsed by the frontend.

The page should basically load the frontend JavaScript and point it to the JSON string (a URL that will check to make sure that the current user is logged in correctly).

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

==Our Work==

===Experience Point Report===
In this game, the player doesn't receive grades; rather, he gains experience(XP), and the professor would convert the experience values of the players at the end of the course into grades.

The Previous XP is a fake one, they just send the "grade" score as the XP point. So one part of work is to rewrite this part.

The new XP point system is a weighted score system, where instructor can assign or automatically generate the XP point.

The following is the code for XP point report system:

===Assignment Group Modules===
Assignment group module is used to

Previous assignment group from the previous project E407 is a fake module. In this version, the code to decide whether an assignment group is “available” to a student should appear in both frontend and backend, but neither of them works. So we rewrite it and assign privileges to it.

The following is the code for the assignment group module:

===JavaScript Code Reconstruction===
When the game is running on the Expertiza system, Expertiza should send the game the info it needs to generate the level and game state at load-time. The page should basically load the frontend JavaScript and point it to the JSON string.

Previous system get JSON by polling the server. In this strategy, the computer does nothing other than check the status of the backend until it is ready, at which point the device is accessed. In order to improve the efficiency of the CPU, we introduced Event Driven Programming (EDP) into our design. In EDP, the flow of the program is determined by events. In our case, a callback closure is called when the JSON data hit the frontend.

We also Change the ig module a little bit to support visiting module variable in closure.

The related code is as following:

===Fixing Mega Bugs===
====Uncaught Exception====
Previous JSON backend throws an uncaught exception when the user has an unsubmitted assignment and he is participating in that assignment.

We fix this bug by

The following is the related code:

====Gate Name Error====
Previous JSON backend didn’t set gate name correctly. Thus when having multiple assignment group (>3) and at least one hub threshold is higher than current user’s XP point, JavaScript frontend falls into infinite loop.

We fix this bug by

The following is the related code:

====Assignment Group Error====
In previous JSON backend, if an assignment group has X assignment in it, it will return X copy of that an assignment group, thus there’ll be X*X assignment in total. X times greater than it should be.

We fix this bug by

The following is the related code:

===Fixing Minor Bugs===
* Previous backend send all assignment data to frontend even if the student is not participate in the assignment.

* Previous JSON backend didn’t set MIME type correctly. That result in frontend code can only use low layer API to capture JSON data, when using high layer API, a silent error will occur.

* Previous MIME type result in IE and Chrome has different behavior.

* Sending a JSON string “null” to frontend will make it stop responding.

==General Introduction to the System Setup==
Please follow these steps to setup the program:

a) Download and deploy the code from
http://commondatastorage.googleapis.com/silverwzw/expertiza-json.zip

b) Drop the database “pg_development”

c) Create an empty database “pg_development”

d) Run “db:migrate”

e) Start the server

f) Login as admin

g) Go to Navigation bar -> Administration -> Setup -> Menu Editor

h) In Menu Editor page, find “Assignment Group” row (it should be the last but six row)

i) You should see an up arrow at the left column of that row, click it.

j) Then the “Assignment Group” row goes up, click the 2nd column of that “Assignment Group” row, in which it should say “assignment_groups:list”

k) In the pop up page named “Editing controller_action” there’s a drop down box with label ”Permission”, choose “administer assignment” in that drop down box, then click button “Edit”

l) Create a student account, let’s say its name is “st1”.

m) Create 2 additional assignment groups (then we will have 3 assignment groups). Set the XP value of the “Default Group” to -1. Set the XP value of the “2nd Group” to 200. Set the XP value of the “3rd Group” to 3000. (XP value of an assignment group is the threshold to open that assignment room).

n) Create 5 assignment:
Please do it carefully and ONE BY ONE in order, set all deadlines to anytime LATER than May, 2013, select the “available to student” check button.

a1 : Group = Default Group | XP = 120 | directory = /submitted_content/edit/1

a2 : Group = Default Group | XP = 200 | directory = /submitted_content/edit/2

a3 : Group = 2nd Group | XP = 2000 | directory = /submitted_content/edit/3

a4 : Group = 3rd Group | XP = 2000 | directory = /submitted_content/edit/4

a5 : Group = Default Group | XP = 2000 | directory = /submitted_content/edit/5

add participant “st1” to a1, a2, a3, a4 ( NOT for a5 )

CSC/ECE 517 Spring 2013/OSS E629

2013-03-23T18:05:11Z

Cyang14: /* General Introduction to the System Setup */

=E629: Integrating game frontend for Expertiza=

==Project Introduction==
This is a game made for the Expertiza system (Ed Gehringer, NCSU). It transforms an assignment-based course into a "game" in which the player levels up and completes areas. The player doesn't receive grades; rather, he gains experience, and the professor would convert the experience values of the players at the end of the course into grades. The map is split up into distinct "rooms" unlocked by completing assignments; these are arrayed around a "center" in the middle of the map which contains portals to each room (portals which unlock as the player progresses).

==Project Requirement==
Students will need to develop a page that runs the Expertiza game in JavaScript when a user is logged in and calls the code from E407 to get the JSON string to be parsed by the frontend.

The page should basically load the frontend JavaScript and point it to the JSON string (a URL that will check to make sure that the current user is logged in correctly).

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

==Our Work==

===Experience Point Report===
In this game, the player doesn't receive grades; rather, he gains experience(XP), and the professor would convert the experience values of the players at the end of the course into grades.

The Previous XP is a fake one, they just send the "grade" score as the XP point. So one part of work is to rewrite this part.

The new XP point system is a weighted score system, where instructor can assign or automatically generate the XP point.

The following is the code for XP point report system:

===Assignment Group Modules===
Assignment group module is used to

Previous assignment group from the previous project E407 is a fake module. In this version, the code to decide whether an assignment group is “available” to a student should appear in both frontend and backend, but neither of them works. So we rewrite it and assign privileges to it.

The following is the code for the assignment group module:

===JavaScript Code Reconstruction===
When the game is running on the Expertiza system, Expertiza should send the game the info it needs to generate the level and game state at load-time. The page should basically load the frontend JavaScript and point it to the JSON string.

Previous system get JSON by polling the server. In this strategy, the computer does nothing other than check the status of the backend until it is ready, at which point the device is accessed. In order to improve the efficiency of the CPU, we introduced Event Driven Programming (EDP) into our design. In EDP, the flow of the program is determined by events. In our case, a callback closure is called when the JSON data hit the frontend.

We also Change the ig module a little bit to support visiting module variable in closure.

The related code is as following:

===Fixing Mega Bugs===
====Uncaught Exception====
Previous JSON backend throws an uncaught exception when the user has an unsubmitted assignment and he is participating in that assignment.

We fix this bug by

The following is the related code:

====Gate Name Error====
Previous JSON backend didn’t set gate name correctly. Thus when having multiple assignment group (>3) and at least one hub threshold is higher than current user’s XP point, JavaScript frontend falls into infinite loop.

We fix this bug by

The following is the related code:

====Assignment Group Error====
In previous JSON backend, if an assignment group has X assignment in it, it will return X copy of that an assignment group, thus there’ll be X*X assignment in total. X times greater than it should be.

We fix this bug by

The following is the related code:

===Fixing Minor Bugs===
* Previous backend send all assignment data to frontend even if the student is not participate in the assignment.

* Previous JSON backend didn’t set MIME type correctly. That result in frontend code can only use low layer API to capture JSON data, when using high layer API, a silent error will occur.

* Previous MIME type result in IE and Chrome has different behavior.

* Sending a JSON string “null” to frontend will make it stop responding.

==General Introduction to the System Setup==
Please follow these steps to setup the program:

a) Download and deploy the code from
http://commondatastorage.googleapis.com/silverwzw/expertiza-json.zip

b) Drop the database “pg_development”

c) Create an empty database “pg_development”

d) Run “db:migrate”

e) Start the server

f) Login as admin

g) Go to Navigation bar -> Administration -> Setup -> Menu Editor

h) In Menu Editor page, find “Assignment Group” row (it should be the last but six row)

i) You should see an up arrow at the left column of that row, click it.

j) Then the “Assignment Group” row goes up, click the 2nd column of that “Assignment Group” row, in which it should say “assignment_groups:list”

k) In the pop up page named “Editing controller_action” there’s a drop down box with label ”Permission”, choose “administer assignment” in that drop down box, then click button “Edit”

l) Create a student account, let’s say its name is “st1”.

m) Create 2 additional assignment groups (then we will have 3 assignment groups). Set the XP value of the “Default Group” to -1. Set the XP value of the “2nd Group” to 200. Set the XP value of the “3rd Group” to 3000. (XP value of an assignment group is the threshold to open that assignment room).

n) Create 5 assignment:
Please do it carefully and ONE BY ONE in order, set all deadlines to anytime LATER than May, 2013, select the “available to student” check button.

a1 : Group = Default Group | XP = 120 | directory = /submitted_content/edit/1

a2 : Group = Default Group | XP = 200 | directory = /submitted_content/edit/2

a3 : Group = 2nd Group | XP = 2000 | directory = /submitted_content/edit/3

a4 : Group = 3rd Group | XP = 2000 | directory = /submitted_content/edit/4

a5 : Group = Default Group | XP = 2000 | directory = /submitted_content/edit/5

add participant “st1” to a1, a2, a3, a4 ( NOT for a5 )

CSC/ECE 517 Spring 2013/OSS E629

2013-03-23T18:04:39Z

Cyang14: /* General Introduction to the System Setup */

=E629: Integrating game frontend for Expertiza=

==Project Introduction==
This is a game made for the Expertiza system (Ed Gehringer, NCSU). It transforms an assignment-based course into a "game" in which the player levels up and completes areas. The player doesn't receive grades; rather, he gains experience, and the professor would convert the experience values of the players at the end of the course into grades. The map is split up into distinct "rooms" unlocked by completing assignments; these are arrayed around a "center" in the middle of the map which contains portals to each room (portals which unlock as the player progresses).

==Project Requirement==
Students will need to develop a page that runs the Expertiza game in JavaScript when a user is logged in and calls the code from E407 to get the JSON string to be parsed by the frontend.

The page should basically load the frontend JavaScript and point it to the JSON string (a URL that will check to make sure that the current user is logged in correctly).

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

==Our Work==

===Experience Point Report===
In this game, the player doesn't receive grades; rather, he gains experience(XP), and the professor would convert the experience values of the players at the end of the course into grades.

The Previous XP is a fake one, they just send the "grade" score as the XP point. So one part of work is to rewrite this part.

The new XP point system is a weighted score system, where instructor can assign or automatically generate the XP point.

The following is the code for XP point report system:

===Assignment Group Modules===
Assignment group module is used to

Previous assignment group from the previous project E407 is a fake module. In this version, the code to decide whether an assignment group is “available” to a student should appear in both frontend and backend, but neither of them works. So we rewrite it and assign privileges to it.

The following is the code for the assignment group module:

===JavaScript Code Reconstruction===
When the game is running on the Expertiza system, Expertiza should send the game the info it needs to generate the level and game state at load-time. The page should basically load the frontend JavaScript and point it to the JSON string.

Previous system get JSON by polling the server. In this strategy, the computer does nothing other than check the status of the backend until it is ready, at which point the device is accessed. In order to improve the efficiency of the CPU, we introduced Event Driven Programming (EDP) into our design. In EDP, the flow of the program is determined by events. In our case, a callback closure is called when the JSON data hit the frontend.

We also Change the ig module a little bit to support visiting module variable in closure.

The related code is as following:

===Fixing Mega Bugs===
====Uncaught Exception====
Previous JSON backend throws an uncaught exception when the user has an unsubmitted assignment and he is participating in that assignment.

We fix this bug by

The following is the related code:

====Gate Name Error====
Previous JSON backend didn’t set gate name correctly. Thus when having multiple assignment group (>3) and at least one hub threshold is higher than current user’s XP point, JavaScript frontend falls into infinite loop.

We fix this bug by

The following is the related code:

====Assignment Group Error====
In previous JSON backend, if an assignment group has X assignment in it, it will return X copy of that an assignment group, thus there’ll be X*X assignment in total. X times greater than it should be.

We fix this bug by

The following is the related code:

===Fixing Minor Bugs===
* Previous backend send all assignment data to frontend even if the student is not participate in the assignment.

* Previous JSON backend didn’t set MIME type correctly. That result in frontend code can only use low layer API to capture JSON data, when using high layer API, a silent error will occur.

* Previous MIME type result in IE and Chrome has different behavior.

* Sending a JSON string “null” to frontend will make it stop responding.

==General Introduction to the System Setup==
Please follow these steps to setup the program:

a) Download and deploy the code from
http://commondatastorage.googleapis.com/silverwzw/expertiza-json.zip

b) Drop the database “pg_development”

c) Create an empty database “pg_development”

d) Run “db:migrate”

e) Start the server

f) Login as admin

g) Go to Navigation bar -> Administration -> Setup -> Menu Editor

h) In Menu Editor page, find “Assignment Group” row (it should be the last but six row)

i) You should see an up arrow at the left column of that row, click it.

j) Then the “Assignment Group” row goes up, click the 2nd column of that “Assignment Group” row, in which it should say “assignment_groups:list”

k) In the pop up page named “Editing controller_action” there’s a drop down box with label ”Permission”, choose “administer assignment” in that drop down box, then click button “Edit”

l) Create a student account, let’s say its name is “st1”.

m) Create 2 additional assignment groups (then we will have 3 assignment groups). Set the XP value of the “Default Group” to -1. Set the XP value of the “2nd Group” to 200. Set the XP value of the “3rd Group” to 3000. (XP value of an assignment group is the threshold to open that assignment room).

n) Create 5 assignment:
Please do it carefully and ONE BY ONE in order, set all deadlines to anytime LATER than May, 2013, select the “available to student” check button.

a1 : Group = Default Group | XP = 120 | directory = /submitted_content/edit/1
a2 : Group = Default Group | XP = 200 | directory = /submitted_content/edit/2
a3 : Group = 2nd Group | XP = 2000 | directory = /submitted_content/edit/3
a4 : Group = 3rd Group | XP = 2000 | directory = /submitted_content/edit/4
a5 : Group = Default Group | XP = 2000 | directory = /submitted_content/edit/5

add participant “st1” to a1, a2, a3, a4 ( NOT for a5 )

CSC/ECE 517 Spring 2013/OSS E629

2013-03-23T18:03:35Z

Cyang14: /* General Introduction to the System Setup */

=E629: Integrating game frontend for Expertiza=

==Project Introduction==
This is a game made for the Expertiza system (Ed Gehringer, NCSU). It transforms an assignment-based course into a "game" in which the player levels up and completes areas. The player doesn't receive grades; rather, he gains experience, and the professor would convert the experience values of the players at the end of the course into grades. The map is split up into distinct "rooms" unlocked by completing assignments; these are arrayed around a "center" in the middle of the map which contains portals to each room (portals which unlock as the player progresses).

==Project Requirement==
Students will need to develop a page that runs the Expertiza game in JavaScript when a user is logged in and calls the code from E407 to get the JSON string to be parsed by the frontend.

The page should basically load the frontend JavaScript and point it to the JSON string (a URL that will check to make sure that the current user is logged in correctly).

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

==Our Work==

===Experience Point Report===
In this game, the player doesn't receive grades; rather, he gains experience(XP), and the professor would convert the experience values of the players at the end of the course into grades.

The Previous XP is a fake one, they just send the "grade" score as the XP point. So one part of work is to rewrite this part.

The new XP point system is a weighted score system, where instructor can assign or automatically generate the XP point.

The following is the code for XP point report system:

===Assignment Group Modules===
Assignment group module is used to

Previous assignment group from the previous project E407 is a fake module. In this version, the code to decide whether an assignment group is “available” to a student should appear in both frontend and backend, but neither of them works. So we rewrite it and assign privileges to it.

The following is the code for the assignment group module:

===JavaScript Code Reconstruction===
When the game is running on the Expertiza system, Expertiza should send the game the info it needs to generate the level and game state at load-time. The page should basically load the frontend JavaScript and point it to the JSON string.

Previous system get JSON by polling the server. In this strategy, the computer does nothing other than check the status of the backend until it is ready, at which point the device is accessed. In order to improve the efficiency of the CPU, we introduced Event Driven Programming (EDP) into our design. In EDP, the flow of the program is determined by events. In our case, a callback closure is called when the JSON data hit the frontend.

We also Change the ig module a little bit to support visiting module variable in closure.

The related code is as following:

===Fixing Mega Bugs===
====Uncaught Exception====
Previous JSON backend throws an uncaught exception when the user has an unsubmitted assignment and he is participating in that assignment.

We fix this bug by

The following is the related code:

====Gate Name Error====
Previous JSON backend didn’t set gate name correctly. Thus when having multiple assignment group (>3) and at least one hub threshold is higher than current user’s XP point, JavaScript frontend falls into infinite loop.

We fix this bug by

The following is the related code:

====Assignment Group Error====
In previous JSON backend, if an assignment group has X assignment in it, it will return X copy of that an assignment group, thus there’ll be X*X assignment in total. X times greater than it should be.

We fix this bug by

The following is the related code:

===Fixing Minor Bugs===
* Previous backend send all assignment data to frontend even if the student is not participate in the assignment.

* Previous JSON backend didn’t set MIME type correctly. That result in frontend code can only use low layer API to capture JSON data, when using high layer API, a silent error will occur.

* Previous MIME type result in IE and Chrome has different behavior.

* Sending a JSON string “null” to frontend will make it stop responding.

==General Introduction to the System Setup==
Please follow these steps to setup the program:

a) Download and deploy the code from
http://commondatastorage.googleapis.com/silverwzw/expertiza-json.zip

b) Drop the database “pg_development”

c) Create an empty database “pg_development”

d) Run “db:migrate”

e) Start the server

f) Login as admin

g) Go to Navigation bar -> Administration -> Setup -> Menu Editor

h) In Menu Editor page, find “Assignment Group” row (it should be the last but six row)

i) You should see an up arrow at the left column of that row, click it.

j) Then the “Assignment Group” row goes up, click the 2nd column of that “Assignment Group” row, in which it should say “assignment_groups:list”

k) In the pop up page named “Editing controller_action” there’s a drop down box with label ”Permission”, choose “administer assignment” in that drop down box, then click button “Edit”

l) Create a student account, let’s say its name is “st1”.

m) Create 2 additional assignment groups (then we will have 3 assignment groups). Set the XP value of the “Default Group” to -1. Set the XP value of the “2nd Group” to 200. Set the XP value of the “3rd Group” to 3000. (XP value of an assignment group is the threshold to open that assignment room).

n) Create 5 assignment:
Please do it carefully and ONE BY ONE in order, set all deadlines to anytime LATER than May, 2013, select the “available to student” check button.
i. a1 : Group = Default Group | XP = 120 | directory = /submitted_content/edit/1
ii. a2 : Group = Default Group | XP = 200 | directory = /submitted_content/edit/2
iii. a3 : Group = 2nd Group | XP = 2000 | directory = /submitted_content/edit/3
iv. a4 : Group = 3rd Group | XP = 2000 | directory = /submitted_content/edit/4
v. a5 : Group = Default Group | XP = 2000 | directory = /submitted_content/edit/5
add participant “st1” to a1, a2, a3, a4 ( NOT for a5 )

CSC/ECE 517 Spring 2013/OSS E629

2013-03-23T18:03:04Z

Cyang14: /* General Introduction to the System Setup */

=E629: Integrating game frontend for Expertiza=

==Project Introduction==
This is a game made for the Expertiza system (Ed Gehringer, NCSU). It transforms an assignment-based course into a "game" in which the player levels up and completes areas. The player doesn't receive grades; rather, he gains experience, and the professor would convert the experience values of the players at the end of the course into grades. The map is split up into distinct "rooms" unlocked by completing assignments; these are arrayed around a "center" in the middle of the map which contains portals to each room (portals which unlock as the player progresses).

==Project Requirement==
Students will need to develop a page that runs the Expertiza game in JavaScript when a user is logged in and calls the code from E407 to get the JSON string to be parsed by the frontend.

The page should basically load the frontend JavaScript and point it to the JSON string (a URL that will check to make sure that the current user is logged in correctly).

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

==Our Work==

===Experience Point Report===
In this game, the player doesn't receive grades; rather, he gains experience(XP), and the professor would convert the experience values of the players at the end of the course into grades.

The Previous XP is a fake one, they just send the "grade" score as the XP point. So one part of work is to rewrite this part.

The new XP point system is a weighted score system, where instructor can assign or automatically generate the XP point.

The following is the code for XP point report system:

===Assignment Group Modules===
Assignment group module is used to

Previous assignment group from the previous project E407 is a fake module. In this version, the code to decide whether an assignment group is “available” to a student should appear in both frontend and backend, but neither of them works. So we rewrite it and assign privileges to it.

The following is the code for the assignment group module:

===JavaScript Code Reconstruction===
When the game is running on the Expertiza system, Expertiza should send the game the info it needs to generate the level and game state at load-time. The page should basically load the frontend JavaScript and point it to the JSON string.

Previous system get JSON by polling the server. In this strategy, the computer does nothing other than check the status of the backend until it is ready, at which point the device is accessed. In order to improve the efficiency of the CPU, we introduced Event Driven Programming (EDP) into our design. In EDP, the flow of the program is determined by events. In our case, a callback closure is called when the JSON data hit the frontend.

We also Change the ig module a little bit to support visiting module variable in closure.

The related code is as following:

===Fixing Mega Bugs===
====Uncaught Exception====
Previous JSON backend throws an uncaught exception when the user has an unsubmitted assignment and he is participating in that assignment.

We fix this bug by

The following is the related code:

====Gate Name Error====
Previous JSON backend didn’t set gate name correctly. Thus when having multiple assignment group (>3) and at least one hub threshold is higher than current user’s XP point, JavaScript frontend falls into infinite loop.

We fix this bug by

The following is the related code:

====Assignment Group Error====
In previous JSON backend, if an assignment group has X assignment in it, it will return X copy of that an assignment group, thus there’ll be X*X assignment in total. X times greater than it should be.

We fix this bug by

The following is the related code:

===Fixing Minor Bugs===
* Previous backend send all assignment data to frontend even if the student is not participate in the assignment.

* Previous JSON backend didn’t set MIME type correctly. That result in frontend code can only use low layer API to capture JSON data, when using high layer API, a silent error will occur.

* Previous MIME type result in IE and Chrome has different behavior.

* Sending a JSON string “null” to frontend will make it stop responding.

==General Introduction to the System Setup==
Please follow these steps to setup the program:

a) Download and deploy the code from
http://commondatastorage.googleapis.com/silverwzw/expertiza-json.zip

b) Drop the database “pg_development”

c) Create an empty database “pg_development”

d) Run “db:migrate”

e) Start the server

f) Login as admin

g) Go to Navigation bar -> Administration -> Setup -> Menu Editor

h) In Menu Editor page, find “Assignment Group” row (it should be the last but six row)

i) You should see an up arrow at the left column of that row, click it.
j) Then the “Assignment Group” row goes up, click the 2nd column of that “Assignment Group” row, in which it should say “assignment_groups:list”
k) In the pop up page named “Editing controller_action” there’s a drop down box with label ”Permission”, choose “administer assignment” in that drop down box, then click button “Edit”
l) Create a student account, let’s say its name is “st1”.
m) Create 2 additional assignment groups (then we will have 3 assignment groups). Set the XP value of the “Default Group” to -1. Set the XP value of the “2nd Group” to 200. Set the XP value of the “3rd Group” to 3000. (XP value of an assignment group is the threshold to open that assignment room).
n) Create 5 assignment:
Please do it carefully and ONE BY ONE in order, set all deadlines to anytime LATER than May, 2013, select the “available to student” check button.
i. a1 : Group = Default Group | XP = 120 | directory = /submitted_content/edit/1
ii. a2 : Group = Default Group | XP = 200 | directory = /submitted_content/edit/2
iii. a3 : Group = 2nd Group | XP = 2000 | directory = /submitted_content/edit/3
iv. a4 : Group = 3rd Group | XP = 2000 | directory = /submitted_content/edit/4
v. a5 : Group = Default Group | XP = 2000 | directory = /submitted_content/edit/5
add participant “st1” to a1, a2, a3, a4 ( NOT for a5 )

CSC/ECE 517 Spring 2013/OSS E629

2013-03-23T18:02:39Z

Cyang14: /* General Introduction to the System Setup */

=E629: Integrating game frontend for Expertiza=

==Project Introduction==
This is a game made for the Expertiza system (Ed Gehringer, NCSU). It transforms an assignment-based course into a "game" in which the player levels up and completes areas. The player doesn't receive grades; rather, he gains experience, and the professor would convert the experience values of the players at the end of the course into grades. The map is split up into distinct "rooms" unlocked by completing assignments; these are arrayed around a "center" in the middle of the map which contains portals to each room (portals which unlock as the player progresses).

==Project Requirement==
Students will need to develop a page that runs the Expertiza game in JavaScript when a user is logged in and calls the code from E407 to get the JSON string to be parsed by the frontend.

The page should basically load the frontend JavaScript and point it to the JSON string (a URL that will check to make sure that the current user is logged in correctly).

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

==Our Work==

===Experience Point Report===
In this game, the player doesn't receive grades; rather, he gains experience(XP), and the professor would convert the experience values of the players at the end of the course into grades.

The Previous XP is a fake one, they just send the "grade" score as the XP point. So one part of work is to rewrite this part.

The new XP point system is a weighted score system, where instructor can assign or automatically generate the XP point.

The following is the code for XP point report system:

===Assignment Group Modules===
Assignment group module is used to

Previous assignment group from the previous project E407 is a fake module. In this version, the code to decide whether an assignment group is “available” to a student should appear in both frontend and backend, but neither of them works. So we rewrite it and assign privileges to it.

The following is the code for the assignment group module:

===JavaScript Code Reconstruction===
When the game is running on the Expertiza system, Expertiza should send the game the info it needs to generate the level and game state at load-time. The page should basically load the frontend JavaScript and point it to the JSON string.

Previous system get JSON by polling the server. In this strategy, the computer does nothing other than check the status of the backend until it is ready, at which point the device is accessed. In order to improve the efficiency of the CPU, we introduced Event Driven Programming (EDP) into our design. In EDP, the flow of the program is determined by events. In our case, a callback closure is called when the JSON data hit the frontend.

We also Change the ig module a little bit to support visiting module variable in closure.

The related code is as following:

===Fixing Mega Bugs===
====Uncaught Exception====
Previous JSON backend throws an uncaught exception when the user has an unsubmitted assignment and he is participating in that assignment.

We fix this bug by

The following is the related code:

====Gate Name Error====
Previous JSON backend didn’t set gate name correctly. Thus when having multiple assignment group (>3) and at least one hub threshold is higher than current user’s XP point, JavaScript frontend falls into infinite loop.

We fix this bug by

The following is the related code:

====Assignment Group Error====
In previous JSON backend, if an assignment group has X assignment in it, it will return X copy of that an assignment group, thus there’ll be X*X assignment in total. X times greater than it should be.

We fix this bug by

The following is the related code:

===Fixing Minor Bugs===
* Previous backend send all assignment data to frontend even if the student is not participate in the assignment.

* Previous JSON backend didn’t set MIME type correctly. That result in frontend code can only use low layer API to capture JSON data, when using high layer API, a silent error will occur.

* Previous MIME type result in IE and Chrome has different behavior.

* Sending a JSON string “null” to frontend will make it stop responding.

==General Introduction to the System Setup==
Please follow these steps to setup the program:

a) Download and deploy the code from
http://commondatastorage.googleapis.com/silverwzw/expertiza-json.zip

b) Drop the database “pg_development”
c) Create an empty database “pg_development”
d) Run “db:migrate”
e) Start the server
f) Login as admin
g) Go to Navigation bar -> Administration -> Setup -> Menu Editor
h) In Menu Editor page, find “Assignment Group” row (it should be the last but six row)
i) You should see an up arrow at the left column of that row, click it.
j) Then the “Assignment Group” row goes up, click the 2nd column of that “Assignment Group” row, in which it should say “assignment_groups:list”
k) In the pop up page named “Editing controller_action” there’s a drop down box with label ”Permission”, choose “administer assignment” in that drop down box, then click button “Edit”
l) Create a student account, let’s say its name is “st1”.
m) Create 2 additional assignment groups (then we will have 3 assignment groups). Set the XP value of the “Default Group” to -1. Set the XP value of the “2nd Group” to 200. Set the XP value of the “3rd Group” to 3000. (XP value of an assignment group is the threshold to open that assignment room).
n) Create 5 assignment:
Please do it carefully and ONE BY ONE in order, set all deadlines to anytime LATER than May, 2013, select the “available to student” check button.
i. a1 : Group = Default Group | XP = 120 | directory = /submitted_content/edit/1
ii. a2 : Group = Default Group | XP = 200 | directory = /submitted_content/edit/2
iii. a3 : Group = 2nd Group | XP = 2000 | directory = /submitted_content/edit/3
iv. a4 : Group = 3rd Group | XP = 2000 | directory = /submitted_content/edit/4
v. a5 : Group = Default Group | XP = 2000 | directory = /submitted_content/edit/5
add participant “st1” to a1, a2, a3, a4 ( NOT for a5 )

CSC/ECE 517 Spring 2013/OSS E629

2013-03-23T17:59:15Z

Cyang14: /* General Introduction to the System Setup */

=E629: Integrating game frontend for Expertiza=

==Project Introduction==
This is a game made for the Expertiza system (Ed Gehringer, NCSU). It transforms an assignment-based course into a "game" in which the player levels up and completes areas. The player doesn't receive grades; rather, he gains experience, and the professor would convert the experience values of the players at the end of the course into grades. The map is split up into distinct "rooms" unlocked by completing assignments; these are arrayed around a "center" in the middle of the map which contains portals to each room (portals which unlock as the player progresses).

==Project Requirement==
Students will need to develop a page that runs the Expertiza game in JavaScript when a user is logged in and calls the code from E407 to get the JSON string to be parsed by the frontend.

The page should basically load the frontend JavaScript and point it to the JSON string (a URL that will check to make sure that the current user is logged in correctly).

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

==Our Work==

===Experience Point Report===
In this game, the player doesn't receive grades; rather, he gains experience(XP), and the professor would convert the experience values of the players at the end of the course into grades.

The Previous XP is a fake one, they just send the "grade" score as the XP point. So one part of work is to rewrite this part.

The new XP point system is a weighted score system, where instructor can assign or automatically generate the XP point.

The following is the code for XP point report system:

===Assignment Group Modules===
Assignment group module is used to

Previous assignment group from the previous project E407 is a fake module. In this version, the code to decide whether an assignment group is “available” to a student should appear in both frontend and backend, but neither of them works. So we rewrite it and assign privileges to it.

The following is the code for the assignment group module:

===JavaScript Code Reconstruction===
When the game is running on the Expertiza system, Expertiza should send the game the info it needs to generate the level and game state at load-time. The page should basically load the frontend JavaScript and point it to the JSON string.

Previous system get JSON by polling the server. In this strategy, the computer does nothing other than check the status of the backend until it is ready, at which point the device is accessed. In order to improve the efficiency of the CPU, we introduced Event Driven Programming (EDP) into our design. In EDP, the flow of the program is determined by events. In our case, a callback closure is called when the JSON data hit the frontend.

We also Change the ig module a little bit to support visiting module variable in closure.

The related code is as following:

===Fixing Mega Bugs===
====Uncaught Exception====
Previous JSON backend throws an uncaught exception when the user has an unsubmitted assignment and he is participating in that assignment.

We fix this bug by

The following is the related code:

====Gate Name Error====
Previous JSON backend didn’t set gate name correctly. Thus when having multiple assignment group (>3) and at least one hub threshold is higher than current user’s XP point, JavaScript frontend falls into infinite loop.

We fix this bug by

The following is the related code:

====Assignment Group Error====
In previous JSON backend, if an assignment group has X assignment in it, it will return X copy of that an assignment group, thus there’ll be X*X assignment in total. X times greater than it should be.

We fix this bug by

The following is the related code:

===Fixing Minor Bugs===
* Previous backend send all assignment data to frontend even if the student is not participate in the assignment.

* Previous JSON backend didn’t set MIME type correctly. That result in frontend code can only use low layer API to capture JSON data, when using high layer API, a silent error will occur.

* Previous MIME type result in IE and Chrome has different behavior.

* Sending a JSON string “null” to frontend will make it stop responding.

==General Introduction to the System Setup==
Please follow these steps to setup the program:

a) Download and deploy the code from
http://commondatastorage.googleapis.com/silverwzw/expertiza-json.zip
b) Drop the database “pg_development”
c) Create an empty database “pg_development”
d) Run “db:migrate”
e) Start the server
f) Login as admin
g) Go to Navigation bar -> Administration -> Setup -> Menu Editor
h) In Menu Editor page, find “Assignment Group” row (it should be the last but six row)
i) You should see an up arrow at the left column of that row, click it.
j) Then the “Assignment Group” row goes up, click the 2nd column of that “Assignment Group” row, in which it should say “assignment_groups:list”
k) In the pop up page named “Editing controller_action” there’s a drop down box with label ”Permission”, choose “administer assignment” in that drop down box, then click button “Edit”
l) Create a student account, let’s say its name is “st1”.
m) Create 2 additional assignment groups (then we will have 3 assignment groups). Set the XP value of the “Default Group” to -1. Set the XP value of the “2nd Group” to 200. Set the XP value of the “3rd Group” to 3000. (XP value of an assignment group is the threshold to open that assignment room).
n) Create 5 assignment:
Please do it carefully and ONE BY ONE in order, set all deadlines to anytime LATER than May, 2013, select the “available to student” check button.
i. a1 : Group = Default Group | XP = 120 | directory = /submitted_content/edit/1
ii. a2 : Group = Default Group | XP = 200 | directory = /submitted_content/edit/2
iii. a3 : Group = 2nd Group | XP = 2000 | directory = /submitted_content/edit/3
iv. a4 : Group = 3rd Group | XP = 2000 | directory = /submitted_content/edit/4
v. a5 : Group = Default Group | XP = 2000 | directory = /submitted_content/edit/5
add participant “st1” to a1, a2, a3, a4 ( NOT for a5 )

CSC/ECE 517 Spring 2013/OSS E629

2013-03-23T17:58:42Z

Cyang14: /* Fixing Minor Bugs */

CSC/ECE 517 Spring 2013/OSS E629

2013-03-23T17:57:08Z

Cyang14: /* Assignment Group Error */

CSC/ECE 517 Spring 2013/OSS E629

2013-03-23T17:56:19Z

Cyang14: /* Gate Name Error */

CSC/ECE 517 Spring 2013/OSS E629

2013-03-23T17:55:26Z

Cyang14: /* Uncaught Exception */

CSC/ECE 517 Spring 2013/OSS E629

2013-03-23T17:53:20Z

Cyang14: /* Fixing Mega Bugs */

CSC/ECE 517 Spring 2013/OSS E629

2013-03-23T17:50:48Z

Cyang14: /* JavaScript Code Reconstruction */

CSC/ECE 517 Spring 2013/OSS E629

2013-03-23T17:50:27Z

Cyang14: /* Assignment Group Modules */

CSC/ECE 517 Spring 2013/OSS E629

2013-03-23T17:49:46Z

Cyang14: /* Experience Point Report */

CSC/ECE 517 Spring 2013/OSS E629

2013-03-23T17:48:54Z

Cyang14: /* Project Requirement */

CSC/ECE 517 Spring 2013/OSS E629

2013-03-23T17:48:16Z

Cyang14: /* Project Requirement */

CSC/ECE 517 Spring 2013/OSS E629

2013-03-23T17:47:42Z

Cyang14: /* Project Introduction */

CSC/ECE 517 Spring 2013/OSS E629

2013-03-23T17:47:02Z

Cyang14:

=E629: Integrating game frontend for Expertiza=

==Project Introduction==

==Project Requirement==

==Our Work==

===Experience Point Report===

===Assignment Group Modules===

===JavaScript Code Reconstruction===

===Fixing Mega Bugs===

===Fixing Minor Bugs===

==General Introduction to the System Setup==

CSC/ECE 517 Spring 2013/OSS E629

2013-03-23T16:52:51Z

Cyang14: Created page with "=E629: Integrating game frontend for Expertiza="

=E629: Integrating game frontend for Expertiza=

CSC/ECE 517 Spring 2013/ch1 1h jc

2013-02-24T16:55:33Z

Cyang14: /* Mini-language for boiler-plate */

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.

==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-24T16:54:12Z

Cyang14: /* References */

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.

==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. 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-24T16:53:54Z

Cyang14: /* References */

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.

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

:K. Czarnecki, "Generative Programming" chapter 8, Static Metaprogramming in C++

:http://www.program-transformation.org

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

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

CSC/ECE 517 Spring 2013/ch1 1h jc

2013-02-24T16:53:34Z

Cyang14: /* References */

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.

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

: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-24T16:53:16Z

Cyang14: /* References */

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.

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

: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-24T16:52:49Z

Cyang14: /* References */

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.

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

: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-24T16:52:37Z

Cyang14: /* References */

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.

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

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-24T16:52:10Z

Cyang14: /* References */

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.

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

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-24T16:51:18Z

Cyang14: /* References */

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.

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

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

http://www.program-transformation.org

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

CSC/ECE 517 Spring 2013/ch1 1h jc

2013-02-24T16:49:30Z

Cyang14: /* Introduction to reflection */

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.

==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. 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-24T16:48:59Z

Cyang14: /* Introduction to reflection */

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.

==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. 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="reflection">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-24T16:46:48Z

Cyang14: /* Metadata annotation */

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.

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

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-24T16:46:26Z

Cyang14: /* Generics */

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.

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

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.

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-24T16:45:32Z

Cyang14: /* Generics */

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.

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

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

CSC/ECE 517 Spring 2013/ch1 1h jc

2013-02-24T16:44:14Z

Cyang14: /* Introduction to reflection */

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.

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

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

CSC/ECE 517 Spring 2013/ch1 1h jc

2013-02-24T16:42:55Z

Cyang14: /* Introduction to reflection */

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.

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

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

CSC/ECE 517 Spring 2013/ch1 1h jc

2013-02-24T16:41:19Z

Cyang14: /* Mini-language for boiler-plate */

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.

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