KERMIT: a Constraint-based Tutor for Database
Modeling
Pramuditha Suraweera, Antonija Mitrovic
Intelligent Computer Tutoring Group
Computer Science Department, University of Canterbury
Private Bag 4800, Christchurch, New Zealand
pramu16@hotmail.com
, tanja@cosc.canterbury.ac.nz
Abstract: KERMIT is an intelligent tutoring system that teaches
conceptual database design using the Entity-Relationship data model.
Database design is an open-ended task: although there is an outcome
defined in abstract terms, there is no procedure to use to find that outcome.
So far, constraint based modelling has been used in a tutor that teaches a
database language (SQL-Tutor) and a system that teaches punctuation and
capitalisation rules (CAPIT). Both systems have proved to be extremely
effective in evaluations performed in real classrooms. In this paper, we
present experiences in using CBM in an open-ended domain. We describe
system’s architecture and functionality. KERMIT has also been evaluated
in the context of genuine teaching activities. We present the results of an
evaluation study with students taking a database course, which show that
KERMIT is an effective system. The students enjoyed the system’s
adaptability and found it a valuable asset to their learning.
1. Introduction
In previous work, we have shown that Constraint-Based Modeling (CBM) [14] is
extremely effective. We have implemented SQL-Tutor [11], an Intelligent
Tutoring System (ITS) for the SQL database language, and CAPIT [10], a
punctuation and capitalization tutor. This paper presents our experiences in
implementing another constraint-based tutor, this time in the area of database
design. This domain is different from the ones we have previously worked in, as
it is an open-ended domain. Although the final database design is described in
abstract terms (i.e. the features of a good quality design are known generally),
there is no procedure to use to arrive at the final solution. We therefore wanted to
test CBM in such a domain.
The Entity-Relationship (ER) data model, proposed by Chen [3], is the most
widely used model for conceptual database design. Although the ER model is
relatively simple, students have many problems developing ER diagrams. The
text of the problem is often ambiguous and incomplete. ER modelling is not a
well-defined process. There is no single best solution for a problem, and often
there are several possible schemas for the same requirements. Although the
traditional method of learning ER modelling in a classroom environment may be
sufficient as an introduction to the concepts of database design, students cannot
gain expertise in the domain by attending lectures only. In tutorials, a single tutor
must cater for the needs of the entire group of students, and it is inevitable that
they obtain only limited personal assistance. Therefore, the existence of a
computerized tutor, which would support students in acquiring database design
skills, would be highly important.
We start by reviewing related work. Section 3 describes the overall
architecture of the system. Section 4 presents the evaluation study that showed
the effectiveness of the system. The conclusions are given in the last section.
2. Related Work
There have been only two attempts at developing ITSs for DB modelling. ERM-
VLE [9] is a text-based virtual learning environment for ER modelling, in which
students design databases by navigating the virtual world and manipulating
objects. The virtual world consists of different rooms, such as entity creation
rooms and relationship creation rooms. The authors claim that the organisation of
the environment reflects the task structure. The student issues commands such as
pick up, drop, name, evaluate, create and destroy to manipulate objects. The
effect of a command is determined by the location in which it was issued. For
example, a student creates an entity whilst in the entity creation room.
The interface of ERM-VLE contains the definition of the problem, and a
graphical representation of the solution, but the student does not directly interact
with the graphical representation. The student interacts with the virtual world
solely by issuing textual commands. The problem’s ideal solution is embedded in
the virtual world. The learner is only allowed to create objects that correspond to
the ones in the ideal solution. When the system was evaluated, the experienced
designers felt that the structure of the virtual world had restricted them [8]. On the
other hand, novices felt that they had increased their understanding of ER
modelling. However, these comments cannot be treated as a proof of the system’s
effectiveness since the system has not been evaluated properly.
ERM-VLE restricts the learner since he/she is forced to follow the identical
solution path to the ideal one. This method has a high tendency to encourage
shallow learning as users are prevented from making errors and they are not given
explanation about their mistakes. Moreover, a text-based virtual reality
environment is not a natural environment in which to construct ER models.
Students who learn to construct ER models using ERM-VLE would struggle to
become accustomed to modelling databases outside the virtual environment.
The other tutor for database modelling is COLER [5,6], a web-based
collaborative learning environment for ER modelling. Students initially solve
problems individually and then join a group to develop a group solution. The
designers argue that this process helps to ensure that students participate in
discussions and that they have the necessary raw material for negotiating
differences with other members of the group. The student’s individual solution is
constructed in the private workspace, whereas the collaborative solution is
created in the shared workspace. Students are provided with a chat window
through which they can communicate with each other. The private workspace
also allows the student to experiment with different solutions. Once a group of
students agree to be involved in collaboratively solving a problem, the shared
workspace is activated. Only a single member can edit the shared workspace at
any time. After each change in the shared workspace, the students are required to
express their opinions by voting, with either agree, disagree or not sure.The
personal coach resident in the interface gives advice in the chat area based on the
group dynamics: student participation and the group’s ER model construction.
COLER encourages and supervises collaboration, and we believe it has the
potential in helping students to acquire collaboration skills. However, it does not
evaluate the ER schemas produced, and cannot provide feedback regarding their
correctness. In this regard, even though the system is effective as a collaboration
tool, the system would not be an effective teaching system for a group of novices
with the same level of expertise. From the authors’ experience, it is very common
for a group of students to agree on the same flawed argument. Accordingly, it is
very likely that groups of students unsupervised by an expert may learn flawed
concepts of the domain. In order for COLER to be an effective teaching system,
an expert should be present during the collaboration stage.
3. KE
EE
ER
RR
RMIT: A Knowledge-based ER Modelling Tutor
KERMIT [12] is a problem-solving environment, in which students construct ER
schemas that satisfy a given set of requirements. The system provides feedback
tailored towards each student’s knowledge. The system supports the ER model as
defined in [7]. The architecture of the system is given in Figure 1. The main
components of KERMIT are its user interface, pedagogical module and student
modeller, discussed in this section. KERMIT contains a number of predefined
database problems and ideal solutions, specified by a human expert. Each
problem describes the requirements of a database that the student is to design.
The problem text is represented internally with embedded tags that specify the
mapping to the objects in the ideal solution. The tags are not visible to the student
since they are extracted before the problem is displayed.
Users interact with KERMIT’s interface to construct ER schemas for the
problems presented to them by the system. The pedagogical module drives the
whole system by selecting the instructional messages and problems that best suit
the particular student. The
student modeller evaluates the
student’s solution. In contrast
to typical ITSs, KERMIT does
not have a problem solver, as
developing a problem solver
for ER modelling is extremely
difficult. One of the major
obstacles that would have to
be overcome is natural
language processing (NLP), as
the problems in the domain are
presented using natural
language text. NLP would
have to be used to extract the
requirements of the database
from the problem text. However, the NLP problem is far from being solved.
Other complexities arise from the nature of the task. There are assumptions that
Constraint
Based
Modeller
Interface
Student
Pedagogical
Module
Solutions
MS
Visio
Models
Problems
Constraints
Student
Fig. 1. Architecture of K
ER
MIT
need to be made during the composition of an ER schema. These assumptions are
outside the problem description and are dependent on the semantics of the
problem itself. Although this obstacle can be avoided by explicitly specifying
these assumptions within the problem description, ascertaining these assumptions
is an essential part of the process of constructing a solution and would over
simplify the problems.
Although there is no problem solver, KERMIT is able to diagnose students’
solutions by using its domain knowledge represented as a set of constraints. The
system contains an ideal solution for each of its problems, which is compared
against the student’s solution according to the system’s knowledge base. The
knowledge base consists of constraints used for testing the student’s solution for
syntax errors and comparing it against the system’s ideal solution. KERMIT’s
knowledge base enables the system to identify student solutions that are identical
to the system’s ideal solution. More importantly, this knowledge also enables the
system to identify alternative correct solutions, i.e. solutions that are correct but
not identical to the system’s solution.
KERMIT’s knowledge base consists of 92 constraints. Each constraint consists
of a relevance condition, a satisfaction condition and feedback messages. The
feedback messages are used to compose hints that are presented to students when
the constraint is violated. The constraints can be roughly divided into syntactic
and semantic ones. The syntactic constraints describe the syntactically valid ER
schemas and are used to identify syntax errors in students’ solutions. These
constraints only deal with the student’s solution. They vary from simple
constraints such as “an entity name should be in upper case”, to more complex
constraints such as “the participation of a weak entity in the identifying
relationship should be total”.
Semantic constraints compare the student’s solution to the ideal one. These
constraints are usually more complex than syntactic constraints. For example.
constraint 67 deals with composite multivalued attributes. Since such attributes
can also be modelled as weak entities, the constraint has to compare a composite
multivalued attribute in the ideal solution to a similar one or a weak entity in the
student’s solution. This constraint illustrates the ability of the system to deal with
alternative correct student solutions that are different from the ideal solution
specified by a human expert. KERMIT knows about equivalent ways of solving
problems, and it is this feature of the knowledge base that gives KERMIT
considerable flexibility.
KERMIT maintains two kinds of student models: short-term and long-term
ones. Short-term models are generated by matching student solutions to
constraints and the ideal solutions. The student modeller iterates through each
constraint, checking whether the current problem state satisfies its relevance
condition. If that is the case, the satisfaction component of the constraint is also
verified against the current problem state. Violating the satisfaction condition of a
relevant constraint signals an error. The pedagogical module uses the short-term
student model to generate feedback to the student. On the other hand, the long-
term student model is implemented as an overlay model. It keeps a record of each
constraint’s history: how often the constraint was relevant, and how often it was
satisfied or violated. The pedagogical module uses these data to select new
problems.
3.1. Interface
Students interact with KERMIT via its user interface (Figure 2) to view problems,
construct ER diagrams, and view feedback. The top window displays the text of
the current problem. The middle window is the ER modelling workspace where
students create ER diagrams. The workspace was developed by integrating
Microsoft Visio [15] with KERMIT. Feedback is presented in the textual form in
the lowest window, and also verbally, through the animated pedagogical agent.
KERMIT’s interface reduces the burden on the student’s memory by showing
the text of the problem, and also by showing the available constructs. The student
can easily remind her/himself of the elements of the problem and the concepts of
the ER model. Furthermore, this interface reinforces ER modelling by requiring
the student to highlight the appropriate part of the problem text whenever a new
construct is added to the ER diagram. The highlighted words are coloured
depending on the type of object. When the student highlights a phrase as an entity
name, the highlighted text turns bold and blue. Similarly the highlighted text turns
green for relationships and pink for attributes. The feature is advantageous from a
pedagogical point of view, as the student must follow the problem text closely.
Many of the errors in students’ solutions occur because they have not
comprehensively read and understood the problem. These mistakes would be
minimised in KERMIT, as students are required to focus their attention on the
problem text every time they add a new object.
Besides being useful from the pedagogical point of view, highlighting is also
Fig. 2. User interface of KERMIT
