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.