| Project: |
Web-CAT Rubric Designer |
|
| Student Researchers: |
Jaime Garcia-Ramirez, |
|
| Advisor: |
Stephen Edwards |
|
| Institution: |
Virginia Tech |
|
| Webpage: |
Project Description: goals and purpose of the project
The goal of the Web-CAT Rubric Designer project was to create a tool by which professors would be able to create grading rubrics in an online system which could later be accessed by other users. The driving point was to create an online sharing community where professors could not only share rubrics but also assignments. Due to the many complexities involved in creating not only assignments but the rubrics to grade them by, the designer tool would allow for a standardized way of creating and editing new rubrics. The system was to be designed in such a way that it would integrate into Virginia Techs existing Web-CAT automated grading system. Web-CAT is a system that allows for programming assignments to be submitted and in some cases automatically graded by using input/output comparisons or unit testing.
The purpose of having rubric based grading is two-fold. The first reason is to facilitate the grading process for either professors or teaching assistants. Having a rubric, grading tends to be more objective because the assignment submitted either meets the requirements listed or it doesnt. Since a rubric is basically a worksheet for grading, ambiguities such as if something was covered or not are reduced if not eliminated. The second reason as to why rubric based grading is efficient, is because it provides the students with concrete reasons justifying their grade. These advantages hold as long as the rubric is a well-written one. This is where a sharing system comes in place, where professors can create and more importantly edit rubrics, after some iterations, even a badly written rubric can become a work of art.
Process used on the project
The team started the project by first creating prototypes of the Rubric Designer. They developed the prototypes after considering what kinds of rubrics and what kinds of features were necessary to support. Having a couple of professors as guides and asking what they would want a rubric to contain, the team came up with a starting foundation. The team decided that a rubric format would have to be standardized, handling custom sets of rubrics in arbitrary formats would be too complex. One of the constraints was to have the user group similar types of questions into categories. Also, the team made a simplifying decision to support only single-level categories, rather than allow categories nested within other categories. Questions all had to be made in such a way that they were to be answered in a multiple choice format.
The interface of the system was prototyped in such a way to be a WYSIWYG interface. This came about because, as a user, being able to see right away what the final product will look like is more helpful than rendering it from a series of commands. With this type of interface new challenges arose. The first was to find a way to allow the user to re-order questions. One of the options was to have a button that the user clicked that would display a pop-up box asking which question to move to where. This however, would have led to a tedious task whenever a question had to be moved possibly leading to frustrated users. One answer did come to mind however, drag-and-drop. We implemented the drag-and-drop question re-ordering functionality by using Yahoos User Interface (YUI) Library. This solved the problem.
After settling on a user interface, the team started looking at the software engineering aspects of the project. The reason for leaving the software engineering aspect last was because this is a user-driven tool, therefore the software must change to the users need and not the other way around. First, the team built a data model. The data model linked all aspects of the rubric to each other by means of unique identifiers. Next, the implementation architecture was laid out using a combination of Javascript and DHTML. The loading and saving of information was done using AJAX, and the encoding of information to and from the server using JSON. The use of these technologies allows for a seamless user experience, without having to refresh the page when new changes occur and at the same time creating the appearance of an actual desktop application.
The last part the team completed was creating the backbone for this system. The team created a database to allow for interaction between the user and server. At this time, all data gathering parts of the prototype were abstracted out as well. This way the interface itself does not have to be updated if the data source changes and vice versa. In this implementation, the middleware was written using PHP classes that receive commands from the interface and then relay information back from the database.
Conclusions
The undergraduate researchers on this project learned a great deal about web application construction and the use of modern Web 2.0 infrastructure technologies, including AJAX and JSON. The project implementation did not reach its final release state as intended. Along the way, the team confronted a number of unforeseen problems and had to cope with the wide scope of the project. Discovering the problems and tackling them was an important part of the research and learning process, and the team did produce a strong foundation for future work. The prototype for the project demonstrates significant uses of new Web 2.0 technologies and finishing the project is not out of the question. The team's knowledge of Web 2.0 techniques has increased thanks to the work put into this project, but as always, even minor details such as browser incompatibilities stifle the overall progress.
Websites Developed and Publications
Web pages developed: