Random Musings

Still thinking !!!

2009-08-31T00:52:00.000-07:00

Week 13 : 11/20/2007 - 11/30/2007 ( Writing CS 297 report)

2007-11-27T00:35:00.000-08:00

Writing the CS 297 report.
I am thinking of including the following

1. Abstract
2. Problem Definition and Use-cases(a couple of them )
3. Current implementation ( Web-Cat, labrat,Curriki)
4. Things I did ( extended labrat for upload, check.properties etc)
5. Repository use-cases and schemata
6. Conclusion

Week 12 : 11/13/07 - 11/19/07( Design of the repository UI mock ups)

2007-11-20T00:29:00.000-08:00

This week focussed on the use-cases and design of the repository UI.

1. Designed the repository UI for various use-cases involving uploading, downloading, categorizing, remove, fork and critique of assignments.

Week 11 : 11/06/07 - 11/12/07( labrat installation on oslo, labrat-web fixes, schema definition)

2007-11-13T00:48:00.001-08:00

This week focused on the following activities.

Installation of Labrat on OSLO

Installed the labrat tool and the web interface for the tool on oslo.

2. Fixes

Made the following fixes

Added a unqiue salt so that every upload of the same set of exercises will generate different unique directory names
Fixed the "More" button on the first page of the wizard. I had to return "null" from the action handler to remain in the same page. I was returning "" , thinling that a "blank" return will do the same.
Added the export functionality to the check.properties file of each exercise. Clicking on the "Export" button will bring up the check.properties file.

3. Pondered over the schema definition for the original problem i.e. authoring and sharing of exercises. I have written up a write up on this and have sent the document as an attachment.

Week 10 : 10/30/07 - 11/05/07( Revised Implementation of check.properties generation)

2007-11-06T00:23:00.000-08:00

Generating check.properties

This week focussed on the revised implementation of the check.properties generation

As discussed, this process will have a wizard interface.

1. When an exercise is uploaded, labrat-web will look for a check.properties file

2. Contents of Page 1 -General of the wizard
Generating check.properties for exercise - ExP6_5

Q1.Main class of the assignment     DataAnalyzer.java
                                                                   DataSet.java
                                                                DataSetTester.java

Q2 File Name     Editable
DataAnalyzer.java     []
DataSet.java     []
DataSetTester.java    []

Q3 [] Is this a GUI Application?

Navigation Flow
------------------

If the box is unchecked then it is forwarded to Page 2 which displays "console" properties.

3. Contents of Page 2 - "console" of the wizard

Generating check.properties for exercise - ExP6_5
[ ]Run this program
[ ] with this input [ -------------------------]
[ ] with input(s) provided in file(s)
[ ] without inputs

Command line [--------------------------------]
Classpath [-----------------------------------]

[ ] compare output to content stored in file(s) [-------------------]
[ ] capture output to report

ISSUES

1. I had problems with generating this UI

[ ] with this input [ -------------------------]

It is kind of difficult to produce a text box next to a radio button. The closest I got to in generating this UI was this jsf snippet

<html:selectOneRadio layout="pageDirection" value="#
{exerciseUpload.currentExercise.studentDir.mainclassRunOptions}" >
<core:selectItem itemValue="1" itemLabel="with this input ">
[<html:inputText size="50" value= "#{exerciseUpload.currentExercise.studentDir.runMainClassInput}" /> ]

</core:selectItem>

</html:selectOneRadio>

2. This UI element

[ ] capture output to report

doesn't have a corresponfing property. The check.xml(labrat tool) basically checks if the *.out is present. If not it is just copied to a report file.

Does it need to be in the UI ?

3. This UI element

[ ]Run this program
[ ] without inputs

doesn't have any corresponding property in check.properties. Again check.xml checks if the property test.run.inputstring is set. If it hasn't been set then a blank string id assigned to this property.

Does it need to be in the UI ?

Navigation Flow
------------------
When this page is submitted, the wizard will check for the existence of *Tester*.java or *Test.java. If any of these files exists, it will forward to the "tester" properties page which is page 3 of the wizard.

4. Contents of alternate Page 2 - GUI of wizard

Generating check.properties for exercise - ExP6_5

[ ]Run this Program DataAnalyzer.java
DataSet.java
DataSetTester.java
Command line [----------------------------------------]

Navigation Flow
------------------

When this page is submitted, the wizard will check for the existence of *Tester*.java or *Test.java. If any of these files exists, it will forward to the "tester" properties page which is page 3 of the wizard.

5. Contents of Page 3 - "tester"

Generating check.properties for exercise - ExP6_5

[ ] Run tester program
o Horstmann Style test ("Expected: ")
0 JUnit test

Navigation Flow
----------------

If the option "Horstmann Style .." is selected, then the wizard checks for the existence of file *.in, which are input files for the tester. If the file is not found an error is thrown.

Issues
--------

1. I think the user should be given a chance to generate the input and output files instead of throwing an error.

6. Contents of Page 4 - "output" capture and compare

Generating check.properties for exercise - ExP6_5

Select the type of comparison to use.
0 line
0 word
0 number

Enter the tolerance factor when comparing numbers [-------------------]

Navigation Flow
-----------------
The wizard generates the check.properties at this stage and forwards to the "view results" page.

7. Contents of Page 5 - View results page

Assignment Upload Status:

Check.properties file was successfully generated. Save this file for future use.

View Result
ExP6_5URL for the assignment is given below:

http://localhost:8080/labrat-web/exercise_submit_files.faces?directory=3a9sglth0e1ri3wd6izigveya&problem=CS40%2FExP6_5

If you want to register for easy uploading of exercises in future - Register

The generated URL will be published to the student for submitting the assigment.

Setting up labrat and labrat-web on OSLO

Tried to connect to oslo but it didn;'t connect through telnet

Microsoft Telnet>
Microsoft Telnet> open oslo.cs.sjsu.eduConnecting To oslo.cs.sjsu.edu...Could not open connection to the host, on port 23: Connect failed
Microsoft Telnet> open oslo.cs.sjsu.eduConnecting To oslo.cs.sjsu.edu...Could not open connection to the host, on port 23: Connect failed

Microsoft Telnet> open oslo.cs.sjsu.eduConnecting To oslo.cs.sjsu.edu...Could not open connection to the host, on port 23: Connect failed

Microsoft Telnet>

Week 9 : 10/23/07 - 10/29/07( Implementation of check.properties generation)

2007-10-29T09:28:00.000-07:00

This week was focussed on generating a check.properties file, if it is has not been included in the problem.

The solution was to develop a wizard like interface and ask the user a set of questions. Each page thereafter is driven by the answers to the current set of questions or prompts. The set of questions that will be asked are the following:

1. Page 1 ( Start page )

Question 1. Does this assignment needs to include a main class to be submitted by the student ?

2. Page 2

Prompt 1. Select the java class that will be marked as the main class.(The selection will be a set of radio button and the labels will be derived from the *.java classes that is present in the */student/ directory of the assigment that was uploaded.)

Prompt 2. Enter comma-separated list of required classes that a student must submit.
Prompt 3. Enter comma-separated list of required files that a student must submit.

Question 1. Is this assignment a GUI application ?
Question 2. Should the assignment's main class be run and its output captured and compared with an instructure supplied output file ?

Question 3. Should the assignment's main class be run with external inputs like *test*.in and the corresponding outputs of the program compared with instructor supplied output file like *test*.out ?

3. Page 3 ( If the submitted assignment is a GUI application )

Prompt 1: Enter the command line arguments to pass to the application when taking a snapshot.

Prompt 2: Enter the key strokes to execute before taking the snapshot of the application

Prompt 2: Enter the name of the program to run when taking a snapshot(Default is mainclass)

4. Page 4 ( if property test.run is true)

Prompt 1: Enter the command-line arguments to pass to the application when running it and capturing its output.

Prompt 2: Please specify the input to the application.

Prompt 3: Select the name of the file containing the expected output file ( The file names will be displayed will be ones which has extension *.expected and is present in the */student/ directory of the uploaded assignment )

5. Page 5 ( if property test.test-inputs is true )

Prompt 1 : Enter the command line arguments to pass to the application when testing inputs.

Prompt 2 : Please specify the classpath.

6. Page 6 ( if one of the properties test.run or test.test-inputs is true)

Prompt 1: Select the type of output comparision to use ( Available options are line,number,word)

Prompt 2: Please enter the tolerance factor.

After Page 6, the check.properties will be generated and written to the */student/ dirctory of the uploaded assignment.

If multiple assignments are loaded, then the process of generating check.properties will be done for each assignment.

Design
------

1. The ExerciseMB.java will keep track of the directory structure and the name of the files that were uploaded for an assignment. Each uploaded assignment will encapsulated in a class Exercise. The structure of the class is given below

Exercise
String name ( name of the exercise)
Directory for student
Directory for solution
Directory for grader
Directory for description

Each Directory object will have the set of file names that is part of the assignment

Directory
String name ( name of the directory)
String[] dirPath ( path of the directory from the root)
String rootPrefix ( root of the directory which will be repositorypath)
List of *.java files
List of *.html files
List of *.in and *.out files
List of *.expected files

Properties properties( check.properties values)

boolean hasProperties( boolean to indicate whether a check.properties is present in the Directory

2. When the assignment upload is complete, it will check if the assignment has a check.properties file by introspecting the */student/ directory. If no check.properties has been found, the the property

currentExercise
of ExerciseMB will be set to the name of the exercise and then the wizard will process will kick in for generating the check.properties for the */student/ directory of the uploaded assignment.

3. The various properties of the check.properties will be filled in by accessing the member Properties object of the Directory whose name is "student". For example to the set the property that an assignment has a main class, the jsf code is as follows:

<html:selectBooleanCheckbox value="#{exerciseUpload.currentExercise.studentDir.mainClassRequired}" /> <html:outputText value="Does this assignment have a main class to be submitted by student?" />

The property "currentExercise" will always point to the uploaded assignment which doesn;'t have a check.properties defined.

4. Each Exercise is associated with a wizard interface. The wizard has the information about its set of pages and it forwards to the relevant pages by introspecting the current page and the set of properties that has been enabled in the Properties object of Directory "student" as a result of questions/prompts from previous pages.

5. At the end of the wizard phase, a check.properties will be generated and written to the */student/ directory of the assignment.

Issues
---------

1. I am using tiles to define templates for a page. Unfortunately I cannot forward to a tile name. I have to create another .jspx page and then insert the tile definition in that page.

2. Initially I thought that extra path info can be passed to an assignment url. For example

http://localhost:8080/labrat-web/exercise_submit_files.faces/fjfjfjf9riwiwiw*&gdh2535/course name/exercise name

This looks more elegant than passing parameters in the URL. A tiles controller can be developed to parse this URL and then pass it as request parameters for downstream handling of the particular exercise. (This will be used as submit urls by the students)

It doesn't seem to work with jsf servlet mapping.
The error, predictably, is resource not found.

3. How do I encode a JSF view with parameters ? For example If I need to forward to a view

"some_view" with certain set of request parameters, how do I do it ?

Week 8 : 10/16/2007 - 10/22/2007 ( Implementation of additional labrat features)

2007-10-22T22:52:00.000-07:00

The following was implemented

1. The upload feature was implemented and the result page showed the files and directories
uploaded to the repository.
2. Integrated the submit files page with the new UI.
3. Traced the debugger problem.
4. Fixed the tile layout issues.

Work in progress
-------------------
1. Implementing the check.properties discovery and generation.

Week 7: 10/09 - 10/15 Implementation of additional Labrat features ( 20+ hours)

2007-10-16T01:45:00.000-07:00

The following was done

1. Converted the UI to a tiles implementation.
2. Implemented the upload and upload results screen. Will need to debug it.
3. After converting to equivalent JSF tags, the UI hasn't come out as I wanted it to be. Will need
to figure out by loading the HTML output in a designer.

ISSUES

1. Cannot attach a debugger. It is crapping out with this error

Incrementally deploying web_localhost:4848_serverCompleted incremental distribution of webDuplicated project name in import. Project labrat-web-impl defined first in C:\projects\labrat\web\nbproject\ant-deploy.xml and again in C:\projects\labrat\web\nbproject\build-impl.xmlconnect-debugger:Non-existing path "C:\projects\labrat\web\build\ear-module\WEB-INF\classes" provided.C:\projects\labrat\web\nbproject\build-impl.xml:553: The following error occurred while executing this line:C:\projects\labrat\web\nbproject\build-impl.xml:557: org.netbeans.api.debugger.jpda.DebuggerStartException: Connection refused: connectBUILD FAILED (total time: 1 second)

It started happening once again. Tried uninstalling and installing 5.5.1 and V2. Didn't work.

I resolved the earlier message. It happens if Tomcat is running in non-debug mode. I am getting this success message.

deployment started : 0%deployment finished : 100%Deploying application in domain completed successfullyTrying to create reference for application in target server completed successfullyTrying to start application in target server completed successfullyDeployment of application web completed successfullyDuplicated project name in import. Project labrat-web-impl defined first in C:\projects\labrat\web\nbproject\ant-deploy.xml and again in C:\projects\labrat\web\nbproject\build-impl.xmlconnect-debugger:Non-existing path "C:\projects\labrat\web\build\ear-module\WEB-INF\classes" provided.
Attached JPDA debugger to localhost:9009

Duplicated project name in import. Project labrat-web-impl defined first in C:\projects\labrat\web\nbproject\ant-deploy.xml and again in C:\projects\labrat\web\nbproject\build-impl.xmldebug-display-browser:BUILD SUCCESSFUL (total time: 3 seconds)

The debugger is getting attached, but IDE cannot connect to it. Connection refused.

Week 6 : 10/02 - 10/08 - Design of Additional Labrat features

2007-10-08T21:53:00.000-07:00

This week was focused on marking up the design for additional features for Labrat in HTML.

Summary
------------
Repository Structure

Each instructor will be identified based on the following fields:

name

title

university name

If the instructor wishes to register, these fields will be hashed to form a unique string. This "unique string" will be labelled as the root directory of the repository.

The repository directory structure is as follows

The meta directory will be used to store "close" match hash strings from instructor profiles.

UI Interface

Registration Page ( Instructor view)

The fields that were put in this page to uniquely identify an instructor were: name, email, title, university name. These fields will be used generate a hash, which will be the root directory in the repository for uploaded assignments for that instructor.

If the instructor doesn't wish to register then he/she has to input that information during upload of assignments.

2. Assignment Upload (Instructor view)

An instructor will come to this page to upload assignments. If the check.properties file is missing from the jar file, then one will be generated from the instructor's input.

A successful upload will generate a link for the instructor to be given to the student. The format of the link is given below:

http://www.labrat.sjsu.edu/ieo987$#jkiolp09*djdjjdjdjdj/CS101/Exercise_1

The unique token string is the one that will belong to the instructor. It includes the course id nunber and the name of the assignement.

3. check.properties generation page

This page will take the instructor input to generate a check.properties file. Since the number of properties are large, it will make sense to separate out the properties into required and optional ones. And within each of the categories it will be further divided into functional regions like

display,documentation,build,test/execute

4. Assignment Submit ( Student view)

Students will come to this page via the link that may have been provided by their instructors. A link will look like

http://www.labrat.sjsu.edu/ieo987$#jkiolp09*djdjjdjdjdj/CS101/Exercise_1

This page will display the files that needs to be submitted for that assigment by introspecting the check.properties file.

Week 5 : 09/26 - 10/01 (JSF, Web Labrat and Upload exercise)(12 hrs)

2007-10-01T17:06:00.000-07:00

This week concentrated on getting comfortable with JSF and Exercise Upload Tag.

Netbeans 5.5.1 and V2

Downloaded and installed Netbeans 5.5.1 and Glassfish V2.

Web labrat

Ran the labrat web interface
1. I commented out the Mail session and the mail functionality. It does seem to work after that.
A UI came up to paste the required files. No "cyclic errors".

Upload tag

1. Integrated the upload tag from core jsf into web labrat
2. Tailored it to upload exercises and create the path in the repository directory.
3. Need to add a parameter whether the user is uploading a zip file with UNIX or WINDOWS style path entries.

Week 4: 09/18- 09/24 (18 hrs) ( JSF 1.2 and Labrat)

2007-09-25T09:03:00.000-07:00

These were the following activities.

Ramp up on JSF 1.2 ( 10 hrs)

Most of the time was focussed on ramp up on JSF 1.2. Core JSF (Chapters 1-6) and Chapter 9.

Labrat ( 2 hrs)

Executed the standalone labrat script on an exercise example. I did have to spend some time converting the bash shell commands to windows scripts. Looked at the code to figure out the execution path. ( 4 hrs)

Web-Labrat ( 2 hrs )

Changed the initialization parameters such as the repository path. It still gives the error "cyclic reference". I debugged this a little bit. I think it is failing because of the repository path and the bad repository path exception is not handled in the ProblemSubmission.load() method.

On windows I have given the repository path as

C:\\java\\labrat\\exercises in web.xml intialization parameter section.

Feature: Upload exercises in Web labrat ( 4 hrs )

Work in progress. I have decided to implement it as a custom JSF component. For example

Week 3 : 09/11/2007 to 09/17/2007 ( 8 hrs) Web-CAT and Labrat

2007-09-18T12:12:00.000-07:00

This week the activities focused on getting to know Web-CAT and Labrat at the source code level.

Web-CAT

1. Download the source-code through CVS client which is part of NetBeans IDE 5.5.
2. There are too much unfamiliar technologies(WebObjects) and lack of documentation(build/source)
made it quite difficult to come to any conclusion on making source code changes to Web-CAT.
3. It also looked like every backing object for a web Page is derived from a auto-generated persistent objects, meaning that every page is mapped to a persistent store object.

LabRat
1. Downloaded the source code for the standalone tool and the web interface
2. Installed the environment(glass fish App Server, ANT(build env) etc.
3. Built and deployed the jars.
4. There are some errors while invoking the pages in the web-interface. (Cyclic references)

Week 2 - (09/04/07 - 09/10/07) Learning Object Metadata model ( 8 hrs)

2007-09-10T12:25:00.001-07:00

Overview

It is an attempt to describe the meta-data model for learning objects which can be searched,evaluated,tagged(annotated) and exported to various automatic submission and grading tools available in the market. The central repository will consist of instances of this meta model describing the underlying learning objects.

A metadata instance for the learning object will describe the characteristics of the learning objects, which is relevant to its definition and applicability in the educational field. Such characteristics will be grouped together as General, Educational,Structure(describes the content),LifeCycle,Annotation and Rights(usage rights).

The definitions below are for a conceptual metadata and it doesn't take into account the implementor language for defining this metadata. This could be easily translated into an XML Schema definition or any repository schema such as a relational database.

Basic Metadata Overview

Given below are the basic metadata overview and a brief description of the elements involved.

General - This element describes the learning object as a whole.
Educational- It will describe the educational characteristics of a learning object,its typical applicability, technical requirements(technology used),particular coverage area, difficulty,targated courseware etc.
Structure - This element will describe the structure of the learning object. It will include information about the mime-type of its content, file set included,dependencies etc.
LifeCycle - This element will record all the activities(CRUD) done on the learning objects. It will record the principal names, contributions, current version, state of the learning object
Annotation - This element will record the feedback,rating and the use of the learning object in the educational field. Extensible tags can be defined to record additional keyword.
Rights - This element will have any copyright instruction to use the learning object in a particular field.

Metadata Schema

Given below is a conceptual metadata schema to author and share learning objects across various users. This schema can be be easily adapted to an XML format or any repository schema like a relational database.

1. General

This will keep general information about a learning object as a whole

1.1 Object Id - The global identifier for the Learning Object within the repository.
1.2 Title - The title of the Learning Object.
1.3 Language - The language in which this Learning Object has been expressed for example "en-US"
1.4 Description - A textual description of the content of the learning object.
1.5 Keywords
1.5.1 Keyword* - Multiple keywords entries to identify and tag this learning object. This will be used in searhing for a learning object on a specific set of keywords

2. Educational

This element will capture the essential educational characteristics and applicability of this object in the educational field.

2. 1 language - This will describe the host language in which this learning object has been written i.e. Java, C++ etc

2.2 Min version - Minimum version of the compiler or the driver software to run this.

2.3 Installation - Any installation help text to install this learning object.

2.4 Technology Stack

2.4.1 Name * - name of the technology

2.5 Target Audience - Subjects for which this learning object has been designed for example instructors, students, publishers etc.

2.6 Difficulty level - Level of difficulty ( easy,hard etc)

2.7 Duration - Likely duration to complete this learning object

2.8 Context - The principal environment within which the learning and use of the learning object is intended to take place. for example in the junior year, senior etc

2.9 Description - Detail description on how to use the learning object

3. Structure

This element describes the content of the learning object that is persisted in the repository. It will define the various artifacts the make up the learning object.

3.1 resource* - Resources that make up the learning object

3.1.1 Name - name of the resource

3.1.2 Mime Type - The content type such as text/html, application/x-jar etc.

3.1.3 Location - Location of the resource. It could be defined in terms of URI, URL. This field will also have a special tag to describe that the content has been persisted in the repository as a CLOB or BLOB

3.1.4 Content - The actual content of the resource for exampe it will contain the text for a .java file.

4. LifeCycle

This element will capture the lifecycle of the learning object as it goes through various incarnation in the central repository

4.1 version -Current version of the learning object

4.2 last update -Last updated date and time

4.3 Subject - Person/oraganization which made the last update.

4.4 Audit Trail*

4.4.1 Subject - person/organization making the change

4.4.2 role - On what capacity, it is making changes to the learning object i.e. as an author ,publisher etc.

4.4.3 date - The date the change was made.

4.4.4 change record - A record to capture the delta change that was made

5. Annotation*

This element will describe the feedback and other information about the usage of this learning object in various course-wares.

5.1 Subject - Person/organization which created this annotation
5.2 Date - The date this annotation was created.
5.3 Content - Description of this annotation
5.4 Tags* - Any extended tag annotation that may be needed for feedback for example rating
5.4.1 Name - Name of the tag
5.4.2 Value - The content of the tag

6. Rights

This element will describe the copy right information about this learning object
6.1 Cost - The cost of using this learning object.
6.2 Copy Right Instruction - The text describing the copy right of the learning object
6.3 Description - Any other description that needs to go with it.

Week 2 : 09/04/07 to 09/10/07 ( 1 hr )

2007-09-09T22:43:00.000-07:00

The following example illustrates the artifacts that needs to be created in Web-CAT to create an assignment. The homework assignment in question has been taken from

http://www.horstmann.com/sjsu/cs46a/hw6.html

Exercise 7.10 Factoring of integers. Write a program that asks the user for an integer and then prints out all its factors in increasing order. For example, when the user enters 150, the program should print
2
3
5
5
Use a class FactorGenerator with a constructor FactorGenerator(int numberToFactor) and methods nextFactor and hasMoreFactors .
This class generates all the factors of a number.

public class FactorGenerator
{
/**
Creates a FactorGenerator object used to determine the factor of
an input value.
@param aNum is the input value
*/
public FactorGenerator(int aNum)
{
// TODO
}
/**
Determine whether or not there are more factors.
@return true there are more factors
*/
public boolean hasMoreFactors()
{
// TODO
}
/**
Calculate the next factor of a value.
@return factor the next factor
*/
public int nextFactor()
{
// TODO
}
// TODO: instance fields
}

1. The first step is to create an assignment for the particular course offering.

2. For this assignment, the instructor has to upload a reference JUnit test file which is name
as FactorGeneratorTest.java. This JUnit test file will be executed whenever a students submits a solution for this assignment.

This test file needs to be targeted to a directory which is accessible by the web-server.

This configuration step is specific to an assignment and is part of several steps to configure the JavaTdd plugin that has been deployed to Web-CAT.

3. There are other configurable options that may need to be set depending on specific requirements of the assignment.

Week 1 - 08/27/07 - 09/03/07 ( 8 hrs)

2007-09-03T19:50:00.000-07:00

One of the first steps in defining a common interchange Meta-data format is to study the feature sets of the automatic grading tools available in the market. The candidates included Web-CAT, Marmoset and SJSU Prof. Beeson's home grown grading tool.

Studying Web-CAT(installation,configuration,usage)

Before installation of this tool, I had a chance to go through the various tutorial videos embedded within the installation package. Those proved to be useful, especially when dealing with WebObjects.

This tool is built around Apple's WebObjects. The installation went through fine and pre-requisites were installation of Tomcat 5 and MySQL server and yes, one has to download Web-CAT_1.3.1.war from sourceforge and drop it in the web applications folder.

The steps included to have a course offering and assignments running are

The first steps are to configure the Web-CAT tool instace. It includes crearing a root user, setting up the MySQL configuration and adding courses offered by the concerned institution.

In Web-CAT there is a clear distinction between courses offered and course offerings for a particular course in a semester by an instructor. It has the same relationships as between a Class and Objects of type Class. Course offerings are instances of the particular course. This is mentioned here as it may play a part in defining an interchangeable meta-data format for a Learning Object.

The next step is to create a course offering. The properties that make up a course offering are

Course, CRN(unqiue course offering identifier), Course Label( description),URL(location)

There are other properties which may not form part of the meta data, such as instructors and graders for that course offering.

The next step is to create an assignment for the course offering. These have properties which could be relevant to be part of a meta-data for a course.

Name, Title, URL(location), Upload Instructions

Each specific assignment can have different submission rules. These rules would be unique to a system, hence may not be relevant as part of the meta-data in describing a course.

Each specific assignment also has a plugin configuration. Each plugin configuration has re-suable properties and assignment specific properties

Java Plugin Configuration

This plugin has two types of configutation options: Re-usable and Assignment specific.

The properties of a re-usable configuration are

Java settings(Java source version compatibility,pre-defined classes or jars in the classpath)

Scoring Settings(Test code submissions, test coverage)

Static Analysis(Check Style Configuration, PMD)

Feedback settings

Assignment specific settings are related to

Junit Reference test classes(These junit test classes are executed against the submitted code)

Supplemental Classes for Assignment(Any jar file or directory of java class files to be put in the class-path when compiling or running submissions for an assignment.)

Data files(Any data files that may be needed when running reference tests)

The properties of any specific Java or C++ plugin configuration may form part of the meta-data information for a course, specifically the files that are included or needed to submit and execute test cases in an automatic grading system.

Studying Marmoset(installation,configuration,usage)

Marmoset is an automated snapshot, submission and testing system developed at the University of Maryland.

Much of the information that is blogged here are got from the demo server which is hosted at

https://marmoset-demo.cs.umd.edu/view/course.jsp?coursePK=1

This gives access to a demo-course but doesn't allow the user to create courses or assignments.

This system seems to be similar to Web-CAT in the sense that it has

Automated Testing - Submissions are graded based on the number of tests that pass.

This system also has the following capabilities

Collecting snapshots - There is an Eclipse plugin called the Course Project Manager to capture snapshots of students' projects to a centralized CVS repository whenever they save their files.

Week 0

2007-08-30T13:20:00.000-07:00

1. Researched on literature materials for Learning Object meta-data definitions.
2. Submitted the revised CS 297 proposal
2. Reading up on AJAX.