Time: 08:30-17:30, June 26
Abstract. This tutorial provides experience with the Cognitive Tutor Authoring Tools (CTAT), a suite of tools that help authors build intelligent tutoring systems. The tutorial will have two parts: the morning session focuses on the development of example-tracing tutors, built by demonstration rather than programming; the afternoon session provides experience with creating traditional rule-based cognitive tutors. A key objective of the tutorial is to foster discussion on the aspects of authoring tools that are most beneficial to tutor authors.
1 Introduction and Objectives
Intelligent Tutoring Systems have been shown to be effective but are hard to build. That difficulty may be one reason why, with a number of notable exceptions, they are not in widespread use. One possible answer is to create authoring tools that make tutor development easier and less time-consuming [1, 2] The main goal of the Cognitive Tutor Authoring Tools (CTAT) project is to provide a suite of authoring tools that make tutor development more affordable by leveraging human-computer interaction, machine learning and data mining techniques [3, 4]. The tutorial provides an introduction to CTAT by means of carefully-scaffolded hands-on activities with a minimum of lecture. After the tutorial, participants can continue to use CTAT free of charge for research and educational purposes. See http://ctat.pact.cs.cmu.edu.
CTAT aims to support the development of tutors for both real-world and experimental use--for example, empirical experiments to evaluate whether a particular tutor feature results in improved learning. Thus, the target users for CTAT (and the target audience for the tutorial) include not only tutor developers but also ITS researchers.
CTAT supports the development of two types of tutors: Cognitive Tutors, which have been successful in raising students’ test scores [5]; and a relatively novel type called “Example-Tracing Tutors,” which provide much of the functionality of Cognitive Tutors, yet can be built without programming [3]. The tutorial covers both types of tutors. It also features recent CTAT extensions that address authoring efficiency for Example-Tracing Tutors, integrate student interface technology especially suited to web delivery (viz., Flash), and aid the creation of production-rule models used in Cognitive Tutors.
By direct, hands-on experience, the tutorial seeks to enable participants to evaluate whether the CTAT tools would be useful for their own development, research or teaching activities. Participants also will learn some of the general capabilities of intelligent tutoring systems. A second objective is for participants to reflect and comment on CTAT’s usefulness and usability. We seek suggestions that might help us to continue to improve the tools and make them more broadly applicable.
2 Target Audience, Topics and Content
The target audience includes the following.
1. Researchers and developers interested in creating intelligent tutoring systems (perhaps for use as embedded components) and looking for tools to help.
2. Educators interested in developing on-line exercises for their courses
3. Researchers in intelligent tutoring systems interested in using tutors as an experimental platform to explore hypotheses about learning or instruction
We request 2 half-day tutorials that each could stand alone but together form a coherent full-day presentation. Most of each session will consist of carefully-scaffolded hands-on activities, but we include time for discussion and suggestions from participants. The morning session covers Example-Tracing Tutors, which are easier to build than Cognitive Tutors but less general. The afternoon session addresses the development of Cognitive Tutors, which require AI programming. By splitting the tutorial into 2 half-days, we hope to make it possible for participants to focus on topics that match their needs. People already acquainted with CTAT might choose only the afternoon session. Those without the skill or desire to implement production rule models might attend only in the morning. Both sessions together provide a complete view of CTAT.
The planned morning session covers the following topics:
· Creating a student interface: Participants use drag-and-drop tools integrated with CTAT to create or modify a student interface (i.e., a GUI) that exposes the cognitive steps in the chosen domain.
· Example-Tracing Tutors: Using only programming-by-demonstration, without writing code, participants create a complete problem-specific tutor that, within its scope (a single problem), provides a student experience with all essential ingredients of that supported by Cognitive Tutor.
· Mass production of tutors: With the Example-Tracing Tutor as a template, participants quickly create new problem instances using an Excel spreadsheet.
· Web deployment and trial: If time permits, participants deploy their tutors and quizzes and try them out as if they were student subjects in an experiment.
The afternoon session continues work in the same domain but concentrates on creating cognitive models using CTAT with the Jess system [6]. Its topics include:
· Production rule outlining guided by Behavior Graphs: Participants use steps from the Behavior Graphs (i.e., the examples of demonstrated behavior recorded for Example-Tracing Tutors) to outline the content of rules needed for the cognitive model (i.e., create “pseudo code” for their production rules).
· Working memory design: Participants will adapt a partially-built design of working memory elements to support production rule modeling
· Rule writing, testing and debugging: Participants use facilities in the tools for writing production rules, executing them, and debugging them.
3 Schedule and Facilities
We will need a lab with networked, Windows-based PCs having CTAT, Java v1.4.2 and Flash MX2004 pre-installed (the no-cost evaluation version is adequate).
Table 1: Schedule for both sessions. Nearly all activity is hands-on.
|
|
Morning Session
|
|
15 min.
|
Opening, introductions of personnel, and agenda
|
|
20 min.
|
Demonstration: building an Example-Tracing Tutor using CTAT
|
|
40 min.
|
Create part of a student interface, record an example-tracing tutor and create a template solution graph
|
|
15 min.
|
Break
|
|
15 min.
|
Convert the template graph to a spreadsheet for mass-producing examples
|
|
30 min.
|
Mass-producing example-tracing tutors with a spreadsheet
|
|
20 min.
|
Transferring tutors to a web server for distribution
|
|
30 min.
|
Reflection and discussion
|
|
|
Afternoon Session
|
|
30 min.
|
Explanation of model-tracing in intelligent tutoring systems (lecture)
|
|
20 min.
|
Writing pseudo code for production rules (discussion)
|
|
20 min.
|
Demonstration of rule editing, testing and debugging using CTAT
|
|
20 min.
|
Completing a working memory design to support rules’ execution
|
|
15 min.
|
Break
|
|
90 min.
|
Writing, testing and debugging rules to complete a partially-built model
|
|
30 min.
|
Reflection and discussion
|
T1, T2 are canceled.