Towards a Pattern Language for Intelligent Teaching and Training Systems Andreas Harrer1 , Alke Martens2 1
University of Duisburg-Essen, Dep. of Computer Science and Interactive Systems 2 University of Rostock, Dep. of Computer Science and Electrical Engineering
[email protected]|
[email protected]
Abstract. Intelligent Tutoring Systems (ITSs) are usually based on similar fundamental structures. In contrast to this, software engineering techniques are seldomly used for realizing ITSs. In the last years, some approaches tried to change this: pattern mining took place; methods covering the specifics of ITS project development have been deployed. These approaches usually focus on a specific system type or on a certain application domain. What is missing is a combination of all the different approaches in a pattern language or a pattern catalogue for ITS. The purpose of such a pattern catalogue is to provide pattern for different types of software and to support the software development starting from design and ending with the implementation. The first step towards a pattern language is described in this paper.
1
Introduction
Intelligent Tutoring Systems (ITSs) can look back on a comparably long history and are usually based on similar fundamental structures, reflected in the ITS architecture. This architecture consists: expert module, learner module, user interface module, and steering/tutoring module (see e.g. [5], [27]). This architecture can be seen as a pattern in the broad sense [9]. In contrast to the quite homogeneous usage of terms, the realization of the modules and the interpretation of each module’s role and functionality in the ITS is heterogeneous [27]. In some ITSs, e.g. the realization of the expert knowledge module has moved from the integrated expert system to a system module, which resembles a multilayer database. Consequently, the execution layer (former part of the expert system) is then externalized and realized as an own module. The potentially stand-alone expert system and the expert knowledge database are both called expert knowledge modules. Thus, ITS development suffers from the negative effects of homogeneous naming for heterogeneous functionality. This results in hardly comparable ITSs. Re-use of existing systems or system components is in most cases not possible. In recent years, several approaches have been made towards establishing uniformity in the development of teaching and training systems. Two main directions of research are: the realization of standards, and the usage of software engineering methods. Standards can be used at different levels of teaching and training
system development. Examples are: standardized architectures like the LTSA (Learning Technology system architecture) (see http://www.edutool.com/ltsa), approaches for learning project management like ELM (Essen Learning Model) [34], and XML (EXtensible Markup Language) descriptions for teaching and training content like the Dublin Core Metadata (see http://dublincore.org). The main advantage of standards is the predefinition of terms, which is a step towards exchangeability. Main drawback is that the standard’s contribution remains on the level of terms. Standards lack a specific description of how to realize and implement the system parts. Using methods of software engineering in teaching and training systems is based upon the idea that software development is mainly an engineering science, not an art – although the latter perspective usually describes how software development is done in several different branches of computer science, and also in the area of ITS. To organize work according to the engineering perspective has some consequences: the development of software is based on techniques which are clear, definite, and traceable, and which explicate different aspects of the development process and of the result (i.e. the software). This paper describes a first step towards a pattern language for intelligent teaching and training systems. In the following section, related work is described. The subsequent section is used to suggest a terminology for describing a generative pattern language. A snapshot of a generative pattern language is given. Afterwards, two examples of ITS are given, which are developed based on software engineering approaches. The paper closes with a discussion.
2
Methods and Terminology
Currently, the situation in e-learning research and development is the following: systems for learning support that do not rely on methods of artificial intelligence, like Web-portals (e.g. Postnuke, http://www.post-nuke.net) and platforms for structured discussion forums (e.g. Future Learning Environment FLE3 [31]) are usually developed according to software engineering techniques (e.g. modularization, extensibility). Functional extensions by other developers can frequently be found (e.g. [35], [7]). By contrast, complex AI-based systems are usually not developed according to software engineering criteria. ITSs and AIED Systems (Artificial Intelligence for Education) are usually developed specifically for a certain application domain, and based on a cognitive or pedagogical theory. Details of architecture descriptions, explication of interfaces or background information about implementation details cannot be found in most cases. Most of the systems are not extensible and not re-usable. Utterances like ”AI kept fighting and losing against Software Engineering” [37] reveal a lot about the feeling of rivalry between these fields. From the engineering perspective, ITSs are complex software systems, which should be conceptualized and developed based on software engineering. Advantage of this perspective is a reduction of complexity in modules and components of the system. Based on a good design it should be easy to integrate applica-
tion domain experts. Usually experts of the application domain shouldn’t need to know implementation details but should have insight in the specific design of parts, like e.g. the expert knowledge module. An appropriate software design would separate between a application domain oriented specification (e.g. domain knowledge) and technical aspects of implementation. In software engineering there are several approaches which can support the development of teaching and training systems. – Reference architectures and architectural patterns are used to specify basic structure and relationships between the main components of a software system. Reference architectures are e.g. the LTSA, system oriented verbal descriptions [5], or student oriented descriptions [4]. Architectural patterns are on a more abstract level, e.g. [8] and the example of a realization [22]. – Design patterns are used to describe typical solutions for recurring design problems. They help to refine and complete system structures. [8] has introduced design patterns in ITS research. – Process patterns and Learning Design follow the idea to explicitly model process oriented aspects and to make them re-usable. In ITS, implicit principles (e.g. related to pedagogical principles) are transformed to explicit declarations. This supports and facilitates the work of domain experts; resulting concepts and designs can be re-used. Examples are an exchangable catalogue of tutoring rules [14], and sequencing of learning activities in the Learning Design [6]. – Ontologies, Component based design, Frameworks and Refactoring are futher software engineering methods relevant for ITS, which are not discussed here due to space limitations. To combine the obove mentioned software engineering concepts in a pattern language is a complex task. Thus, in the following, a stepwise approach is described. A necessary step towards designing and implementing systems and subsystems with a pattern oriented approach is to make the implicit relations between different patterns explicit. These are: – – – –
Patterns Patterns Patterns Patterns
can be used to realize patterns complement patterns can be used alternatively have similarities and differences
A collection of patterns which explicitly describes these relations is called a pattern language [38]. Pattern-oriented software development means to work stepwise: Based on the requirements of a system to develop, a certain entry point is selected, usually an architectural pattern. This first pattern provides a structure but no details. Thus, a refining pattern is used, which meets the requirements. Step by step, the system design will be refined by selecting subsequent patterns. This procedure continues until all requirements are met or if no refining patterns are available. For ITS currently only few approaches towards pattern language
development can be found: e.g. a pattern language for tutoring systems, based on the layer decomposition [8], and the blended learning process pattern [10]. Both are specialized on a certain ITS aspect.
3
Towards a Pattern Language for ITS
When developing a pattern language, the first step is to look for entry points. The basic pattern underlying most ITS is the ITS architecture (e.g. [5], [27], [28]). The elements of the architecture are described as models, modules or as components (see [28]). In the following the term module is used to name the parts of an ITS. A module is not necessarily a well defined and clearly structured model – the term module is used to characterize one entity of a complete system. Accordingly, an ITS consists of: expert module, learner module, user interface module, and process steering module. In figure 1 in part I, the aggregation without label is used – usually only one instance of each module exists. Each module can be concretised by a refining pattern (see figure 1, part II). The expert module can be realized e.g. as pedagogical agent, as case-based expert knowledge module, as expert knowledge model based on production rules. The learner module can e.g. be specialized as CSCL (Computer Supported Collaborative Learning) learner module [15], as cognitive tutor, which uses model tracing for evaluation of learner behavior [1], as the simple learner profile, which has no further information for correction or evaluation, as classical bug library [2], and as overlay module [13].
I
II Processsteeringmodule
Userinterfacemodule
ITS
Processsteeringmodule
Expertmodule
Userinterfacemodule
ITS
Pedag. Agent Expertmodule
Casebased Productionrules
Learnermodule
Learnermodule
CSCL Learnermodule
Cognitive Tutor Model Tracing
LearnerProfile
Buglibrary
Overlay Module
Fig. 1. Part I: Modules of an ITS, Entry point pattern. Part II: Extension of the Modules of an ITS
The specialization of the process steering module is closer to the implementation level (see figure 2 – everything except the grey parts). The specifica-
tion of the process itself, which differs dependent on the process description, is separated from the specification of the execution semantics, which should be the same for different processes. The engine part describes the semantics of the process steering module, i.e. how the steering process is realized and executed. Examples are: Learning Design (LD) Engines (for example Coppercore http://www.coppercore.org), an Intelligent Distributed Learning Environment (IDLE) Agent [15], or a Tutoring Process Model (TPM) interpreter [29]. The specification part is given by the (formal) process specification. Examples are: the LD-Documents [6] describing a learning scenario together with activities, services and learning resources, to be used in a LD-Engine; the behavior of the IDLE Agent according to the intended role of the agent in a learning community; a formally described Tutoring Process Model (TPM), which can be refined, e.g. as an adaptive TPM [29] or timed TPM [30]. On the next level of refinement (now including the grey parts in figure 2), gen-
LDEngine
LDDocument
IDLE Agent
Desc. of Behaviour Processsteeringcomponent
TPM Interpreter
Engine
General Software Pattern
Specification
timed TPM adaptiv. TPM
Processsteeringmodule
State
Chain of Possibility
Tutoring Process Modell (TPM)
Processdescription
Pedag. Agent
PAC Userinterfacemodule
Publish Subscribe MVC
ITS
Expertmodule
Productionrules
Learnermodule
Singleton
Casebased
Factory CSCL Learnermodule
Cognitive Tutor Model Tracing
LearnerProfile
Buglibrary
Overlay Module
Fig. 2. Separation of Engine and Specification and Extension by General Software Patterns
eral software patterns are integrated in the language. Figure 2 exemplarily shows some patterns, which can be used for the design of the user interface module: the Presentation Abstraction Control (PAC) pattern or the Model View Controller (MVC) pattern (both in [3]). PAC uses for example the pattern Chain of Responsibility [12] and the Publisher-Subscriber pattern [3]. The Publisher-
Subscriber pattern can also be used by the alternative MVC oriented implementation. MVC would use the Singleton and the Factory pattern (both in [12]). The Factory pattern also lends itself for the realization of the CSCL learner module. For the realization of the process steering component a State pattern [12] can be used to implement the state dependencies in the tutoring process execution in an elegant way.
4
Applications of the Pattern Language
To show the practical usefulness of our proposed pattern language two extended examples are given. The first one is an analytical usage of the pattern language to explore the structure of the medical ITS Docs ’n Drugs, while the other one is a pattern-oriented extension of a pre-existing system towards an ITS. Docs ’n Drugs - case- and web-based ITS for clinical medicine ”‘Docs ’n Drugs - the virtual hospital”’ is a web-based ITS for training of clinical medicine in a case-based way [22], [26]. The learner acts as physician who treats patients. His activities range from different anamneses, body examinations, over technical and laboratory examinations, to therapy. He has to decide about how to proceed in a given situation and he has to record and continually actualize a list of differential diagnoses. Since 2000 the system is part of the medical education at the University of Ulm, Germany (see http://www.docs-n-drugs.de). Docs ’n Drugs has been implemented based on the classical ITS architecture [29], see figure 1,I. The implementation of the system was based on the PAC pattern (Presentation-Abstraction-Control) [21]. PAC describes a system based on a set of interacting agents, each of which has presentation, abstraction and control parts. In Docs ’n Drugs, ten agents have been found and described: The expert module is realized consisting of two sub-modules: the medical knowledge agent for the expert knowledge module, the case-based knowledge agent for the pedagogical knowledge module. The learner module is part of the telecollaboration agent, which is also responsible for the telecollaboration between case authors. The process steering module is described by the tutoring process agent. The user interface module is part of the execution coordinator agent. Additionally, a repository access agent and an intelligent tutor agent have been identified. The first agent provides an interface between external repositories and system – this part would be an extension of the case-based realizaton of the Expertmodule in figure 2. The second agent is an additional feature of the system, comparable to a pedagogical agent for guiding and supporting the learner (see figure 2). Using the PAC pattern as basic description for ITS development had the advantage of a clear and explicite structure. Docs ’n Drugs had been a project of mid size, consisting of experts, e.g. artificial intelligence, media computer science, computer grafics, and several medical experts. Separating the system in several sub-parts which communicate via interfaces facilitates not only the system design, but also the interaction of the different experts. The approach showed one drawback: several levels of granularity regarding the module design have been mixed in one approach. For example, the tutoring process agent has a completely different functionality and structure than the medical knowledge agent. This has
led to the effect that most of the agents had to be refined in a complex way (see [21]). Moreover, the PAC based approach has been quite difficult to communicate to the non-computer scientists of the procject. A better structured approach, like the usage of a pattern language, would shift parts, which are in computer terminology, like e.g. agents, in the responsibility of computer scientists, whereas inter-project communication can take place at a level which is easier to grasp independent of the developer’s expertise. Cool Modes - towards an ITS for collaborative modelling Cool Modes [36] has been conceived as a collaborative synchronous application for graphical modelling in different domains, e.g. concept mapping, mathematical modelling, computational models like Petrinets and finite automata. The focus was on graphical representational issues and collaborative processes conducted by students in co-located classroom or distance scenarios. Tutoring functionality was not available. The user interface component of Cool Modes can be analyzed by using the suggested pattern language: The graphical model created by students is separated into visual representation (view), internal data model (model) and the components handling user input (control) – the Model-View-Controller architecture pattern. For the synchronisation of the students’ multiple instances of the application an event propagation mechanism (Java RMI) is used – an example for the Publisher-Subscriber design pattern. To guarantee controlled instantiation of graphical objects and uniqueness of a student’s identification, the Factory and Singleton design patterns have been used. After successful use of the application in teacher-supervised classroom scenarios [25], the support of remote and unsupervised scenarios became a topic of interest. Possible modes of desired support are the sequencing of specific collaborative and/or individual work phases and direct feedback with respect to the quality and completeness of the created models. The proposed pattern language has been used to extend the application towards an ITS for graphical modelling – e.g. by adding modules for student information, expert knowledge, and process regulation (see figure 1). These models are realized as follows: For the student model a logging mechanism [23] is used that captures all the raw information of the collaborative user actions, e.g. time stamp, user id, type of action, targeted object, and associated parameters. The student model has been realized as a combination of CSCL Learner module and Cognitive Tutor Model Tracing [18], two possible continuation patterns of the student module pattern. The expert module is case based, as teachers and/or experts of a specific graphical domain can specify relevant situations and configurations of graphical objects and their relations [19]. Cases are situations directly targeted at specific tasks/problems, but can be also more conceptual entities, e.g. conflicting argumentative structure, in a typed graphical discussion. In complex collaborative learning scenarios, students often need some scaffold, e.g. what to do in a specific phase, which tools to use, and which phases might follow each other. This is similar to pedagogical control in an ITS with interventions, yet more specifically tailored to the needs and specifities of collaborative learning. The IMS/LD specification [6] provides
a standardized vocabulary for the definition of (collaborative) learning processes and implementations. Based on the pattern language a process regulation module for Cool Modes has been conceptualized. The used refining pattern is LD engine and LD document in figure 2. The pattern approach has then been combined with a component based approach, using the existing Coppercore IMS/LD engine as a loosely coupled process regulation module (see [17]). The Cool Modes example shows that the pattern language is useful for analytical purposes as well as for the pattern oriented development and extension of ITS.
5
Discussion
The investigation of different teaching and training systems, e.g. ITS, AIED, and CSCL systems, has revealed that methods of software engineering are seldomly used. This can be the reason for the following three problems: 1. Re-usability of existing systems in different teaching and training domains and also re-usability of system components is in most cases not possible. 2. System requirements have to be communciated. Communication is difficult between different ITS research groups, and even more between different researchers, e.g. software developers, experts of the application domain, and pedagogical researchers. 3. Comparison of teaching and training systems often takes place by evaluation of the learner’s satisfaction and the learner’s success. Aspects like re-usability of components, performance, or way of implementation, all of which could be used to compare systems in the same application domain and based on similar didactical approaches, are not taken into account. Promising regarding all three mentioned problem areas is the idea to combine different software engineering approaches. Example architectures (e.g. reference architectures, architectural patterns, and frameworks), implementation oriented approaches from the field of software engineering (e.g. patterns, component based design, and refactoring), and formal tutoring process descriptions can be combined and related to each other. Together, all these different descriptions can constitute a pattern language. An approach following this direction is described in this paper. Starting with the classical ITS architecture as an entry pattern, examples of refining patterns are given for the expert module, learner module, and for the process steering module. By separating engine and specification part, the possibility to re-use the semantics of process execution arises. The combination of specific ITS patterns with general software patterns is given. Two examples for the practical application of this pattern based approach with ITS systems have been sketched. In Docs ’n Drugs a pattern based approach has been used for system design. In CoolModes a non-ITS system has been evolved towards an ITS based on the pattern language.
References 1. Anderson, J.R., Boyle, C.F., Corbett, A.T. and Lewis, M.W.: Cognitive Modeling and Intelligent Tutoring. Artificial Intelligence, 42, (1990) 17–49
2. Brown, J.S. and Burton, R.R.: Diagnostic Models for Procedural Bugs in Basic Mathematical Skills. Cognitive Sciences, 2, (1978) 155–192 3. Buschmann, F., Meunier, R., Rohnert, H., Sommerlad, P. and Stal, M.: A System of Patterns. John Wiley & Sons, Chichester, (1996) 4. Brusilovsky, P.: Intelligent Learning Environments for Programming: the Case for Integration and Adaptation. Proc. of AI-Ed, Washington, US, (1995) 1–7 5. Clancey, W. J.: Methodology for Building an Intelligent Tutoring System. In: Kintsch, W., Miller, J.R., and Polson, P.G. (eds.): Methods and Tactics in Cognitive Sciences, Lawrence Erlbaum Associates, Hillsdale, New Jersey, London, (1984) 51–84 6. IMS Global Learning Consortium. IMS Learning Design Information Model. Report No. 1.0, (2003) 7. Dolonen, J., Chen, W. and Morch, A.: Integrating Software Agents with FLE3. In: Wasson, B., Ludvigsen, S. and Hoppe, U. (eds): Proc. of CSCL 2003, Kluwer Academic Publishers, (2003) 157–161 8. Devedzic, V.: A Pattern Language for Architectures of Intelligent Tutors. In: Moore, J.D., Redfield, C. and Johnson, W.L. (eds): Proc. of AI-Ed, San Antonio, TX, US, (2001) 542–544 9. Devedzic, V. and Harrer, A.: Architecural Patterns in Pedagogical Agents. In: Cerri, S., Gouard´eres, G. and Paragua¸cu, F. (eds): Proc. of ITS, LNCS 2363, (2002) 81–90 10. Derntl, M. and Motschnig-Pitrik, R.: Patterns for blended, Person-Centered learning: Strategy, Concepts, Experiences, and Evaluation. In: Proc. of the 2004 ACM symposium on Applied Computing, ACM Press, Nicosia, Cyprius, (2004) 916–923 11. Fowler, M., Beck, K., Brant, J., Opdyke, W. and Roberts, D.: Refactoring: Improving the Design of Existing Code, Addison-Wesley, (1999) 12. Gamma, E., Helm, R., Johnson, R. and Vlissides, J.: Design Patterns: Elements of Reusable Object-Oriented Software, Addison-Wesley, Reading, MA, (1995) 13. Goldstein, I.P.: Overlays: A Theorie of Modeling for Computer Aided Instruction. Report AI Memo 406, MIT, Cambridge, (1970) 14. Harrer, A.: Both Sides of the Coin - Blending Cognitive and Motivational Aspects into a Tutoring Strategy. In: Ottmann, T., Halim, Z. and Razak, Z. (eds): Proc. of ICCE, Kuching, Malaysia, (1997) 188–195 15. Harrer, A.: Unterst¨ utzung von Lerngemeinschaften in verteilten intelligenten Lehrsystemen. PhD thesis, University of Munich, Germany, (2000) 16. Harrer, A.: Software Engineering Methods for re–use of Components and Design in Educational Systems. International Journal of Computers & Applications, Special Issue on Intelligence and Technology in Educational Applications, Anaheim, CA, 25, 1, (2003) 17. Harrer, A., Malzahn, N., Hoeksema, K. and Hoppe, U.: Learning design engines as remote control to learning support environments. Journal of Interactive Media in Education, Special Issue on Advances in Learning Design, (2005) (http://jime.open.ac.uk/2005/05) 18. Harrer, A., McLaren, B., Walker, E., Bollen, L.B. and Sewell, J.: Collaboration and cognitive tutoring: Integration, empirical results, and future directions. In Proc. of AI-Ed, IOS Press, Amsterdam, (2005) 266 – 273 19. Herrmann, K., Hoppe, U. and Pinkwart, N.: A checking mechanism for visual language environments. In Proc. of AI-Ed, IOS Press, Amsterdam, (2003), 97–104 20. Ikeda, M. and Mizoguchi, R.: FITS, A Framework for ITS – A computational model of tutoring. Journal of Artificial Intelligence in Education, 5, 3, (1994) 319–348
21. Illmann, T., Weber, M., Martens, A. and Seitz, A.: A Pattern-Oriented Design of a Web-Based and Case-Oriented Multimedia Training System in Medicine. 4th World Conference on Integrated Design and Process Technology, Dallas, US (2000) 22. Illmann, T., Martens, A., Seitz, A. and Weber, M.: Structure of Training Cases in Web-based Case-oriented Training Systems. Proc. of Advanced Learning Technologies, ICALT, (2001) 23. Jansen, M.: Matchmaker - a framework to support collaborative java applications. In Proc. of AI-Ed, IOS Press, Amsterdam, (2003) 529–530 24. Johnson, W.L., Rickel, J. and Lester, J.: Animated Pedagogical Agents: Faceto-Face Interaction in Interactive Learning Environments. International Journal of Artificial Intelligence in Education, 11, (2000) 25. Lingnau, A., Kuhn, M., Harrer, A., Hofmann, D., Fendrich, M., Hoppe, U.: Enriching traditional classroom scenarios by seamless integration of interactive media. In Proc. of Advanced Learning Technologies, Los Alamitos, CA, (2003) 135–139 26. Martens, A., Bernauer, J., Illmann, T., Seitz, A.: Docs ’n Drugs - The Virtual Polyclinic. In: Proc. of the American Medical Informatics Conference AMIA, Washington, USA, (2001) 27. Martens, A.: Centralize the Tutoring Process in Intelligent Tutoring Systems. In: Proc. of the 5th Internat. Conf. New Educational Environments ICNEE, Lucerne, Switzerland, (2003) 28. Martens, A.: Ein Tutoring Prozess Modell f¨ ur fallbasierte Intelligente Tutoring Systeme. AKA Verlag infix, DISKI 281, (2004) 29. Martens, A.: Modeling of Adaptive Tutoring Processes. In: Zongmin, M. (ed): WebBased Intelligent e-Learning Systems: Technologies and Applications, Information Science Publishing, Idea Group Inc., Hershey, London, (2005) 193–215 30. Martens, A.: Time in the Adaptive Tutoring Process Model. Submitted to: Intelligent Tutoring Systems ITS Conference, Taiwan, (2006) 31. Muukkonen, H., Hakkarainen, K. and Lakkala, M.: Collaborative Technology for Facilitating Progressive Inquiry: Future Learning Environment Tools. In: Hoadly, C. and Roschelle, J. (eds): Proc. of CSCL, Stanford University, (1999) 32. Mizoguchi, R., Ikeda, M. and Sinitsa, K.: Roles of Shared Ontology in AI–ED Research. In: du Boulay, B. and Mizoguchi, R. (eds): Proc. of AI-Ed, Kobe, (1997). 33. M¨ uhlenbrock, M., Tewissen, F. and Hoppe, H.U.: A Framework System for Intelligent Support in Open Distributed Learning Environments. Journal of Artificial Intelligence in Education, 9, (1998) 256–274 34. Pawlowski, J.M.: The Essen Learning Model - a Multi-Level Development Model. In: Proc. of the Int. Conf. on Educational Multimedia, Hypermedia & Telecommunications ED-MEDIA, Montreal, Quebec, Canada, (2000) 35. Pinkwart, N., Harrer, A., Lohmann, S. and Vetter, S.: Integrating Portal Based Support Tools to Foster Learning Communities in University Courses. In: Uskov, V. (ed): Proc. of Web-Based Education WBE, ACTA Press, Anaheim, CA, (2005) 201–206 36. Pinkwart, N.: Collaborative Modeling in Graph Based Environments. PhD thesis, Gerhard-Mercator-Universit¨ at Duisburg (2005) 37. Rohmer, J.: Yesterday, Today, and Tomorrow of AI Applications. Invited Talk, IFIP World Congress, (2004) 38. Schmidt, D., Stal, M., Rohnert, H. and Buschmann, F.: Pattern–oriented Software Architecture – Patterns for Concurrent and Networked Objects. John Wiley & Sons, Chichester, (2000)
