iList

iList was created to help students learn linked list (Fossati, et al., 2009). In their research, Fossati, et al. (2009) also investigated the effectiveness of different types of feedback. For this purpose, two versions of iList were created. The first one uses simple feedback and the second one uses more sophisticated feedback.

Apart from the feedback differences, both versions of iList contain the same processes and modules. A simulated environment is created to allow the student to see the linked list as a visual entity. Two types of tasks are provided in iList. The first type of task is one that can be solved by entering the code step-by-step. For this kind of task, iList will display the effect of the code on the linked list, as the student submits the code. The second type of task is one that requires the student to write a snippet of code (not the whole program) to solve the task. A loop construct can be

used in the code snippet. Five tasks of the first type and two tasks of the second type are provided in iList.

As in OOPS, the CBM approach is used in iList. Some CBM constraints are defined in iList to check the correctness of the students’ code. Although these constraints can be used to provide feedback when the students violate a relevant constraint, these constraints cannot tell if the students are following a path that will never lead to a correct solution (Fossati, et al., 2009).

The feedback in iList is grouped into three categories: syntax feedback, execution feedback, and final feedback. The syntax feedback is feedback that is presented to the student when the student enters a command that cannot be understood by iList. The execution feedback is for commands that can be understood by iList but cannot be executed due to the current condition of the linked list. The

final feedback is given when the student asks about the correctness of their code.

The difference between the first and the second versions of iList lies in the way the syntax and execution feedback is presented. The first version of iList was created with simple feedback. An example of this kind of feedback in iList is “I don’t understand command XYZ”. The second version of iList provides a more sophisticated feedback. Such a feedback for example is: “You’re trying to write a pointer assignment statement, right? Did you mean ‘->’ instead of ‘>’ ?”.

In the evaluation, Fossati, et al. (2009) firstly asked the students to take an introductory data structure class. Then in the students’ scheduled lab sessions, the students did a pre-test, completed some linked list tasks from iList (except for the control group), and did a post-test. The students were grouped into four groups. The first group – used as a control group – did not do the linked list tasks (they could do any irrelevant activities) before the post-test. However all the other groups did the

linked list tasks. The second group did the tasks using iList version 1, the third group used iList version 2, and the fourth group did the tasks with human tutors.

Although the result of the post-test showed that the students with human tutors achieved the best results, the performance of students with iList version 2 is less distinguishable from human tutor. Based on the results from the log analysis, Fossati, et al. (2009) also concluded that the type of feedback in iList version 2 enabled the students to achieve a good performance level.

2.2.6 JITS: Java Intelligent Tutoring System

The Java Intelligent Tutoring System (JITS) was designed and developed to help the students in their first programming course in Java at a college or university (Sykes & Franek, 2003). Although it is named as an “Intelligent Tutoring System”, JITS does not contains some modules that usually exist in an ITS, such as the student module and the teaching module.

There are two types of functionality in JITS, named “A” and “B” type. The “A” type functionality is used to handle very straight-forward programming tasks. For such tasks, JITS requires the task statement, the specification, and the solution. The Intent Recognition (IR) module inside JITS uses pattern matching between the solution and the student code. If the student types the code incorrectly, JITS will ask the student to confirm the code that he/she wants to write. For example, if the correct code is “int t =1” and the student writes “intt = 1” then JITS will ask if the student intention in the keyword “intt” is actually “int”. Because the IR module uses pattern matching then it will oblige the student to write their code exactly the same as the solution code. A simple difference in the style of code writing, such as: “int a = 0;” versus “int a; a=0;” will not be allowed in the “A” type functionality of JITS. .

For a task with many solutions, JITS uses the “B” type functionality. In this, JITS employ a minimum distance error-correcting scanner-parser algorithm that is used to fix the student’s code. For example, if the student writes the following code: “public status flot TAX = 5;”, the minimum distance error-correcting in JITS will

correct this syntax to become: “public static float TAX = 5;”.

For a more complex program (with more syntax errors in it), such as:

For (intt i = 1; i <= 10 i++ { smu += i

}

JITS will try to find each syntax error in the program and confirm its findings with the student as feedback. For example, for the code above JITS will ask the student if the keyword “For” (with the capital “F”) is a misspelling and the student’s intention actually is the keyword “for” (with a lower case “f”). If the student answers “yes”, then JITS will change the keyword to the correct one and continue to search another error.

However, with these two types of functionality JITS can only help the student to write a syntactically correct program. No functionality exists to help the student with any logical errors. Therefore in “B” type functionality, JITS cannot check whether the student program solves the given task or not. The “B” type functionality in JITS is very similar to the syntax error checker that is included in many modern programming development environments.

JITS was used in Sheridan Institute of Technology and Advanced Learning in June to August 2004. Two classes participated in this study. One class was used as the experimental group and the other class as a control group. 14 students in the experimental group used JITS on regular basis. From the experiment, Sykes (2007)

showed that there is a significant statistical difference in performance scores between the control group and the experimental group.