Abstract: This study present an authoring groupware for the cooperative development of hypermedia intelligent tutoring systems (ITS). The authoring system allows several authors geographically dispersed to collaborate to produce such tutors. It consists of a shared workspace gathering all tools necessary to the cooperative development task. After describing the structure of the generated ITS, the client-server architecture of the authoring tool and the mechanism needed to manage the notification and group awareness is outlined.
INTRODUCTION
The Intelligent Tutoring Systems (Wenger, 1987) development remains a difficult task to nndertake, despite all the efforts carried out during the last few years. This interdisciplinary task often requires the cooperation between experts from different fields such as education, psychology and computer science engineering to design such systems. In order to improve the productivity in this domain and allow a wider commmrity to be involved, authoring systems have appeared and some of them allow tbe users to develop Intelligent Tutoring System (ITS), sometimes, without writing a single line of code. Thus, the task is reduced in a way that the experts need only to introduce knowledge to generic ITS predetermined by the system. Some of these authoring systems are discussed in (Murray, 1999), however, tbey were all designed to work in a single-user mode.
Recently, thanks to the networks and groupware, virtual meetings involving many people are made possible (Attaran andAttaran, 2002; Mills, 2003), Several works in this area are already available in such domains as the cooperative writing (Decouchant and Martinez, 2000; Zidani eta/., 2000; Pacull et a/., 1994), tbe multimedia, tbe cooperative design of objects, etc. The common point between all these systems is that they allow several participants to work together in synchronous or asynchronous mmer to realize a common task.
Since the cooperative aspect, through a computer network, has been experimented successfully in a lot of domains, this leads us to think that it would be desirable that the designers of future authoring tools should integrate this cooperation fnnctionality for ITSs production.
The present study investigated the idea through an authoring system called CAMITS (Cooperative Authoring Model for Intelligent Tutoring Systems).
ITS AUTHORING SYSTEMS
Single-user authoring systems: During this last decade, several works has been taken on the design and implementation of ITS authoring systems. Besides our experience witb MOALIM system (Talhi et a/,, 1996; Harous eta/,, 2004), Tom Murray (Murray, 1999) listed more than twenty references in his recent paper and presented his authoring system named Eon (Mmay, 1998). These systems are classified in seven categories according to the type of ITSs they produce. These categories are: l.cmiculurn sequencing and planning, 2.tutoring strategies, 3.device simulation and equipment training, 4.domain expert system, 5.multiple knowledge types, 6.special purpose and 7 ,intelligent/adaptive hypermedia.
Given that ITSs are often described as having four main components (domain module, tutoring module, student model and student interface), the authoring systems must therefore theoretically include all the necessary tools for building these components. However, it has to be recognized that, very few systems require from the author to construct every thing needed, as in the case of Eon system (Murray, 1998) for example, The otber systems are usually limited to tools for constructing one, two or at limit three components among the four. The remaining components are generally predefined in an ITS pattern and the author is solicited only to introduce necessary parameters for their fnnctioning.
CAMITS, the system presented in this paper, offers cooperative frmctionalities to the authors and generates ITSs classified as first and seventh category of the Murray classification mentioned above. These authoring system types, structure generally the teaching material as a network of Learning Units (Lus) where every LU satisfied some educational objectives.
The LUs are linked together to show prerequisite- relations between them. Although these systems do not use any explicit representation of domain knowledge, they investigated nevertheless the intelligence at the sequencing process of the LUs, the manipulation of the hypertext links and the adaptation of the course according to a student level of knowledge (Janicki and Liegle. 2001; Nkambou et al., 2003). The LUs to be presented to the learner are then determined dynamically based on the learner performance, the lesson learning objectives and the relations that exist between the different LUs.
The CAMITS system is among the systems that, in order to facilitate the authors' task, requires only instantiation of the LUs. He next will have only to introduce the prerequisite network and the necessary parameters for the frmctioning of the three other components.
Authoring groupware design approach: Several approaches can be proposed to develop a cooperative authoring system. We can classify them in two large categories (Talhi et al., 2001 ). A first approach, pragmatic and more economic in implementation effort, consists to take an existing single-user authoring system and enrich it with other frmctionalities that makes it cooperative one. However, the rigidity induced by knowledge acquisition rmits of the single-user authoring systems, makes it very difficult to take into a cormt group awareness control and the distributed management of the knowledge base. The produced authoring tools will lack certainly effectiveness and will use cooperation mechanisms only at a limited degree.
The second method, which we adopted in the design of CAMITS, consists in taking into a cormt the paradigm of cooperation and the needed tools to do it, at the design step of the system architecture. This approach, although expensive, allows us to apply rigorously the mechanisms of the cooperation metaphor.
Though, we must provide through this software architecture, a common work-space to the authors involved in the cooperative construction of an ITS.
However, we should notice that the software component does not constitute the only parameter in the success of such cooperative system. Also, we must have to take into accormt the human factors involved due to the group activities because of their importance (Greenberg and Roseman, 1999). Thus. to avoid the inherent conflicts due to the human nature, we propose a group organization that allows an optimal way the construction of the ITS.
This organization facilitates also the manipulation of different components of the ITS during all steps of the project advancement. So, we define three roles through which the authors can participate during the ITS development process: main author, constructor coauthor and commentator coauthor.
| • | The role of the main author is to coordinate the whole work and to verify that the calendar is well respected. He defines the ITS logical structure to be produced, by decomposing it in several components (parts, chapters, LU, figures, images, etc.) and then assigns the roles to different co-authors. He has free access to all ITS components. |
| • | A constructor coauthor is authorized to create, modify or delete only the components assigned to him. On the remaining ITS components he will have only the role of commentator. |
| • | A commentator coauthor is authorized only to read and/or comment the components assigned to him. |
HYPERMEDIA ITS MODEL
The learning envirornnent consists of two learning modes offered to the learner: exploration mode (free exploration) and training mode (learning with self- evaluation) and it organizes the teaching process arormd hypermedia components (Talhi et al., 2005).
The teaching material is structured in three abstraction level hierarchy according to three level hierarchy of pedagogical objectives defined in (Hameline. 1990): parts (satisfYing the general objectives). chapters (satisfying the specific objectives) and the Hypermedia Learning Units (HLU) (satisfying the operational objectives). To intelligently sequencing the curriculum and adapt it to each learner capacities, the management of these components, is ensured by a multi- expert system based on a five sets of production rules.
These rules (for which parameters can be set), called main rules (MRules), describe the different tutoring plans depending on the different learning situations.
They constitute therefore a generic knowledge base that is instantiated in a suitable way for each ITS created byCAMITS.
The instantiation process, producing generated rules (GRules), is carrying out automatically by the system, based on parameters delivered by authors. These ITS parameters which are represented in predicates form, describe the quantitative aspect of the teaching material (number of parts, number of chapters, number of learning rmits, number of questions, number of exercises, etc.).
For the goal of reusability and independence from the domains, the MRules invoke abstracted structures called HLU. These HLUs have no knowledge about the ITS domain. They are supposed to receive all kind of knowledge about the domain via instantiation, rmder all media types that are allowed by the HTML language (text. image, smmd, video, applet).
To summarize, we can consider, two levels of knowledge in the curriculum definition:
| • | A higher level corresponding to the tutoring plans: These plans consist of five sets of rules that invoke HLU of the lower level. Every set of rules has a specific fnnction. These frmctions are the following: negotiation with the learner for the entry point in the course (where to start) and/or the objectives to reach; deduction of HLUs assumed to be rmderstood after a negotiation phase; planning the learning sesswn; searching and filtering the content of HLU; and auto-evaluation. |
| • | A lower level corresponding to the HLU rmiverse: This rmiverse consists of a hierarchical network constituted of six HLU sub-levels where the first four sub-levels correspond to the course type HLU (module abstract. part abstract, chapter abstract. HLU classes) and the last two sub-levels correspond to evaluation type HLU (questions and exercises). |
ITS architecture: The architecture of the generated ITS is similar to that of a traditional tutoring system (Wenger. 1987), It is composed of:
1. An “exploration module” that allows the learner to navigate freely through the different HLUs.
2. Three modules implementing the training mode:
| • | A “domain-expert module” using generated rules to search and filter concept-indexed HLU asked at a given moment. |
| • | A “pedagogical module” that allows the negotiation of learning session objectives with the learner and generates in turn sequencing plan for the adaptive presentation of the lesson. Two sub-modules realize these two tasks: the “negotiator” using the negotiation generated rules and the “planer” using the planning generated rules. |
| • | A “diagnosis module” that allows the learner evaluation and the maintenance of an overlay type learner model. This module is made up of three sub-modules: an “evaluator” usmg evaluation generated rules; a “deduction agent” using the deduction generated rules and a “learner model manager” managing its persistent content. |
3. A “supervisor module” that allows on one side, the commrmication with the learner and on another side, the coordination between the three modules: domain-expert module, pedagogical module and diagnosis-module. This coordination is carried out via message sending.
The difference between our ITS and a classical ITS is the fact that our ITS resides on the server and can therefore be accessed distantly by learners. Its implementation in Php/MySql has certainly helped in spreading its use as a distance learner system.
ITS AUTHORING GROUPWARE
To be efficient, collaboration requires not only a shared space, but also some support. The shared space must be structured, each user must be aware of the activity of others, some direct commmrication between people should be provided to allow them to discuss their common task and coordination means should be provided.
In authoring mode, we have proposed some necessary tools for ITS cooperative authoring. From an author point of view, designing an ITS using CAMITS consists in introducing, via a cooperative editor, a set of objects that will be manipulated in the learner mode.
These objects are made up with teaching material in the form of hypermedia learning units (HLU), prerequisite- network in the form of an oriented graph, ITS parameters in the predicates form and pedagogical knowledge in the form of production rules.
The cooperation task in CAMITS is introduced at the editing level of the teaching material and at the editing level of the prerequisite-network. These two components are well structured: the teaching material is organized as parts, chapters and HLU and the prerequisite-network is organized as sub-networks form (part-prerequisite network, chapter-prerequisite network, HLU-prerequisite- network and concept-prerequisite network).
These structures are well convenient for the fragmentation and then constitute the basis of our cooperative editing approach as in Alliance (Decouchant and Martinez, 2000). The two concept-keys on which is based the design ofCAMITS are the “fragmentation” and “edition roles” (Decouchant et al, 1999). As previously said, we defined three edition roles of participation for the authors: main author, constructor coauthor and commentator coauthor.
At the beginning of the ITS construction task, a negotiation step is necessary. The main author assigned the edition roles to different co-authors around different competences and availability. Five learning principles has been incorporated into the authoring process (Janicki and Liegle, 2001). These principles are: a clear definition of pedagogical objectives, definition of pre-requisite knowledge, fragments of ITS structure in accordance with their providing a variety of presentation styles (tell, show and do), enhanced feedback and testing and finally, permitting the learner to control the direction of the learning session by choosing himself the pedagogical objectives.
Adopted cooperation modes: The cooperative building process of ITS is characterized by a steps-sequence during which the authors can works either individually or collectively. In JamEdit (Zidani et al., 2000), we defined four cooperation modes, we believe that they to be also necessary in CAMITS: individual responsibility, dynamic exchange, alternate version and collective responsibility.
The first three modes are typically asynchronous cooperation modes. Especially, the third one is inspired from the real principle “let us reflect separately on the question and then compare our results after”.
The fourth one is a typically synchronous mode that allow, to relatively reduced number of authors chosen by main author, to finalize the ITS version when the project reaches its final phase.
Software architecture: The cooperative editor is organized according to centralized client/server architecture (Orfali et al., 1997). Then, all the communications pass automatically through the central site (the server). To every client- site, we associate a client process (CPR) that accomplishes all the tasks that are processed locally (the editing tasks for example). We define a server process (SPR) that manages all the communications between the different CPRs and keeps up to date the content of the ITS central copy and the ITS 1ogical structure.
The software architecture offers several functionalities that we can decompose in three layers: server layer, editor layer and presentation layer. Every layer is structured as a collection of modules where each module consists of several objects implementing some functionalities (Fig. 1).
| Fig. 1: | Software architecture of CAMITS |
The need for information exchange between the two client layers on one side and between the client and the server on the other side, implies the presence for "dialog controllers". We interpose therefore between every presentation layer and every editor layer a Dialog Controller (DC) and between the server layer and every editor layer a Main Dialog Controller (MDC).
Messages exchanged betweenlayers transits automatically by the dialog controllers. According to message-type, the convenient objects are then chosen among those that are defined in a layer.
Server layer:This software layer gathers several types of functionalities, among which those that concern ITS logical structure management, as well as the content of ITS components. They allow the authors to save and retrieve ITS objects whose logical structure is declared, as well, at the central level as at the local level.
This software layer is responsible for access rights control, events handling and events notification. In the case of events notification, for example, the concerned module manages a set of queues such as engagement queue, locking-queue, etc. At every time, if an event occurs, this process identifies the concerned authors and proceeds to structure the notifications as a message form to transmit. These messages then will be made available to another sender module that sends the message.
Editor layer: This software layer gathers many types of frmctionalities allowing every author to manipulate the objects that constitutes the ITS. These frmctionalities include not only the support of individual actions, but also the sharing aspect and transparency management. For example, the access to a file in a single user editor delivers directly its content. But in our case, this process consists in several tasks such as access rights verification, locking state of the object and warning the authors working on this file in the same time.
At each author site, some associated frmctionalities allow the author to save locally the objects that are accessible to him. He will solicit regularly the server to update the versions of these objects. The different components of the editor layer are:
HLU/prerequisite-network-Editor: Two modules are designed to implement this component software. They allow the creation task and the maintenance of different ITS objects. The first module allows the wisiwig HLU edition using HTML language. The second module allows the author to edit the prerequisite-network in a graphical form. This oriented network is made up of linked nodes where the links indicates the different possible progressions between the teaching material components. Four levels are used in the network. One level shows the concept-prerequisites, the second shows parts- prerequisites, the third one shows the chapter- prerequisites of a particular part and the fourth level shows the HLU-prerequisites of a chapter.
Parameters acquisition module: This module allows the main author to specify the ITS parameters that indicate the manner in which the teaching material is decomposed (number of parts, number of chapters in every part, number of HLU in every chapter, etc.). These parameters are saved in the predicates form and then used to instantiate the main rules. For example the predicate nbhlu(l.2.4) indicates that chapter 2 in part I contains 4HLUs.
GRules generator module: This module allows the author to generate the five packages of generated rules that represent different tutoring plans. Based on the ITS parameters introduced via the previous module, this generation consists of an instantiation of the five packages of the MRules.
Verification module: As most authoring systems, CAMITS offers a tool to help the author in the diagnosis of errors and bugs. It facilitates detection of incoherencies that can be occurred during the ITS construction. For example, at the end of the construction process of the ITS, it is necessary to check the compatibility of ITS parameters with the effective structure of the teaching material.
Presentation layer: This layer gathers an organized set of interactive objects defining the graphical user interface (buttons, icons, cursor, scrolling bar, task-progression bar, pull-down menus, etc.). Thus, for every object, modeling a part of our application domain, we associate a presentation technique accomplished by a reactive object that reacts to the different authoring actions.
Besides the pull-down menus achieving the different frmctions, we especially find a toolbox containing graphical icons that refer to the frequently used frmctions and specialized widget-based palette allowing the graphical construction of the prerequisite-networks.
Dialogue controllers DC and MDC: Each dialog controller is composed of three independent modules performing respectively, message reception, message control and message sending (Fig. 2).
The Control module allows the coordination and synchronization of the nmning of the different modules within the three layers, in accordance with the actions of the different authors. At any time, it used all necessary information to determine exactly what are the frmctionalities to invoke within the layers for which it is responsible.
Every time that an event occurs, the associated receiver delivers the message materializing this event to the control module. The control module reacts then following three steps: analyze the event, draw up an action plan and then carry out the established plan.
| Fig. 2: | Dialog controllers architecture |
| Table 1: | Factors and authors questions |
Notification and group awareness: The notification and group awareness frmctions constitute an important point in the cooperative application design (Muhammad, 2005). It includes all the interface frmctions and all systems frmctions that allow the users to perceive the activities of the other users, as well as to control and to act on the distributed environment.
To develop the appropriate computer support, we recognized the principal factors concerned by the transparency within the workspace. The Table 1 summarizes the considered elements as well as the questions that the author might ask (Zidani et AL.,2000).
In CAMITS, we use a notification mechanism that broadcast to the authors all different events that are occurred within the distributed workspace.
During the cooperation process, the participants will know “who is doing what, where and when?”. That’s how CAMITS can provide to every participant information concemmg his colleagues (role, identity, etc.), interactions state within the workspace (cment activities, manipulated objects, realized modifications, etc.) and also the handling states of every object of the ITS (locked. free, authors handling it, locking time, etc.).
The event management process is the responsibility of the server. Since the server holds a reference copy, the notification events, linked to the different ITS fragments, is thus facilitated. Every author can request the server to inform him every time that an event is occmed within the shared space. For example, it can establish an engagement in order to receive the modifications made to a specific fragment of the ITS, which then will be automatically delivered to him.
DISCUSSION
The presented study is related to the design of an architecture of an ITS cooperative authoring system called CAMITS. Integrating cooperation paradigm in ITS authoring systems is the original idea of this paper. This authoring groupware allows geographically distant authors to collaborate to produce a tutoring system according to a predefined ITS pattern.
The ITS pattern is implemented in PHP/MySQL and resides on a server; it can therefore be accessed simultaneously by different distant learners.
The authoring mode software, implemented in Java Server Pages and Java language, is organized as centralized client-server architecture. It makes it possible to several authors to be connected to a working session characterized by a cooperative space and a control strategy.
The cooperation space is represented by a set of structured components (HLU, prerequisite-networks, tutoring parameters and tutoring rules) and tools, which make it possible the edition and commmrication tasks. Fig. 3. shows an example of a window-space where developing a Data Bases tutorial.
The control strategy manages the negotiation of the access right to a component of the ITS and then participation of users during the work session.
The authors are oriented to incorporate five learning principles into the authoring process of the tutorial: a clear definition of pedagogical objectives, definition of pre-requisite knowledge, providing a variety of presentation styles (tell, show and do), enhanced feedback and testing and permitting the learner to choose himself the pedagogical objectives of the learning sesswn.
Two different approaches were used to test the validity that the system actually incorporated pedagogy and effective cooperative design concepts as part of the developmental process.
To evaluate the system a group of four teachers were surveyed to seek their opinion if the authoring system did incorporate the five learning principles into its design. Their survey results validated that the system would prompt developers to build an ITS based on pedagogy. In addition a high agreement was noted in the self-direction of the lesson offered to the learner.
In a second means to validate the system, five teachers geographically dispersed were invited to develop a data base tutorial, via local network and were surveyed to seek their opinion if the authoring system offers all cooperative tools necessary to construct the tutorial in a synchronized mmer.
We were also interested in the group interaction through accormting of various exchanges operated between the authors during a work session. Especially, we record the aspects related to notification and group awareness.
Although the system does exhibit positive results after a pilot test in the local network context, a question for future research is the experimentation of the system in the internet/web context. This research would provide evidence that the concepts incorporated into the system do impact learning in a positive manner.
| Fig. 3: | Developing a data bases tutorial |
On the positive side the survey results from the two different experimentations provides indication that the system is a positive benefit to teachers and developers of web-based intelligent tutoring systems.