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

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

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)

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.

1. General - This element describes the learning object as a whole.
2. 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.
3. 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.
4. 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
5. 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.
6. 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 )

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)

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

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

This system also has the following capabilities

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