Designing a Reusable and Adaptive E-Learning System

A Thesis Submitted to the College of Graduate Studies and Research in Partial Fulfillment of the Requirements for the Degree of Master of Science in the Department of Computer Science University of Saskatchewan Saskatoon

By Honggang Wu November, 2002

Copyright Honggang Wu, 2002. All rights reserved.

Abstract
The Internet has shown its advantage in e-Learning, a new approach to online education. It enables online learning materials to be reused by any educational organization around the world, when there is an efficient way to find the appropriate learning materials on the Internet and combine them together. The new concept of e-Learning is that by organizing and disseminating the learning content into a uniform format as small chunks of learning materials, it is possible to achieve content reuse and interoperation between different educational institutions and training vendors. This thesis addresses the possibility of developing learning content based on learning objects, and evaluates the role played by XML in designing an e-Learning system. The main goal of this research is to design a reusable and adaptive e-Learning system with XML schemas forming the basic framework. To implement this goal, the concept of a learning object is redefined, and a schema for learning objects is developed. Some modifications to the existing e-Learning specifications, such as the metadata specification, the content packaging specification, and the learner information specification, are introduced to make them more suitable for our e-Learning systems. In this thesis, four online tutorial courses are developed to illustrate how these schemas can work together to make it possible to reuse learning objects in different learning contexts and to provide learners with individually tailored learning content.

Table of Contents
1 Introduction 2 Background 2.1 E-Learning, a New Way of Learning 2.1.1 The Features of E-Learning 2.1.2 A New Approach to E-Learning Content Development 2.2 Learning Objects 2.2.1 Background Literature on Learning Objects 2.2.2 Reusability of Learning Objects 2.2.3 Problems with Learning Objects 2.3 E-Learning and XML 2.3.1 XML Schema and its Benefits for Interoperability and Reusability of Information 2.3.2 XSL, XSLT, and Xpath for Flexible Information Presentation 2.3.3 XML DOM and Java API 2.3.4 Conclusion about Using XML 2.4 E-Learning Standards 2.4.1 Standards Initiatives For E-Learning 2.4.2 Specification for Metadata 2.4.3 Specification for Content Packaging or Course Structure Format 2.4.4 Specifications for Question & Test Interoperability Specification 2.5 Summary 3 Schema Design 3.1 Schema for Learning Objects 3.1.1 New Definition of Learning Objects 3.1.2 The Design of a Schema for a Learning Object 3.2 Schema for Metadata 3.2.1 The Design of Schema 3.2.1 Controlled Vocabulary 3.3 Schema for Content Packaging 3.4 Schema for Learner Information 4 System Design 4.1 Architecture of the E-Learning System 4.2 Learning Content Development 4.2.1 Idea and Principles behind Learning Content Development 4.2.2 Developing Learning Content 4.3 Design of the Learning Management System 4.3.1 Learning Management System 4.3.2 Design of the LMS 4.3.2.1 Learning Management Module 4.3.2.2 Sequencing/Tracking Module 1 4 4 5 7 8 8 10 11 13 14 17 18 18 19 20 23 25 27 27 28 30 30 34 38 38 41 42 46 49 49 52 52 54 64 64 65 66 67

4.3.2.3 Testing/Assessment Module 4.3.2.4 Search Module 4.3.2.5 Learner Profile Module 4.3.2.6 Delivery Module 4.4 Summary 5 Implementation of the E-Learning System 5.1 Learning Content Implementation Details 5.2 Implementation of the Learning Management System 5.2.1 Environment of the Learning Management System 5.2.2 The Basic Components of the Learning Management System 5.2.3 Implementation of the Modules 5.2.3.1 Implementation of the Learning Management Module 5.2.3.2 Implementation of the Delivery Module 5.2.3.3 Implementation of the Tracking/Sequencing Module 5.2.3.4 Implementation of the Assessment/Testing Module 5.2.3.5 Implementation of the Learner Profile Module 5.2.3.6 Implementation of the Searching Module 5.3 System Testing 5.4 Conclusion 6 Conclusions

68 68 68 69 69 70 70 75 75 76 77 77 78 79 82 83 84 85 88 89

6.1 Summary of Thesis Work 89 6.2 Research Contributions 90 6.3 Future Work 92 6.3.1 Improving Search Functionality 92 6.3.2 Generating Learning Objects from Databases or HTML files 93 6.3.3 Displaying Learning Objects with Different Formats 93 6.3.4 Expanding Content Packaging Schema and Learner Information Schema 94 6.3.5 Developing Tools for Authoring Learning Objects and Content Packaging Files 94 6.4 Conclusion 94 References Appendix A- Schema for Learning Objects Appendix B- Schema for Content Packaging Appendix C- Schema for Metadata Appendix D- Schema for Learner Information 95 101 110 118 121

Figures
Figure 2.1 Content Packaging Figure 3.1: Structure of <learningObject> Element Figure 3.2: Structure of <Description> Element Figure 3.3 Importation of QTILite Schema Figure 3.4 Structure of Metadata Figure 3.5 Structure of Content Packaging Figure 3.6 Sample Course Structure Figure 3.7: Structure of <organization> Element Figure 3.8 Structure of <condition> Element Figure 3.7: Structure of Learning Information Figure 4.1 Architecture of the E-Learning System Figure 4.2 Course Structure for Encryption Tutorial Figure 4.3 Sample <organization> Element Figure 4.4 Sample <resources> Element Figure 4.5 Prerequisite for a Quiz Figure 4.6 Difficulty Range for Learning Content Figure 4.7 Learning Object RSA.xml Figure 4.8 Learning Object RSA1.xml Figure 4.9 Sample Metadata Figure 4.10 LMS Modules Figure 5.1 Course Structure for Encryption Figure 5.2 Course Structure for Firewall Figure 5.3 Course Structure for Network Security Figure 5.4 Course Structure for E-Commerce Figure 5.5 Sample Learner Profile Information Figure 5.6 XSL File for Learning Objects Figure5.7 System Interface Figure 5.8 Learning Content Figure 5.9 Quiz Figure 5.10 Records of Learning Activity Figure 5.11 Changing Learner Information Figure 5.12 Searching Results Figure 5.13 Record of Learning Paths for the Encryption Tutorial 26 34 36 37 39 43 44 45 46 47 50 51 57 58 59 59 61 62 63 65 71 72 73 74 75 79 80 81 82 83 84 85 87

Chapter 1

Introduction
As more and more individuals are connected to the Internet, it will penetrate deeper into our everyday activities, including the way we learn. E-Learning, or Web-based learning is becoming a new research area in which the web and learning converge on all levels, whether in elementary school, college, or business. The rapid development of e-Learning is based on the astounding growth of the Internet and the emergence of new advanced technologies. For the first time in history people may have access to all kinds of learning materials 24 hours a day, seven days a week, at any possible location around the world. The Internet also shows its advantage in course development. For example, if some educational content, such as a description of computer hardware, is available online, then it is available worldwide. It could be accessed by each of the thousands of educational organizations teaching the same topic. Therefore, online learning materials may be easily reused by many organizations, if there is an efficient way to find the appropriate learning materials on the Internet and join them together. This is the reason why the new concept, learning object, has been proposed. The core idea here is that by organizing and disseminating the learning content into a uniform format as small chunks of learning materials that are referred to as learning objects, it is possible to achieve content reuse and interoperation between different educational institutions and training vendors. In order for different systems to communicate and interoperate with each other, it is important to have a common language among the systems. Nowadays, the common language adopted by most learning organizations is eXtensible Markup Language (XML), since XML can facilitate significant features in the e-Learning framework, such as personalization, interoperability, reusability and flexibility [XML 2000].

XML was developed to facilitate the description and exchange of data on the Web by the World Wide Web Consortium [Goldfarb and Prescod 2000]. It is a means of representing information according to its internal structure. Such a structure makes the information in the XML files meaningful and machine-readable, and therefore achieves interoperability and reusability of information [Bosak 1997]. The great potential of using XML has been predicted by many developers and technology-driven companies. In fact, several learning organizations, including a group newly formed by IEEE, are trying to develop e-Learning standards using XML [Gerber 2001]. However, several key problems remain unsolved for developing e-Learning content based on learning objects and XML. Firstly, the exact definition of a learning object is still unclear. Several different definitions exist, and most of them are so broad that they may lose any useful meaning. Secondly, though it may be possible to find the appropriate learning objects by their metadata, it is not clear whether it is possible for computer agents to integrate these learning objects in an appropriate way to form a higher level of course unit that makes instructional sense. Most e-Learning specification initiatives have not mentioned this issue or just leave it to specification adopters to make the decision by themselves. Thirdly, there are many e-Learning specifications in XML available now, however each of them has its own emphasis, and none of them provides a complete solution for developing an e-Learning system. Therefore, most online instructional systems are still developed in proprietary ways without adopting the existing specifications. Finally, although XML was introduced several years ago, it is far from mature. Many technologies associated with it are still under development or change frequently, and therefore learning specifications based on XML have to change accordingly. Moreover, XML is difficult to work with, needing a careful design by organizations that want to adopt it. All of these issues make the use of XML in developing a reusable e-Learning system difficult to implement. This thesis addresses the possibility of developing learning content based on learning objects and the role played by XML for designing an e-Learning system. The main goal of this research is to design a reusable and adaptive e-Learning system with XML

schemas forming the basic framework. To implement this goal, the concept of a learning object is redefined, and a schema for learning objects is developed. Some modifications to the existing e-Learning specifications, such as the metadata specification, the content packaging specification, and the learner information specification, are introduced to make them more suitable for our e-Learning systems. In this thesis, four online tutorial courses are developed to illustrate how these schemas can work together to make it possible to reuse learning objects in different learning contexts and to provide learners with individually tailored learning content. Chapter 2 of this thesis provides background information on e-Learning. First, e-Learning and the requirements of future e-Learning systems are reviewed. The concept of a learning object is selected for a deep examination, since learning objects form the basic foundation of an e-Learning system. Then the present state of XML, and issues such as why XML should be used, and what are the benefits are discussed. Finally, the emerging international standards for e-Learning systems are reviewed, along with the benefits of open standardization. In Chapter 3, the features of learning objects according to the new definition are summarized. The schemas for learning object, metadata, content packaging, and learner information are defined and explained. Chapter 4 describes the architecture and detailed design of the experimental e-Learning system, and Chapter 5 describes the implementation of this system. Chapter 6 summarizes the thesis work, and discusses research contribution and future work related to the eLearning system.

Chapter 2 Background

2.1 E-Learning, A New Way Of Learning Education has evolved considerably because of Web technology. The Internet enables the ordinary person to have access to never-ending quantities of information and knowledge more efficiently and conveniently. The growth of the World Wide Web, high-capacity corporate networks, high-speed desktop computers and all kinds of mobile devices will make learning available to people 24 hours a day, seven days a week around the globe. Since many traditional education organizations are using Web technology to deliver educational content, it is possible now for a high school student to seek assistance with mathematics questions at any time of the day or a graduate student at home to take some courses through long distance education. Web-based learning not only improves the achievement of students from kindergarten to university, but also enhances the productivity of the corporate workforce. Turbulent corporate environments, caused by market dynamics, have made knowledge and skills indispensable for effective performance in the workplace. Knowledge in the workplace is no longer implied but required at different times and different quantities. Traditionally, corporate training has existed in organisations to impart knowledge to individual workers as off-the shelf learning packages. In this model, learning takes a reactive approach to problem solving encountered by organisations, and learning programs take place in a specific location. However, recent advances in the fields of distributed and ubiquitous computing, artificial intelligence, cognitive learning theory, and multimedia have converged to provide more distributed learning systems over the Internet and World Wide Web (WWW).
4

A requirement for knowledge and skills distribution across different systems, space, and time is pertinent to unique learning requirements of individual learners within all kinds of organisations. The infrastructure to support such knowledge distribution is in the form of electronic learning, normally referred to as e-Learning. Commonly, e-Learning is defined as Internet-enabled learning, or convergence of learning and the Internet, including any use of computers and the Internet to facilitate education [Downs 1998]. The components of e-Learning can include content delivery in multiple formats through the Internet, management of the learning experience, and a networked community of learners, content developers and experts. E-Learning covers a wide set of applications and processes such as Web-based learning systems, computer-based learning systems, virtual classrooms, and digital collaborative learning GroupWare packages. E-Learning content is mainly delivered via Internet, intranet/extranet (LAN/WAN), audio- and videotape; satellite broadcast, interactive TV, DVD and CD-ROM, and the still to emerge wireless application protocols (WAP) [ASTD, 2001]. It is estimated that the e-Learning market will grow substantially over the next five years. Moreover, with the improvement of bandwidth, video, and storage technology, the demand for e-Learning products and service will increase exponentially [Wiley 2001]. 2.1.1 The Features of E-Learning E-Learning has the potential to revolutionize traditional education, because it could provide faster learning at reduced costs, increased access to learning, and clear accountability for all participants in the learning process. It enables businesses or schools to distribute training and critical information to multiple locations easily. Employees and students can then access training when it is convenient for them, at home or in the office.

In today's fast-paced culture, organizations that implement e-Learning will provide their work force with the ability to turn change into an advantage. However, e-Learning is just now in its infancy [Downes 1998]. As pioneers struggle with new technologies and new practices, the discipline evolves almost daily. Despite the rapid change, some significant features of future e-Learning can be identified as the following: Personalization. The education of the future will become deeply personalized.

The learning topics will be selected based on student interest, student aptitude and educational level, and societal need. The menu of available courses presented to any given student will be determined dynamically by the student's prior learning assessment, by the prerequisite for the new course, and by the learning management system. A student's daily menu will be varied and constantly changing, building on each day's achievement. Interoperability and reusability. E-Learning systems with different

environments and contents from multiple authors must have the ability to work together. There must be a semantic relationship between different e-Learning systems. Learning content may be reused in multiple applications and environments regardless of the tools used to create them. This requires that content be separated from context-specific runtime constraints so that it can be incorporated into other applications. For reuse to be possible, content must also have common interfaces and data. Flexibility. Courses could be generated in a variety of forms based on standard

style sheets. Different forms of layout could be available depending on the purpose of the course and the preferences of the learner. A student can use various kinds of devices with different processor speeds and memory capacity, from desktop computers, laptop computers, and mobile devices such as Palm computers, to access the learning content.

2.1.2 A New Approach to E-Learning Content Development Despite the wide spread use of e-Learning infrastructure in corporate and educational environments, current approaches to the development of e-Learning content are expensive and time consuming. It is common that content developed by a single vendor or educational institution can be difficult to reuse by a second vendor or institution, even though the content shares the same meaning and quality [Downes, 2001]. Failure of systems to interoperate or exchange content and differences in content ontology between institutions make content reusability and sharing difficult, although content sharing and reusability will reasonably reduce production cost. In order to make e-Learning content less expensive to produce and portable across different hardware and software systems, a new way of developing e-Learning content has been proposed. This new approach assumes that e-Learning content can be organised and disseminated in a uniform format as small chunks of learning materials commonly referred to as learning objects or knowledge objects [Clayton 2000] [Feemster 2000]. It seems that developing and delivering learning content as objects will promote reusability, interoperability and content sharing between different training vendors and educational institutions. When combined, the learning objects, due to their reusability in different learning scenarios may form educational resources that can be used in different environments by different individuals. This realization leads many course developers to believe that the learning object can become the foundation of adaptive instructional systems that deliver individually tailored learning materials to large number of people at the same time. With standards and compliance in place, it is possible for learning materials to be reused and to travel on different systems. However, another problem comes up due to unstructured nature of most of the information available: how can someone search through a vast online repository of objects to enable them to get what they need? The answer is that learning objects must be associated with appropriate metadata. They must

be labelled as to what they contain, what they teach and what technical requirements are needed for their use. It should be also noted that issues of content relevance, systems compliance, and the nature and structure of content are important problems to solve when designing reusable e-Learning content. Currently, the main technology used for tagging learning objects is the eXtensible Makeup Language (XML) [Fox 2000] [Gerber 2001].

2.2 Learning objects

2.2.1 Background Literature on Learning Objects The complexity and contradictions about what constitutes a learning object are reflected in the different views expressed in its definition. The IEEE Learning Technology Standards Committee (LTSC) describes learning objects as any entity, digital or nondigital, which can be used, re-used or referenced during technology supported learning [LTSC 2002]. It goes on to argue that learning objects include multimedia content, instructional content, learning objectives, instructional software and software tools, and persons, organizations, or events referenced during technology supported learning. However, this definition is so broad that anything related to learning can be interpreted as a learning object. Therefore, several groups outside the LTSC have accordingly created some new definitions of learning objects, which normally narrow the scope to something more specific. Following are some definitions that have been adopted by various organizations and companies: [IDC 2001] white paper asserts that a learning object is a standalone piece or chunk of education that contains content and assessment based on specific learning objectives and that has descriptive metadata wrapped around it. [Shepherd 2001] defines a learning object as a small, reusable digital component, which can be selectively applied - alone, or in combination - by computer software, learning facilitators or learners themselves, to meet individual needs for learning or performance support.
8

[Wiley 2001] concludes a learning object is any digital resource that can be used to support learning. He claims that this definition is sufficiently narrow to define a reasonable scope: reusable digital resource, and is also broad enough to include the estimated 15 terabytes of information available on the publicly accessible Internet.

Given all these definitions, there still seems to be little clarity, specifically on what forms a learning object. However, important features of learning objects, shared by most of the definitions, are centred on the grounds that the use of learning objects should be focusing on reusability and sharing. Those definitions explicitly rule out any non-digital and non-reusable resources, such as actual people, events, books, or other physical objects. Examples of learning objects includes the smaller digital resources, such as images, paragraphs of text, questions, animation, audio or video clips, and also the larger resources, such as entire web pages that combine text, images and other media applications to deliver complete instruction. These objects, which are reusable, should be stored in repositories and the copies of their metadata should be available in computers easily accessible by users [Downes 2001]; [Shata 2001]. The idea shared by these definitions is that by building learning resources as reusable learning objects, developers of learning materials, learning managers and learners themselves will all stand to gain [Klassen 2000]. The benefits can be summarized as the follows: Courses can be constructed using learning objects from a wide range of resources. Course developers do not need to prepare all course materials from scratch, therefore they can produce courses more economically;

Courses can be customized to suit the needs of different learners by selecting different learning objects according to the requirement and the interest of learners;

Learning objects can be reused to meet a range of learning needs. It is not necessary to develop similar learning objects for multiple times;

The same objects can be employed across a variety of hardware and software platforms, when common standards are followed by the learning objects.

2.2.2 Reusability of Learning Objects Reuse has existed in the field of software engineering for decades. Software reuse is the process of creating software systems from predefined software components [McClure, 1995]. The greatest benefit of reuse arises from the possibility for rapidly assembling small components into complex ones. With object-oriented design and programming, a completely new way of thinking about the construction of complex systems was originated. Object orientation allows software components to be used as building blocks for future software developments and takes components created by others rather than creating new ones from scratch. In this sense, learning objects are an application of object-oriented design to the world of learning. Reusable learning objects represent an alternative approach to content development. Learning objects treated as small components are pedagogically broken down into small chunks. Better yet, from a pedagogical perspective, each chunk plays a specific role within an instructional design methodology. The basic requirement for each chunk is its ability to communicate with any learning systems using a standardised method that does not depend on a specific system. Akin to the behaviour of small software objects in the object-oriented programming model, what happens within an individual learning object is trivial, since this is obscured from the designer and the user.

10

Each learning object must have a description that enables designers and computer agents to search for and find the right objects for the right job. This implies that objects must be wrapped in metadata. Whatever the properties the learning object has, the metadata itself should be straightforward. Moreover, since the metadata is machine-readable, it must be possible for a specific system to interpret the metadata from other sources and then reuse the learning objects. However, it should also be noted that metadata is limited because it is only a wrapper for the search engine to identify one object from another. The knowledge bits inside a learning object cannot be distinguished by metadata.

2.2.3 Problems with Learning Objects Although it is a good idea to develop course content based on learning objects, some problems still exist. The learning objects are designed not only for direct human processing but also for automatic machine processing. They should allow processing by intelligent services such as information brokers and search agents, which provide greater functionality. For example, one important benefit that these reusable learning objects can offer is that, by mixing and matching them, an e-Learning system may customize learning for individuals. It is also described in the proposal of the Learning Objects Metadata Working Group formed by LTSC, which tries to enable computer agents to automatically and dynamically compose personalized lessons for an individual learner [LTSC 2002]. However, several questions will be raised when we design an e-Learning system to fulfill this goal: How should we define the level of granularity of learning objects? Does it make sense to view any single image, paragraph of text or a question as a learning object? Is it possible to use search agents to select and integrate the learning objects in an appropriate way to form a higher level of course unit, which make instructional sense?
11

Are metadata sufficient to facilitate the combination of learning objects?

The important issue not clearly addressed in the literature on learning objects is the granularity and combination of learning objects. Granularity refers to the size of the learning object and combination refers to the manner in which learning objects can be combined and assembled into larger structures to enhance learning [Wiley 2000] [Jamlan 2001]. For two extreme examples, a learning object can be as small as a piece of an image or as large as a complete course. For the former, such a learning object may be reused by a lot of courses, however it is difficult, if not impossible, to select those individual learning objects and combine them directly by computer agents in a way that makes instructional sense. For the latter, although one can easily re-sequence a complete course in a new context, the potential reusability of this learning object will be low. [TechLearn 2001] has reported that there are no clear standards for the size (or granularity) of a learning object. However, studies show that larger learning objects are typically harder to reuse than smaller ones [Daniel, 2001]. From an efficiency point of view, the decision regarding the granularity of learning objects can be viewed as a tradeoff between the possible benefits of reuse and expense of combination. Granularity and combination issues in the design of learning objects are tantamount to issues of scope and sequencing of learning materials in instructional design [Wiley, et. al, 2000]. The way in which learning objects can be combined with other learning objects is very much dependent on their scope and structure. However, traditional instructional design theories that provide explicit scope and sequencing support are not applicable to learning objects. [Wiley 2000] further argues that the structure of learning and the combination of objects are like molecular bonding process; molecules of the same nature can be combined to form complex structures.

12

Currently a clear ontology for defining learning objects is lacking. Furthermore, if learning objects are solid entities, which can be referenced by others, as proposed by the principles of object orientation, then a learning object should support some kind of data structure. To address those problems, [Daniel 2001] has initiated a new attempt to characterize learning objects as pieces of instruction but not just pieces of digital information. He claims that a learning object should provide instruction on a relatively small, discrete skill or unit of knowledge, and the content of a learning object should be self-sufficient, independent of the context. Even so, it should be possible for a learning object to be used in more than one sequence of instruction. In this proposal, we will further discuss the features of learning objects in chapter 3, where we redefine the concept and develop a schema for a learning object.

2.3 E-Learning and XML

For all the new features and technical demands of future e-Learning, XML seems to be a reasonable answer [Adolphe 2000]. XML is an important step in the direction of promoting the interoperability and flexibility of Internet applications. As a simplified subset of SGML, XML was created as a way to structure, store and send information on the Internet. Unlike HTML, XML allows someone to create his/her own tags and define the DTD (Document Type Definition) or XML Schema. The DTD or schema supports a tree structure, which is much richer than a simple flat list and also respectful of cognitive and data processing requirements for economy and simplicity. When XML is used to store unstructured or semi-structured data, for which the traditional relational database is not suitable, it gives developers the ability to manipulate the information easily and quickly. With XML, course developers may put semi-structured information, such as the course content or course structure, into a discrete relational field,

13

and then work with this information as with structured blocks of data, not as with a string of bytes. Therefore, for e-Learning XML provides a flexible approach to represent the content and the structure of a course, and to keep such information separate from the software used for delivery and presentation. Moreover, content stored using XML can be independent of any course, and is in a form ideally suited to re-use in any number of different courseware and other learning-related products. For example, learning content in XML may be transformed into PDF to form a part of a book, or into HTML to provide online education. With the current intense interest in XML and rapid progress in the area of XML data management, more and more attention has been paid to using XML as an intermediate format for Web-based information representation, exchange, retrieval and reasoning [Nauer et al.2000]. It is widely acknowledged that XML will form the standard for data interchange in electronic commerce, and that the management of large and complex web site will be much improved by the use of XML. As the e-learning market grows dramatically, an increasing number of organizations and vendors are using XML as a standard way to tag or mark up learning information, such as learning materials, management resources, and student data, so that they can be easily referenced, read, and exchanged across applications and systems. [Gerber 2001] points out that XML allows e-Learning designers and administrators to develop applications faster, reuse course content easily, and facilitate data exchange between Web-Based courseware content and learning management systems. However, XML is not a single specification. A rich environment surrounding XML has been developed by the World Wide Web Consortium (W3C) and others since 1998. This environment includes many important specifications, such as DTD, XML Schema, Namespaces in XML (XML Names), Xpath Language (Xpath), Extensible Stylesheet Language (XSL), XSL Transformation (XSLT), XML Query, XML Document Object

14

Model (DOM), XML Linking Language (XLINK) and XML Pointer Language (Xpointer), many of which can be used in an e-Learning system. 2.3.1 XML Schema and its Benefits for Interoperability and Reusability of Information In online systems, the most popular use for XML is to create a separation of content and presentation [Box et al. 2000]. In this situation, we are defining application content as the data that needs to be displayed to a client or processed by a computer agent, and application presentation as the formatting of that data. XML is a markup language for documents containing semi-structured information. Information is stored in XML documents with a logical structure, therefore it is meaningful and machine-processible. This kind of format improves the interoperability and reusability of information, and makes flexible Web-based information representation, exchange and retrieval possible. Both a DTD and an XML Schema can be used to define the tree structure and establish a set of constraints for an XML document. However, DTDs have no formal mechanism to support the declaration of semantic integrity constraints. They show some critical limitations: DTDs are not themselves XML documents; they have no knowledge of hierarchy, they have difficulty in handling namespace conflicts, and they have no means of specifying the types of relationships allowed in XML documents. For these reasons, the XML Schema specification was developed to replace and amplify DTDs. Schemas express shared vocabularies and allow machines to carry out rules made by people. They provide a means for defining the structure, content and semantics of XML documents. XML Schemas have the same purpose as DTDs, but provide several significant improvements [Fallside 2000]: XML Schema definitions are themselves XML documents; XML Schemas provide a rich set of datatypes that can be used to define the values of elementary tags;
15

XML Schemas provide a richer means for defining nested tags (i.e., tags with subtags); XML Schemas provide the namespace mechanism to combine XML documents with heterogeneous vocabulary.

These new features are important progress in the development of XML. They will influence the ways in which XML can be used. XML Schemas offer an XML-centric means to constrain XML documents, or to bring DTDs back into line with XML itself. Every tool that handles an XML document can also be used to deal with schemas. XML Schemas provide a rich set of datatypes and a richer means for defining nested tags. This makes XML languages more like an object-oriented programming language such as Java. Like the definition of data structures of objects in Java, schemas define and model complex object semantics for XML documents, where semantics fundamentally means an intricate web of constrained relationship and properties [Cover 2000]. XML Schemas supports a flexible way to use namespaces. Namespaces are the mappings used for handling definition collisions, when several data type definitions are adopted by the same XML documents. Namespaces were invented after DTDs and are not fully supported by them. However, XML Schemas provide a more advanced namespace mechanism to combine XML documents with a heterogeneous vocabulary. A customized XML Schema would allow an XML document to make a reference to standard schemas whenever necessary. This method could improve the interoperability of XML documents. On the Internet, interoperable exchange and retrieval imply the existence of a sharable ontology, or common set of object semantics [Klein et al. 2000]. XML Schemas fulfill a major goal in common with ontology, namely providing semantic vocabulary and structure for describing information sources that are aimed at data exchange and information retrieval. Using XML in building learning objects and other learning information enables designers to share content with their colleagues or with course designers in other organizations. It should be noted that if a common schema is developed
16

and adopted, information tagged in XML for one system could easily be integrated with any other system. For instance, using XML as a language of metadata allows the user to create new kinds of descriptors that feature the learning objects. Since the schema ensures that the metadata is machine-readable and meaningful for the search engines, any learning management system (LMS), which chooses to support this schema, can use this metadata to select learning objects. Furthermore, through the use of XML Schema, learning objects can be structured and presented as nodes of trees in a content packaging file to reflect different levels of learning granularity and seqencing, which makes the combination of learning objects possible. 2.3.2 XSL, XSLT and XPath for Flexible Information Presentation XSL is the Extensible Stylesheet Language. XSL transforms and translates XML data from one XML format into another. XML provides a way to store data with logical structures and to define a semantic constraint on the data, but it does not tell how to present the data. In order to display XML documents to the clients, it is necessary to have a mechanism to describe how the document should be displayed. One of these mechanisms is Cascading Style Sheet (CSS), but XSL is the preferred style sheet language for XML, and XSL is far more sophisticated than the CSS used by HTML. XSL actually consists of three languages [Berlund et al. 2000]: XSLT is a language for transforming XML documents into other types of documents, or into other XML documents. XPath is a language for addressing parts of an XML document. XPath was designed to be used by XSLT. XSL Formatting Objects is an XML vocabulary for specifying formatting semantics.

17

XSL is a powerful style sheet for XML documents. Instead of having to rewrite the course content in different formats or in a different length, the developers can use XML to separate content from the way it is presented. That allows them to re-organize the content and make tailored courses for a specific learner in an appropriate format. For example, the same XML document may need to be displayed in HTML, PDF, and Postscript form. Without XSL, the XML document would have to be manually duplicated, and then converted into each of these three formats. Instead, XSL provides a mechanism for defining stylesheets to accomplish these types of tasks. Through some standard XSL files, an XML file can be transformed into different formats without having to change the data due to the requirement for different representations. In this way, XSL helps XML fulfill reusability of content. For mobile devices that want to access the learning content, Wireless Markup Language (not HTML) is used. WML is defined as an XML 1.0 application, so XSLT can also be used to transform the XML documents to WML files, and then the Palm computer or mobile phone displays the WML files. With XSL, XML will implement a flexible information presentation with little effort. 2.3.3 XML DOM and SAX The personalization of learning content means that every learner may get information matching particular requirements. Therefore, it is necessary to search and retrieve different information from the XML documents for different learners. As a data-driven markup language, XML can be easily searched and manipulated due to the strict structure and semantic constraint that schemas can impose [Boyle 2000]. XML is simple and easy to use, since there are some software packages for XML parsing. Right now, two APIs for XML, SAX (Simple API for XML) and DOM (Document Object Model) are normally adopted. With the SAX, developers have access to the information in XML documents as they are read, without imposing major memory constraints or a large code footprint. Meanwhile, DOM is designed to generate a

18

representation of an XML document as a tree, therefore users may traverse and manipulate the tree structure to retrieve the data. As W3C specifications, both DOM and SAX provide a standard programming interface to a wide variety of applications for XML. They are designed to be used with any programming language and any operating system. With DOM and SAX, a user can create an XML document, navigate its structure, and extract, add, modify, or delete its elements. Several tools currently used these APIs and provide the means to parse a XML document. 2.3.4 Conclusions about using XML From the above review of XML and the technologies associated with it, it is clear that XML can benefit an e-Learning system with several advances. Firstly, XML Schemas provide a way to define a set of elements, which can establish a shared ontology among different organizations. This helps learning materials go through platforms and be reused without the problem of compatibility. Secondly, the separation of content and presentation will enhance the flexibility of displaying learning materials. By adopting the standard XSLT files, learning materials may be transformed into a variety of possible standard forms. Lastly, information stored in XML files is easy to search and retrieve due to the structure and constraint that XML files followed. It seems that XML is almost ready to be used in such online systems as e-Learning. However, it should be noted that change and development is occurring rapidly, and that XML is far from stable. Some guides about using XML in e-Learning system have been published, however, no practice and experimental data are available yet. Therefore, using XML in a realistic environment is just in a tentative phase now.

2.4 E-Learning Standards

Why should we develop standards for e-Learning? Maybe we can get some inspiration from the Lego system, the childrens construction toy. Although individual Lego pieces
19

have different shapes and sizes, they always follow the standard units of measurement and standard interfaces. Therefore, no matter how one wants to reassemble the pieces, they always fit together. The idea behind standards for e-learning is exactly the same. If the learning objects and metadata follow common standards, the course developers or computer agents can eventually form an integrated course by assembling all kinds of learning objects. In the e-Learning community, XML forms the basic foundation for inter-application communication, however it does not ensure that communication will happen. For example, people speaking different languages cannot understand each other. Even in the same language, such as English, words may have different meanings; the word football represents different sports in England and North America. To make communication possible, a set of vocabularies with clear definitions should be shared by speakers. That is what some organizations are doing; developing standards in XML for e-Learning. In this section, we will survey some important organization and potential standards in e-Learning community. 2.4.1 Standards Initiatives for E-Learning Strictly speaking, there are just a few e-Learning standards now. Several organizations are concerned with e-Learning specifications that the learning community may support. Amongst them, Learning Technology Standards Committee (LTSC) from Institute of Electrical and Electronic Engineers (IEEE), the Aviation Industry Computer-Based Committee (AICC), the Instructional Management System (IMS), the Advanced Distributed Learning (ADL) and the Educational Modelling Language (EML) are the leading ones. IEEE LTSC IEEE, ISO (International Standards Organization) and ANSI (American National Standards Institute) are the major organizations that set most official computer standards.

20

IEEE has developed many technology standards for electrical and information technologies and sciences. Several years ago, it set up the LTSC to develop technical standards, recommended practices, and guides for software components, tools, technologies and design methods that facilitate the development, deployment, maintenance and interoperation of computer implementations of education and training components and systems [LTSC 2002]. Currently, the committee is carefully reviewing the specifications created by IMS, ADL and AICC, comparing and combining them, and making sure that they are general enough to fit the requirements of any learning organizations. Several working groups have been formed concerning the standards in a number of areas, such as glossary, student identifiers, learner models, course sequencing, content packaging, learning object metadata and so on. The standard for learning object metadata was approved on June 13, 2002, by the Standards Board of the IEEE Standards Association. AICC In 1988, AICC was first formed to propose hardware requirements for running computerbased training (CBT) software developed for the aviation industry. However, it has since branched into several other areas [AICC 2002]. In recent years, the AICC has developed guidelines for the aviation industry in the development, delivery, and evaluation of CBT and related training technologies. AICC recommendations are fairly general to most types of computer-based training and, for this reason, are widely used outside of the aviation training industry. It also actively coordinates its efforts with broader learning technology standards organizations like IMS, ADL, and IEEE/LTSC. IMS IMS may be the most influential organization in the e-Learning community. The contributing members of IMS include many well-known academic, corporate, non-profit and government organizations. IMS is developing and promoting open specifications for facilitating online distributed learning activities such as locating and using educational

21

content, tracking learner progress, reporting learner performance, and exchanging student records between administrative systems [IMS 2002]. Because XML has shown its advantage in the interoperability and reusability of data, IMS adopts XML in all of its specifications. Now five specifications are available. When designing our e-Learning system, we were aware of these specifications and tried to adopt them in our system [IMS 2002]: The IMS Learning Resources Meta-data Specifications creates a uniform way for describing learning resources so that they can be more easily found [IMS 2000c]. The IMS Enterprise Specification deals with administrative applications and services that need to share data about learners, courses, performance, etc., across platforms, operating systems, user interfaces. The IMS Content & Packaging Specification is concerned with creating reusable content objects [IMS 2000a]. The IMS Question & Test Specification addresses the need to be able to share test items and other assessment tools across different systems [IMS 2000d]. The IMS Learner Profiles Specification looks at ways to organize learner information so that learning systems can be more responsive to the specific needs of each user [IMS 2000b]. ADL The initiative of ADL is to accelerate large-scale development of dynamic and costeffective learning software and to stimulate an efficient market for these products in order to meet the education and training needs of the military and the nation's workforce of the future [ADL 2002]. It achieves this through the development of a common technical framework for computer and net-based learning that will foster the creation of reusable learning content as "instructional objects."

22

ADL has developed the Sharable Courseware Object Reference Model (SCORM) initiative. SCORM includes four major areas: metadata, course structure format, data model, and an application program interface or API. To avoid reinventing the specifications, SCORM integrates specifications from IMS, AICC and IEEE. It also created a software program to test the learning objects, learning management system, and course delivery tools for compatibility. EML EML is a research program for educational modelling carried out by the Open University of the Netherlands (OUNL). It tries to develop a comprehensive notational system that allows course developers to codify units of study (e.g. courses, course components and study programmes), in an integral fashion. EML describes not just the content of a unit of study (texts, tasks, tests, assignments) but also the roles, relations, interactions and activities of students and teachers. The major EML implementation is in XML [EML 2002]. However, EML pays less attention to the possibility of reusing study units in different course contexts. It mainly focuses on how the course structure should be described and how an instruction course should be navigated during a learning process. This limitation impairs its potential to become an e-Learning standard. Amongst all of these specifications, the metadata and content packaging or course structure specifications may be most important ones. In the following section, we will discuss these two specifications. 2.4.2 Specifications for Metadata Metadata is known as "structured data about data." The term metadata has been used only in the past 15 years, and has become particularly common with the popularity of the World Wide Web. The purpose of metadata is to provide a common way to describe resources so that they can be self-defined and searched [Gerber 2001].

23

The first organization dedicated to promoting the widespread adoption of interoperable metadata standards is Dublin Core Metadata Initiative [DCMI 2002]. It developed a set of simple specialized metadata vocabularies for describing resources that enable more intelligent information discovery systems on the Internet. Nowadays, many web sites adopt DCMI to describe their web pages. However, in an e-Learning system, DCMI is too simple to support effective resource discovery. It lacks the elements that may be used to describe the educational features of learning objects. Therefore, a number of organizations, such as IMS, ADL, and LTSC Learning Object Metadata (LOM) working group, are trying to develop a new metadata standard for learning objects. Over the past few years, the IMS have defined a standard dictionary of metadata elements, which is referenced and used by ADL. Some other initiatives, such as Canadian Core Learning Resource Metadata Protocol (CanCore), also follow this specification [Gerber 2001]. The LOM, which has been approved as an IEEESA standard, is also built on IMS Metadata Specification [LTSC 2002]. IMS Metadata Specification One of the key contributions of IMS is the IMS Learning Resource Meta-data Specification, an XML-compliant schema for indexing learning objects [IMS 2000c]. The growing popularity of this schema among e-learning projects such as SCORM (Sharable Content Object reference Model), and MERLOT (Multimedia Educational Resource for Learning and Online Teaching) and its adoption by a number of educational repository projects suggests that IMS will become the standard means of describing electronic educational materials [Lin 2001]. There are 86 elements in total in IMS metadata, which make the metadata a little complex. All the elements are divided into 9 categories, and each describes one kind of feature about the learning object: general Groups information describing learning object as a whole;

24

lifeCycle History and current state of resource; metaMetadata Features of the description rather than resource; technical Technical features of the learning object; educational Educational or pedagogical features of the learning object; right Condition of use of the resource; relation Features of the resource in relationship to other learning objects; annotation Comment on the educational use of the learning object; classification Description of the characteristic of the resource by entries of classification.

CanCore CanCore Protocol is based on and fully compatible with the IMS Learning Resource Meta-data Information Model. CanCore has defined a sub-set of data elements from this IMS model for the purposes of the efficient and uniform description of digital educational resources in Canada and elsewhere [CanCore 2002]. It is intended to facilitate the interchange of records describing educational resources and the discovery of these resources both in Canada and beyond its borders. Currently, the CanCore schema provides 54 elements in total, which is a little less than IMS specification. 2.4.3 Specification for Content Packaging or Course Structure Format The learning objects and metadata often need to be collected and packaged to enable efficient aggregation, management, and deployment. Therefore content packaging or course structure format can be used as a top-level manifest file describing the course elements, the course structure, and all external references necessary to represent a course and its intended behaviour. There are two kind of content packaging used by e-Learning systems, the Content Packaging conceptual model from IMS and the Course Structure Format (CSF) from ADL. The IMS content packaging is simpler and clearer than CSF, and allows references to CSF to be made by using a namespace [Shata 2001]. However,

25

none of them can provide an efficient way to describe the hierarchical structure of an instructional course, which contains course design information. IMS Content Packaging Specification The IMS content packaging conceptual model creates a Package Interchange File which is a single file, e.g. zip, jar or cab which includes a top level manifest file describing the package as a whole[IMS 2000a]. A package represents a unit of usable content, which includes all learning materials and the associated metadata. A content packaging file is used to describe in XML all the resources comprising a package and one or more ways of organizing the resources for presentation.

Figure 2.1 Content Packaging As described in [IMS 2000a], all data in this e-Learning system could be organized as Figure 2.1 depicts. The root element in the content packaging file is <manifest>, which may also contain optional (sub)manifests. Each instance of a manifest consists of two major parts: the <organizations> element describes the content organization and the

26

<resources> element contains all references to all the actual resources. The organization of the manifest and its nesting functionality permit a great deal of flexibility, which allows developers to aggregate or disaggregate their material as they wish, thus a package might be a unit in a course, a whole course or a whole curriculum of courses. The actual resources form part of the package, with suitable metadata describing each resource. 2.4.4 Specifications for Question & Test Interoperability Specification The IMS Question & Test Interoperability Specification provides proposed standard XML language for describing questions and tests. The specification has been produced to allow the interoperability of content within assessment systems [IMS 2000d]. It describes a basic structure for the representation of question (item) and test (assessment) data and their corresponding results reports. Therefore, the specification enables the exchange of this test, assessment and results data between Learning Management Systems, as well as content authors and, content libraries and collections.

2.5 Summary
In this chapter, we have reviewed a new approach to education, e-Leaning, and some important topics around it, such as leaning objects, XML and open standards. It should be noted that the key problems with learning objects, namely granularity and combination, are still unsolved. Moreover, the use of XML is still not universal in the e-Learning community and XML is not used in a consistent manner. There is no specification for learning objects and the content packaging specification provides no information about instructional design. Those problems make it difficult to develop an e-Learning system based on XML that accomplishes reusability, interoperability and flexibility.

27

Chapter 3

Schema Design
Before designing an e-Learning system based on XML, some fundamental concepts and ideas must be clarified. For course designers, the idea of learning objects requires an immense change in thinking. Instead of looking at learning as a fixed linear progression, we must now look at learning as clusters of independent, stand-alone objects of knowledge. These learning objects should be dynamically selected and sequenced by computer agents to form an individually tailored course. The key problem here is how we should handle these learning objects. We need to find a way to ensure that these objects can be more easily accessed, can be located by computer, can be easily updated, and can be seamlessly tied in with other objects to make a more complete learning package. We also need to make sure that the learning course built on learning objects can present clear objectives, integrated content, and carefully sequenced instructional activities. One answer for this is to use XML as metadata for describing the learning objects. In an e-Learning system, we use metadata to support resource discovery. Every learning object will have associated metadata that is written in XML and conforms to a particular XML Schema. The schema gives specific constraints on the structure of metadata, and also provides information about the interpretation of the metadata. A series of tags defined in the schema are combined together to describe the learning objects. A designer or a search engine will look at the metadata to decide how to find the necessary learning objects and reconstruct them again.

28

However, metadata alone is not enough. To make it possible for computers to make sequencing or any other instructional design decisions, the computers must have access to instructional design information to support the decision-making process. Therefore, it is necessary to have some way to describe the organizational structure of the learning objects and to include enough instructional design and sequencing information. Moreover, to make the instructional design suitable for an individual user, background information about learners is also required. Therefore, a basic framework for an e-Learning system becomes clear. A library of learning objects with metadata forms the basis of the system. In order to construct personalized courses for learners, a data model of a learner is needed to provide background information to describe the learners needs. The Learning Management System, including a search engine, uses the learners interests to select appropriate learning objects and then pieces together courses based on the organizational structure and instructional design information In our project, the following aspects are defined in XML schema: The learning object; Metadata for retrieval and reuse; Content packaging for the learning structure, including information about sequences and alternations of the learning objects; Learner model, including the learners personal properties, such as skills, prior knowledge, and background information. Since schema development is an expensive process, in this project, we borrow from existing standards or specifications when possible, such as the metadata specification, the content packaging specification and the learner information specification. However, it should be noted that some modifications are needed to make the schemas more suitable for a reusable and adaptive e-Learning system. Moreover, we redefine the concept of

29

learning object and develop a schema for it according to the new features that we have summarized. All of these four schemas and a learning management system form the foundation of the whole e-Learning system. In the following section, the schemas are described in detail, and the instance XML documents conforming to the schemas are provided in Chapter 4.

3.1 Schema for Learning Objects

3.1.1 New Definition of Learning Objects

As mentioned above, if we define learning object in too broad a way, we lose any useful meaning about learning object. Although reuse is the core of the learning object notion, as flexibility, adaptivity, and interoperability are all facilitated by the property of reuse, there is still a trade-off between the benefit of reuse and the cost of combination and resequencing. In this research, we prefer a much narrower definition, which makes the automatic construction of individually tailored courses possible. According to a common definition, a learning object is a small, reusable digital component that can be selectively applied - alone or in combination to support learning. This definition makes it impossible to develop a schema for learning object, since any digital resource, such as a single picture or a whole web site, can be viewed as learning objects. It is difficult to find a common structure among those resources and to define the granularity of learning objects. However, to travel across different platforms, learning objects should have a uniform format. Moreover, such a format should be able to facilitate the reuse and re-sequencing of learning objects. Therefore, we need a more specific definition. In our research, a learning object is defined as a combination of smaller knowledge bits, such as text, image, and audio or video clips, which are integrated together to explain or describe a single core concept in a course. Each learning object can stand alone as a
30

collection of content items, practice items and assessment items that are combined based on a single learning objective. The critical features of a learning object may be summarized as follows: A learning object is an integrated knowledge object, focusing on a core concept, not just a piece or a chunk of information. Normally, a learning object is smaller than a course, a module, or a lesson. However, in order to describe or explain a single core concept clearly, a learning object may still include some integrated knowledge bits, which may be in different formats, such as text, pictures, video clips, maps or simulations. All materials in a learning object will be organized to surround and describe a core concept. It is likely that the organization of a learning object should include a definition of the core concept, detailed description of the concept and sometimes several examples, a conclusion, and some test items or exercises. When a single text, image, video clip or a combination of those materials cannot provide a comprehensive instruction independently and needs be joined with other materials to explain a core concept, it will not be viewed as a learning object. A learning object cannot include a complex hierarchical structure. Learning objects are the lowest level of curriculum structure; therefore unlike the upper level structures of a course, such as lessons, modules, units or topics, they cannot have embedded concepts or units. Normally, a learning object should just have a flat structure. The constituent parts in one learning object are all in identical status. It is prohibited that a description about the core concept also contains another definition and description about a new concept. This means that if a learning content for one concept is constructed by several smaller sub-concepts, and each of the sub-concepts can form a stand-alone content, the instructional content about this concept may not be developed as a learning object. Instead, several smaller learning objects should be established to describe the subconcepts, which are then assembled and combined to instruct a more complex concept.

31

A learning object is the basic reusable unit. The greatest potential for reuse exists when the learning object centres on a single, core concept and does not rely on the support of other course contents or context to clearly provide instruction on this concept. A learning object can be used in more than one sequence of instruction. For example, when designing the hierarchical structure of a new course, the designers can just indicate what kind of learning objects are necessary, and then the search engine may find the appropriate learning objects from the global repository of learning objects. However, the knowledge bits in a learning object are not necessarily reusable units which can be handled directly by a search engine. If the designers only want to reuse some parts of the knowledge bits in a learning object, they should inherit this learning object or construct a new learning object by using some knowledge bits in this learning object. However, in such case, the work must be done by the instruction expert, not by a search engine. Several learning objects may describe the same concept. Since the users of a course may have different backgrounds, studying abilities and diverse levels of interests, for one specific concept, a learning system should provide different learning objects that may range from easy to difficult or from simple to complex. However, the learning objects that describe the same concept will probably have some common parts. To avoid multiple duplications of the content, some disciplines in objectoriented programming may be adopted, such as inheritance. Therefore, from one basic learning object, a set of extended stand-alone learning objects can be developed, which may be more difficult or more comprehensive. In such a case, a schema can be used to keep a consistent structure, which enhances inheritance between learning objects A learning object often includes some test items to evaluate the learners performance. To make learning objects independent of course context and reusable in different course sequences, learning objects should include the test items by themselves. Directly tied to

32

the core concept, test items may be used to identify whether a learner has mastered a given learning object. With test items a learning object will not solely depend on the highlevel context to evaluate the learners performance, and therefore fulfils a special learning objective on its own. A learning object must be searchable. Each learning object should be associated with metadata. The attached metadata can implement the express goal of interoperability, which allows search engines throughout the world to be able to successfully find and use learning objects. A learning object will normally be embedded in a hierarchical structure. Each learning object provides stand-alone instruction, so it is difficult to define the connection between learning objects in the content of a learning object itself. To help the learner comprehend the whole structure of a course or smooth the flow in the instruction, a hierarchical structure about the instructional content is necessary, which is used to connect learning objects. The preferred form of representation of learning objects is XML. Learning objects in the form of text can be directly represented in XML. The XML tags make the data in the learning objects meaningful, so the components in the learning objects can be searched, extracted and reused in various ways. In addition, learning objects in XML can be transformed to a variety of forms, such as PDF or WML, based on standard style sheets. This makes the whole system more flexible. In general, the granularity and combination of learning materials are implemented at two levels. At the low level, the learning object combines several knowledge bits to explain a concept, and at the higher level, the hierarchical structure describes the aggregation of

33

learning objects to form courses. This constitutes the solid underpinnings of a schema for learning objects.

3.1.2 The Design of a Schema for Learning Object In this project, we define a Learning Object Mark-up Language (LOML), which is an XML-based markup language designed for instructional contents. Because our specific interest is in the domain of Computer Science, this language is applied specially to describe topics as they apply to the field of Computer Science. When designing this markup language, we have taken into account the critical features to choose a simple set of mark-up tags to define the structure of a learning object.

Diagram

Attribute

Name inheritance

Type xs:anyURI

Use optional

Figure 3.1: Structure of <learningObject> Element

34

Figure 3.1 shows the first level of elements of LOML. In this thesis, all diagrams for the schemas are generated automatically by XML Spy, so they will follow the same style. The notations in this diagram are mainly adopted from UML (Unified Modelling Language) with some revisions. Each rectangle in the diagrams represents an element, with the name of the element inside the rectangle. If two rectangles lap together, it means that this element may appear multiple times. The signal + at the right side of the rectangle indicates that this element has also some sub-elements, which are not shown in the diagram. The switch notation between the root element <learningObject> and the first level elements means that one may choose any element from the first level element in any order to occur in an instance XML document. However, if the notation is a straight line, this means that the elements may just appear in the sequence that has been defined. In this schema for learning objects, the root element is <learningObject>. Other elements are organized into eight different categories: title The title of the learning object; definition The definition of the core concept on which the learning object focuses; description Some detailed descriptions of the core concept; example Some examples about the core concept; application Simulation or demonstration used to explain the core concept; conclusion The conclusion about the core concept. exercise The exercise used to improve the study of learner. test The test used to evaluate the result of study.

The inheritance attribute of the root element indicates from which learning object the current learning object inherits instructional content. If the attribute is not empty, the XML file indicated by the attribute will be loaded and combined with the tagged contents in the current learning object to form a complete description of the core concept. For each sub-elements of the root element, a unique id is assigned, which can be used as a reference to this element. Each element may also have reference attribute and status
35

attribute. If the learning object inherits content from a parent learning object, the reference attribute indicates one specific element in the parent, and the status attribute indicates what kind of action will be taken. The following lists the available actions: If the status is substitution, it means that the content in the current element should replace the content in the parent element, which is indicated by the reference attribute; If the status is integration, it means that the content in the current element should integrate with the content in the parent element, and then combine together to form a single content; If the status is connection, it means that the current element and its content should be inserted behind the parent element;

Diagram

Attribute

Type Use Facets id xs:string required reference xs:string optional status statusType optional substitution, integration, connection Figure 3.2: Structure of <Description> Element

Name

36

Since a learning object may contain text content, we still need some elements to support such textual formats as paragraph, table, list, and head. Figure 3.2 demonstrates the structure of <description> element and the attached attributes. In this structure, in addition to some text elements, the <media> element is used to indicate what kinds of multimedia are used in this learning object, so the proper tools can be invoked to display the multimedia files. This element includes three attributes, type, mimeType and uri, which present the type of the multimedia file and the reference to the file. Moreover, the <code> element may be used to tag some special texts, such as formulae or algorithms. However, for the <test> element and <exercise> element, it is possible to adopt an existing specification to develop test items. In this schema, QTILite specification from IMS is imported. This specification is based upon the IMS QTI specification and is the realization of a subset of that model. It is presented as the entry-level specification to the full QTI specification, just supporting the question styles of true/false and multiple choices with single answer.

Figure 3.3 Importation of QTILite Schema Figure 3.3 demonstrates how the QTILite specification is included in our LOML schema. The schema file, ims_qtil_rootvip1.xsd, is loaded by the <xs:import> element and the namespace, qtil, is assigned to reference the QTILite schema. Therefore, the LOML schema may use any element type from QTILite to define new elements. By adopting the
37

specification from IMS, the test items developed for learning objects may be easily reused by other e-Learning systems. A detailed description about the use and implementation of OTILite can be found in [Brooks 2002].

3.2 Schema for Metadata

3.2.1 The Design of Schema There are currently several metadata XML schemas focusing on e-Learning. However, though those schemas may be used, a specific metadata XML schema should still be created in this research for the following reasons: The purpose of most standard schemas having the goal of interoperability is to allow everyone throughout the world to be able to successfully find and use learning objects. Therefore these schemas are complex, often with about one hundred element tags. An alternative is to choose some necessary elements from them and to build a new schema which will provide a good enough description for the learning objects in this specific project; A designer wants to be able to search for the specific topics within the library of learning objects. To do this effectively, the schema must have a controlled vocabulary, only allowing certain words to be entered between tags. While this makes the searches fast and accurate, it is not possible to do this without creating a unique schema. In fact, we need to add more constraints in our own XML schema and make the metadata document more meaningful. However, using a unique XML schema will not significantly harm the interoperability of the e-Learning system. We choose the tags from the standard schema, so every tag in our schema is still meaningful to others. A third-party search engine that can handle the XML metadata documents conforming to the standard schema could also handle ours. In practice, we selected about 23 tags from the IMS Learning Resource Meta-data Specification. Figure 3.4 shows the first and second level elements in the tree structure of the metadata schema:
38

Figure 3.4 Structure of Metadata

39

1. general Context independent features of the resource identifier - Globally unique label for learning objects; title Name give to the resource; language The human language used by the learning object; description A textual description of the content of the learning object; keywords Keywords describing the resource.

2. technical Technical features of the learning object format Technical data type of the resource; location A location or a method that resolves to a location of the resource;

3. educational Educational or pedagogic features of the learning object interactivitytype the type of interactivity supported by the learning object; learningresourcetype specific kind of resource, such as text or figure; context the typical learning environment where use of learning object is intended to take place; semanticdensity subjective measure of the learning objects usefulness as compared to its size; difficulty how hard it is to work through the learning object for the typical target audience; 4. relation Features of the resource in relationship to other learning objects kind Nature of the relationship between the resource being described and the one identified by <resource> element; resource Resource the relationship holds for.

5. classification Description of a characteristic of the resource by entries in classification taxonpath A taxonomic path in a specific classification.

40

3.2.2 Controlled Vocabulary Many search engines have a problem with interpreting the content between tags. Each person will use different words to describe the same learning object. When search engines try to find useful learning objects, this reduces the accuracy of the search. The best way to overcome this limitation is to employ a controlled vocabulary. Of course, there will be elements that allow a text description without controlled vocabulary, such as <description> element. However, these elements will usually not be used for searching. They will be used once a search has been completed to enable either the designer or the student to make a decision about whether or not to use the learning object without actually looking through it. Whenever possible, it is useful to specify a controlled vocabulary. It is desirable that some existing formal vocabularies can be adopted; however, this is not always possible. In the schema for metadata, three sets of vocabularies are selected to be used directly to describe the learning objects: Computing Curricula 2001. This is a joint task force to undertake a major review of curriculum guidelines for undergraduate programs in computing by the Computer Society of the Institute for Electrical and Electronic Engineers (IEEE-CS) and the Association for Computing Machinery (ACM) [CC 2001]. In this curriculum a set of vocabulary has been defined to represent different levels of topics in computer technologies. In the <taxonpath> element, this vocabulary is used to classify the areas with which the learning objects are concerned; Code for the representation of the names of languages. It comes from ISO 639, in which each language is represented by a two-character code. In the schema, the <language> element adopts those codes to indicate what kind of language is used;

41

Multipurpose Internet Mail Extensions (MIME). MIME defines all the medium types on the Internet, so that the <format> element can use them to describe the data types of learning objects.

However, when a formal vocabulary is not available, a set of vocabulary is defined according to the necessity. For example, the <difficulty> element uses the vocabulary, {very easy, easy, medium, difficult, very difficult}, to describe how hard it is to work through the learning object.

3.3 Schema for Content Packaging

In an e-Learning system, instructional content must be collected and packaged in some electronic form to enable efficient aggregation, distribution, management, and deployment. The content packaging from IMS may be used to enable the encapsulation of the required learning resources, simple course structure information, and other supporting information such as metadata, which promotes the flexibility and interoperability of learning materials. However, one of the major weaknesses of the IMS content packaging specification is that it only supports a simple structure, and does not include any instructional design information. Therefore, it is necessary to add new approaches, such as hierarchical branching, or custom learning paths with conditional branching, if they are required. In this research, the basic structure of the IMS content packaging specification is adopted, and then some new features are introduced to make flexible generation of an individually tailored course possible. The structure of the first two level elements in the content packaging schema is represented in Figure 3.5. Every content packaging file includes a top-level <manifest> element. It is a mandatory element describing the package itself. It may also contain some sub-manifests. Each instance of a manifest includes the following categories:

42

metadata an element describing a manifest as a whole. It can use any element in the metadata schema; organizations an element describing zero, one, or multiple organizations of the content within a manifest; resources an element containing references to all of the actual resources and media elements needed for a manifest, including metadata describing the resources, and references to any external files;

(sub)manifest one or more optional nested manifests.

Figure 3.5 Structure of Content Packaging Amongst those categories, the <organizations> element is the most important one. This element may contain several <organization> elements, each representing one separate course. The problem here is how to define a set of specific elements in the <organization> element to describe the course sequencing information. For example, Figure 3.6 represents the possible sequences of an online course. This course begins with A and ends with I. The points on the each row represent the learning objects that are concerned with the same concept but have different difficulty or comprehensive ranges. In this diagram, we have several possible paths from A to I. The path a1-b1-c1-f1-h1-i1 may stand for the simplest course structure, which just provides some basic knowledge. However, the path
43

a1-b2-c2-d1-e2-f5-g3-h2-i1 includes the complete list of all necessary learning objects, which may be the most difficult ones, and then gives the deepest instruction about the course.

Figure 3.6 Sample Course Structure To describe such a course, the structure of the <organization> element is designed to looks like Figure 3.7. It may contain several <item> elements; each represents a point in the course structure. An <item> element may contain subordinate <item> elements or may appear on the same level as other <item> elements. Each <item> element has an identifier attribute, which is assigned a unique string to distinguish this item from others. Also an identifierref attribute for <item> element may be used to reference a resource in the <resources> element, which indicates the learning object that should be put at this point. At some points, the <testItem> element may be set to indicate a quiz for evaluation of learners performance.

44

Figure 3.7: Structure of <organization> Element The <branches> element in <item> can be used to define the different instruction approaches in a same course. Each approach is described by a <branch> element that represents a separate instruction sequence. A <branch> element uses <condition> element to present the rules, on which the selection of one approach can be determined. In this research, three types of rules, separately or in combination, can be used to distinguish each approach. Figure 3.8 illustrates the elements included in <condition> element. The <difficulty> element and <semanticdensity> element describe the difficulty range and the comprehensiveness range of each path, which extend from 1 to 5, representing the range from low levels to high levels. Therefore the <min> element and the <max> element may illustrate the range of difficulty and comprehensiveness for a particular path. Moreover,
45

the <prerequirement> element specifies the prerequisite, which requires the learner to get some scores range at a quiz to go through this path. The use of content packaging to describe course structure is further discussed in Chapter 4.

Figure 3.8 Structure of <condition> Element

3.4 Schema for Learner Information

User modelling is an important research topic for many online systems, however in this thesis it is not a major one. The purpose of establishing a learner model in this thesis is just to ensure that a defined set of information about a learner can be recorded, tracked, and communicated between clients and servers. In the IMS learner modelling specification, a learner model in XML that describes those characteristics of a learner is needed for the general purposes of: [IMS 2000c] Recording and managing learning-related history, goals, and accomplishments; Engaging a learner in a learning experience;
46

Discovering learning opportunities for learners.

In this research, a simple schema for learner profile information is developed based on the learner model defined by IMS. This learner information is used by the e-Learning system to manage, organize, and evaluate the learners progress and performance. Figure 3.9 represents the schema for learner model. Four core learner information categories are included:

Figure 3.9: Structure of Learning Information

47

identification This element contains all of the data for a specific individual or organization, such as names and contact information. accessibility This element describes the studying capabilities of the learner. The <eligibility> element use a set of vocabulary, {very low, low, medium, high, very high}, to indicate the level of learners capabilities.

goals This element consists of the description of the personal objectives and aspirations. The learner can have several learning goals. For each goal, the <reference> element indicates the course in which the learner is interested. The <priority> element uses a set of vocabulary {very basic, basic, medium, advanced, very advanced} to describe the level of learning that the learner wants to achieve. The <status> element records whether this course has been finished.

activity This element includes the descriptions of the course undertaken currently and the records of the past learning content and corresponding evaluation for this course. Each <item> element in the <learningactivity> element records one learning object or one result of a quiz that the learner has taken.

48

Chapter 4 System Design

For e-Learning, learning objects and XML not only present advanced technologies, but also promise an approach to create online instruction quickly and economically. Although it is unlikely that a global library of learning objects, which follows some open standards, will be formed in near future, developing a campus-wide instructional system based on learning objects for courseware design and delivery is still possible. The main goal of this research is to develop a reusable and adaptive e-Learning system with XML schemas forming the basic framework. This system shows that it is possible to achieve flexibility, reusability, interoperability, and personalization of learning content in such a XML environment. This chapter describes the detailed design of the e-Learning system. The first section describes the architecture of this system. Section 4.2 is concerned with the rules and ideas behind learning content development that affect the structure of the entire system. It also explains how those XML documents should be developed based on the defined schemas, and how those documents work together. The last section deals with the design of the Learning Management System.

4.1 Architecture of the E-Learning System

The overall architecture of the e-Learning system is presented in figure 4.1. This system assumes a Web-based infrastructure as a basis for its technical implementation. Therefore, learners interact with the e-Learning system through browsers in the client side, and get the learning materials in the format of HTML. In the server side, the XML documents, conforming to the schemas that we define in chapter 3, are used to store all information
49

about learning content, instruction structures, and learner profiles. The Learning Management System (LMS), working as a run-time environment, deals with the XML documents to response to the learners requirements. It involves a suite of functionalities designed to deliver, track, report, and manage learning content, learner progress and learner interactions.

Figure 4.1 Architecture of the E-Learning System The LMS is developed to support the idea of composing larger units of instruction, such as a whole course, from relatively small, reusable learning objects. By themselves, learning objects have no specific context. As figure 4.1 shows, learning objects are normally separate knowledge objects with metadata, which are stored in a repository. When combined with other learning objects, it is the content packaging file that provides the context and allows an LMS to manage the learning experience. Resources can thus be reused in multiple contexts.

50

This means that learning objects do not determine by themselves how to navigate through an aggregation representing a unit of instruction. Instead, sequencing and navigation are determined by rules defined within the content packaging file and interpreted by the LMS. The LMS merely processes the explicitly defined rules and itself has no knowledge about how the content is organized. By importing the content packaging file and following the defined rules, the LMS has the ability to determine what and when to deliver, and tracks the learners progress through the learning content. This allows course developers to specify sequencing attributes and rules and navigation behaviour while maintaining the possibility of reusing learning objects within multiple aggregation contexts. In our system, the attributes and rules that are used to guide the navigation behaviour of the LMS include the follows: The difficulty range of learning content. Normally, one instruction course may include some basic knowledge and advanced knowledge, which are suitable for the requirements of different learners. For example, in a calculus class, the instruction content for students in Mathematics department should not be the same as that for students majoring in English. At some points of the instruction, several navigation paths need to be distinguished by the difficulty range; therefore learners with different background may reach the knowledge levels that fit their requirements. The comprehensiveness range of learning content. For the learners with similar background and requirement, the studying capability of those learners may still be different. When studying the same topics, some learners may need more detailed explanation and more examples than others. The navigation paths with different comprehensiveness ranges will allow the learners with diverse studying capabilities to follow the most appropriate learning content. The result of the tests. In an instruction course, some tests should be set to evaluate the performance of the learners. The result of tests is used in two ways. First, it may be used to determine whether the learners are good enough to skip some prerequisite knowledge. Second, the result is used to evaluate the learners
51

studying capacity. This may help the LMS to decide whether the content with more examples and detailed explanation should be served to learners. Following those rules, course developers may develop instruction courses without considering the LMS that they use. Through defining the content packaging file that conforms to the schema, they can freely design courses with different navigation paths, which will fit the requirements of different learners. Moreover, if the same content packaging schema is adopted by other systems, which may also interpret the rules defined in the packaging files, these instruction courses can be easily reused in those systems. In summary, the development of a reusable and adaptive e-Learning system involves two important parts. The first part is mainly concerned with learning content development, including a library of learning objects, metadata, content packaging file, and learner models. In the second part, it is necessary to establish a run-time environment for the learning materials. In this research, a Learning Management System is especially designed for our e-Learning system.

4.2 Learning Content Development

4.2.1 Idea and Principles behind Learning Content Development From its genesis, learning objects have been imagined to be something such as Lego pieces, which may be combined with each other freely. It is expected by some initiators that just as the Lego pieces can be assembled into an automobile and then reused to construct a castle, learning objects may be easily reused in different instruction structures. However, such a simplistic way of thinking about learning object will harm its practical use in the real-world environments. If the results from the combination of learning objects are not instructionally meaningful, the combination will fail no matter whether we get it automatically or manually.

52

A learning object is a small and reusable component that can be combined and recombined with other learning objects to form larger instruction courses. However, the combination of learning objects should be ruled by some outside laws. Actually, in this research, a learning object should be viewed as an atom, which, itself a combination of some smaller bits, such as neutrons, protons, and electrons, is still the basic component of any larger object. At the same time, the larger objects are formed only in some certain ways. Unlike Lego pieces, the combination of learning objects has its own features: Not every learning object is combinable with every other learning object. The reusability of a learning object may heavily depend on the way that this learning object is developed, or in another words, its internal structure. Learning objects can only be assembled in certain ways prescribed by some external structures. It is obvious that developing reusable learning objects and combining learning objects into different instructions require a deep understanding of instructional design and a careful arrangement of learning content. In this e-Learning system, we follow several rules for developing learning content: An instruction course incrementally introduces complexity in small, cognitively manageable learning objects. The structure of the course explicitly links and tailors concepts to justify different instruction objectives. The content packaging file is used to describe the interrelatedness and web-like nature among the learning objects. A learning object is created to explain or describe one core concept, which solves a real need in an instruction. The development of learning objects needs a careful design. It is desirable that learning objects themselves are complete, selfcontained, and roughly independent of the context. Therefore, each learning object may fulfil a certain instruction objective in any instruction context.

53

When a new course is developed, it is desirable to find appropriate learning objects from the existing library of learning objects. The course may adopt those learning objects directly or rebuild new learning objects based on the old ones.

4.2.2 Developing Learning Content This section gives a detailed description of how the schemas defined in Chapter 3 help to develop proper learning content for the e-Learning system. As discussed in the previous section, an instruction course should be presented in a structure that explicitly links and tailors concepts to fit for practical use. Figure 4.2 demonstrates such a structure for a tutorial course about the topic of encryption. In this diagram, each row represents a concept that may be explored in the tutorial. For each concept, one or several learning objects are developed. The connection between learning objects indicates which learning objects may be choose for the next step of the instruction from the current point. All learning objects in this tutorial can be divided into four parts. The first part includes some basic knowledge about mathematics. To understand how encryption works, every learner should be sure to know something about prime numbers, great common division, modulus function, and binary numbers. However, due to diverse backgrounds of different learners, it is not necessary for every learner to go through this part identically. In this case, a quiz is designed to examine whether the learners may skip the mathematic part. Anyone who passes the quiz may go directly to the next part, the introduction of encryption. The second part is an introduction about encryption. It includes a description of the history of encryption and some simple encryption methods. This part is the same for all learners. A quiz is also set to assess learners performance.

54

Figure 4.2 Course Structure for Encryption Tutorial The third part is the main component of this tutorial. It provides several alternative instruction sequences for learners with different requirements and backgrounds. The basic path of this instruction only involves four learning objects, the introduction of public key, the RSA algorithm, the examples of public key, and the advantage and disadvantage of public key. This means that for learners just having a minimal need for knowledge of

55

public key, they just get a brief description about what is public key and how to get it and use it. However, for the learners who want to acquire more advanced and professional knowledge, it is necessary for them to learn some detailed information about why the public key can work and how it really works. Such proof and explanation is included in several other learning objects, the learning objects about Euclidean algorithm, Euler phi function, and Euler-Fermat theorem. Moreover, since the content in those learning object is difficult to understand, it is possible that some learners may need more examples or explanation to master these concepts. Therefore, the learning objects series l2-m2-n2 is developed in parallel with the learning objects series l1-m2-n2 to sever the learners with weak studying capability. In part four, the alternative instruction sequences are developed following the same design idea as part three. Therefore, the tutorial is designed in such a way that learners will get different learning contents that is suitable for different requirements and backgrounds. 4.2.2.1 Developing Content Packaging File This section describes how the content packaging specification may be used to represent a tutorial shown in figure 4.2. As defined in Chapter 3, the <organization> element contains information about the particular, passive organization of the learning materials. It assumes a default hierarchical structure, such as is common with a tree view or structural representation of data. The hierarchical structure for this tutorial course can be determined by the order and nesting of the <item> elements, <testItem> elements, and <branches> elements contained within the <organization> element, similar to the figure 4.3. An LMS encountering this structural organization of the learning content could interpret it conceptually as figure 4.2 shows. The mechanism for referencing an <item> element's resource is the "identifierref" attribute, which is used to reference the learning object that should appear in this point.

56

Figure 4.3 Sample <organization> Element In the content packaging file, the <resources> element is used to identify a collection of learning objects and metadata. Individual learning objects are declared as a <resource> element nested within the <resources> element. A <resource> element may also have a <metadata> sub-element to reference the separate metadata file attached with this learning object. Figure 4.4 is an example of using < resources> element to include all learning objects for this encryption tutorial:

57

Figure 4.4 Sample <resources> Element To set a quiz in the course structure, the schema provides two ways to present it. The line 3 in figure 4.3 indicates a separate resource to provide a quiz at the beginning of the tutorial. This resource references an outside file, quiz.xml, which conforms to the IMS QTILite specification. In another case, lines 24 to 27 in figure 4.3 represent the way to form a quiz from the learning objects. Every learning object in this system has a <test> element, which includes several test items relevant to the concept of this learning object and follows the same specification, QTILite. Therefore, course developers can flexibly combine the test items in several learning objects to construct a quiz that covers several topics. In this example, the quiz includes the <test> elements from item002 to item005, which is the combination of all learning objects about mathematics. Such a quiz can be used to evaluate the learners performance in the mathematics part. In our system, the result of a quiz always influences the value in <eligibility> element of

58

learner profile documents. A score below 60% results in a downgrade of the learners studying capacity level, while a score above 80% leads to an upgrade. The <branch> element is optional and is allowed within <item> elements to indicate different paths in course structure. In each <branch> element, the <condition> element is defined to confine the requirement to this path. For example, figure 4.5 shows the prerequisite for the learners to get a minimal 80% in the quiz defined by item000 to go to this branch. This means that when the learners show a good grasp of mathematical knowledge, they may skip the mathematic part in this tutorial. For the same reason, figure 4.6 indicates that this branch presents a path whose difficulty level is below 2. This represents a content that just includes very basic or basic knowledge about public key.

Figure 4.5 Prerequisite for a Quiz

Figure 4.6 Difficulty Range for Learning Content In summary, the elements in the content packaging specification combine together to provide a way of describing a course structure including multiple paths. By interpreting

59

the information tagged by those elements and following the rules of choice, the LMS is able to select the appropriate learning objects for learners. 4.2.2.2 Developing Learning Objects and Metadata To make it possible to develop reusable learning objects, an XML schema for learning objects is designed, which was described in Chapter 3. The benefits of using this schema may be summarized as the follows: Provides a standard way to tag a learning object, which help it transfer among multiple platforms. Moreover, learning objects in XML can be flexibly transformed to a variety of forms, such as PDF or WML, based on standard style sheets. Makes it possible to extend the current schema by integrating additional standard XML languages, such as Mathematics Markup Language (MathML), or Synchronized Multimedia Integration Language (SMIL). In this research, the QTILite specification is imported, so the test items in learning objects may be developed conforming to available standard. Enhances the reusability of learning objects by supporting the feature of inheritance between learning objects. Designs a simple structure for learning objects, which help the course developers to develop self-contained and context-independent content. Provides a way to extract a part from learning objects. For example, the <test> elements in learning objects may be retrieved to form a separate quiz. Keeps learning objects in a consistent instruction style. Therefore, the learning objects may be easier to combine together. In this system, a learning object normally includes several <description> elements that are used to give a complete description of the core concept, and a <test> element that contain several test items to assess learners performance. Figure 4.7 shows a complete learning object, RSA.xml, with its basic elements.
60

Figure 4.7 Learning Object RSA.xml This learning object describes the basic knowledge about the RSA cryptosystem. It includes one <definition> element, several < description> elements, one <conclusion> element, and one <test> element. The three <description> elements explain three

61

dimensions of this concept: how the public key and private key work, what the RSA algorithm tries to do, and how to get both public key and private key through RSA algorithm. As figure 4.2 has described, for the same concept of RSA, two learning objects are developed. The second one, RSA1.xml, includes more information for high-level learners. Figure 4.8 presents the learning content in the second learning object. It is noted that the major parts in those two learning object are same. The second learning object just adds some new content to give deeper description about the steps to get public and private keys. Moreover, there is a different conclusion in the new learning object.

Figure 4.8 Learning Object RSA1.xml As indicated by the inheritance attribute, learning object RSA1.xml inherits learning content from RSA.xml. However in this learning object, the tag <description id="010201" reference="010105" status="integration"> indicates that the content in this element should be inserted behind the parent element, whose id is 010105 in RSA.xml. The combination of these two elements gives a deeper and more concrete explanation
62

about how the four steps to get public and private keys really work. Moreover, tag <conclusion id="010203" reference="010106" status="substitution"> indicates that the content in the current element substitutes the parent element whose id is 010106. By this way, the new learning object eliminates the conclusion in the parent one and adds a new one, which is more suitable for learners who require advanced knowledge.

Figure 4.9 Sample Metadata For each learning object, metadata is attached. Figure 4.9 represents the metadata for RSA1.xml. This metadata describe the basic features about this learning object, which
63

may be used as the basis for source retrieval. Moreover, the <relation> element in metadata defines the inheritance relationship between learning objects. This may be also used to trace the change of versions among the learning objects concerned with the same concept.

4.3 Design of the Learning Management System

4.3.1 Learning Management System A Learning Management System (LMS) is a single, integrated software tool based on standard technology platforms that will fit with the existing infrastructure of e-Learning. With the rapid growth of the Internet and the development of e-Learning technology standards, many designers of e-Learning system now use the term LMS to replace Computer Managed Instruction (CMI) so as to include new functionalities and capabilities not historically associated with CMI systems. The new features in LMS enable one to have more ability to assess, plan, deliver, manage, and improve e-Learning in a Web-based environment. With the open standards in place, a LMS developed by any organization can be used to handle learning materials from different resources. The term LMS can apply to very simple course management systems, or highly complex enterprise-wide distributed environments. However, the basic functions of a LMS can be summarized as follows: Select and tailor learning materials to meet learners needs; Establish learning path and sequence; Monitor and correspond with individual progress; Assign exercises and quizzes, and evaluate learners performance; Manage and update learner information; Integrate learning materials from multiple sources

64

4.3.2 Design of the LMS In this thesis, a specific Learning Management System is designed to provide a run-time environment for our e-Learning system. As figure 4.10 shows, the components that make up this LMS include six modules: Learning Management Module, Sequencing/Tracking Module, Testing/Assessment Module, Searching Module, Learner Profile Module, and Delivery Module. Every module provides some specific functionality. This section gives a brief description of how each module works and interacts with other modules.

Figure 4.10 LMS Modules

65

In general, the whole Learning Management System is developed based on servlets, which accept requests from a client (via the Web server), performs some tasks, and returns the results. These servlets implement the following functions: Verify the learners identification, and then load the learners background information; Check the current progress of the learner, load the content packaging file, and select the proper learning objects according to the learners need and performance; Transform learning content to the appropriate formats, such as HTML or PDF, by using some standard XSLT files; Load proper quizzes to evaluate learners performance; Update learners information along with learners performance.

4.3.2.1 Learning Management Module Learning Management Module is the central part of the LMS. It mainly contains a series of interfaces between the server and the client, and implements the basic functions that a server should provide. In order to get a better understanding of the details of this module, a brief knowledge about server and servlet is required. In the client/server architecture, the server manages the data resource: it stores, retrieves, and protects data. The services provided by conventional Web servers are mainly restricted to the delivery of files. For this reason, if more complex services are required, a powerful interface is needed between the actual application and the HTTP server. One of the basic interfaces is the Servlet API. Sun developed this application programming interface to provide Java programs on the server with a simple and flexible basis on which to run. Like CGI, the programmer can use the API to access environment variables and write the response to the request in a stream. In addition to that, the API provides cookie support and session management. It is left open whether the application on the server runs in the same process as the server or a different process.

66

In a nutshell the Learning Management Module is used to wait for client HTTP requests. When these requests arrive the module does whatever is needed to serve the requests by invoking the appropriate applications to provide the necessary content to the learners. Therefore the basic performance of this module includes the following functions: It provides an interface for the learners to log into the e-Learning system; When the status of learners is validated, the module sets up a session between the client and the server. Therefore, the system may begin to track the learners progress. Moreover, it also loads the content packaging file and the learners profile information for future use; When a request arrives from the learner, it checks and decides if a certain request belongs to another module. If so, it invokes the right module to handle this request; The result of every request is sent to the Delivery Module, where the XML documents are transformed into HTML documents and provided to the learner. 4.3.2.2 Sequencing/Tracking Module Most Web sites deliver content essentially one-way: from the server to the user. Occasionally information is entered by the user, for example when ordering something online, which is then posted back to the server. But for the most part, Web servers do not keep track of what the user is doing with the content until a specific request is made. However, an LMS, on the other hand, must track a learner progress, assess a learners performance, and then select the next appropriate learning content. This involves gathering learner profile information, monitoring key interactions and performance within the content and then determining what the student should next experience. This functionality is implemented by the Sequencing/Tracking Module. When the Sequencing/Tracking Module is invoked, it imports the content packaging file and gets the learners information from the Learner Profile Module. Based on the rules
67

defined in the content packaging file and learners information, the module will select the next appropriate learning objects. Every time such a selection is made, the learners profile information should be updated by Learner Profile Module. 4.3.2.3 Testing/Assessment Module The Testing/Assessment Module implements two functions: When a quiz is invoked, this module finds the proper quiz file or forms a quiz file dynamically from the learning objects <test> elements. Associated with this file, the quiz applet file is sent to the client side, which runs in the browser to show the quiz content. After the learner finishes the quiz, the result of the test is sent back to the LMS. After getting the test result, this module updates the learners profile information to include the result of the quiz. Moreover, the module changes the status of the learners studying capability according to the scores. 4.3.2.4 Search Module The Search Module provides a way for the system to find the appropriate learning objects by keywords. The course developers or learners can use this module to retrieve learning objects that they need for course design or learning. According to the keywords input by users, the module compares the keywords with the <keyword> elements in each learning objects and return a series of learning object that fit the requirement. 4.3.2.5 Learner Profile Module The Learner Profile Module keeps updating the learners progress and performance. This information may dynamically form a content menu for learners. Moreover, it also provides learner information to other modules that need the information to make a proper decision or choice.
68

4.3.2.6 Delivery Module The Delivery Module includes a set of standard XSL files, which transform the XML files into HTML files. Every time when some content needs to be presented to the learners, this module invokes the right XSL file for transformation. Therefore, the content can eventually appear in the right format on the browser of client side.

4.4 Summary
The major features of this e-Learning system can be summarized as follows: The whole system is developed based on reusable learning objects. The LMS always tries to find the appropriate learning objects for learners. The system can provide individually tailored learning content and process. The combination and sequencing of learning objects are accomplished and adjusted dynamically according to the learners performance and requirement. The learning objects can be reused in different instruction contexts. The learning content can be transformed to other forms of layout with standard style sheet files.

69

Chapter 5

Implementation of the E-Learning System

For the purpose of this thesis, an e-Learning system that provides online tutorials in Computer Science is developed. A library of learning objects forms the basis of this eLearning system. Four small courses are created manually by the author; each combines about twenty learning objects. Some learning objects are reused by different courses, demonstrating that a learning object may be embedded in different contexts. In order to adapt to the needs of individual students, some courses allow different instruction paths through the available learning content. A simple LMS is also developed to track the learners performance and provide the navigation from one learning object to another.

5.1 Learning Content Implementation Details

The learning materials in our research come from CMPT 371 projects, which require the students to create tutorial web sites that provide tutorial instruction about some fundamental concepts or common tasks or tools in Computer Science. Based on the tutorials developed by students, four new tutorials are developed, in which the topics cover encryption, firewall, network security, and e-Commerce. Figure 5.1, 5.2, 5.3 and 5.4 represent the course structures for the four tutorials. Each tutorial contains a dozen or so learning objects. Most of them mainly consist of text and images, which are used to explain some core concepts. Moreover, there is always a short test forming part of a learning object.

70

Figure 5.1 Course Structure for Encryption In this research, the first two tutorials, encryption and firewall, are designed to show how the course structure, which embeds the learning objects in each point, will provide personalized and adaptive course content according to the learners requirement and performance. In Chapter 4, the structure for the tutorial about encryption has been described in details. Similarly, the instruction structure for the firewall tutorial also used the three rules to differentiate the alternative learning paths.

71

Figure 5.2 Course Structure for Firewall The other two tutorials, network security and e-Commerce, were developed to illustrate that the learning objects may be reused in different contexts. As indicated in figure 5.3 and 5.4, for both of the two tutorials, several learning objects in the first two tutorials are reused. Some of the learning objects, such as client/server model, are reused directly in the new tutorial. Meanwhile, other learning objects are reused through inheritance. For example, the firewall learning object in e-Commerce, inherits content from the learning object in the firewall tutorial, and then adds some new features to explain the use of firewall in an e-Commerce environment.

72

Figure 5.3 Course Structure for Network Security In this e-Learning system, every learning object has associated metadata, which describes the content of the learning object. The course developers may use metadata to retrieve the proper learning objects that they want to use in a new course. A single content packaging file is established to encapsulate the four tutorials together, each <organization> element describing one tutorial course. This file includes all the required content resources, supporting information, and course structure information. By means of this structure the system can easily select those learning objects that are relevant to a given learner, e.g., if a

73

learner wants to learn some basic knowledge about encryption, the system will select the simplest instruction path about this topic for him/her.

Figure 5.4 Course Structure for E-Commerce

For every learner of this system, a learner model is established. When a learner is assigned an account and a password to access the system, the basic information about the learner is stored in the learner profile document. Figure 5.5 illustrates a sample learner profile document. It assigns the learners studying capability as medium. This value will change according to the learners performance in the quiz. This document also includes the information about what courses and the levels the learner would like to learn. When the learner begins studying, the system will use the learner model to record the learners learning progress and adjust the instruction path according to the learners performance.

74

Figure 5.5 Sample Learner Profile Information

5.2 Implementation of the Learning Management System

The Learning Management System is implemented using Java servlets, Java applets, Java applications, and a variety of HTML interfaces. The servlets respond to requests from client side and are responsible for selecting appropriate learning objects, serving the learner course menu and content, tracking learners performance and progress, and so on. 5.2.1 Environment of the Learning Management System Currently, a PC machine is used as a server for our e-Learning system, which installs Tomcat from Apache. Tomcat is a combination of JavaServer Page (JSP) 1.1 and Servlets 2.2 Reference Implementation, and may be used as a stand-alone server. All learning materials, metadata and useful tools are also stored in this server machine. When running Tomcat, the web pages under the Root directory of the server can be accessed from any
75

other machine through the IP address. The server provides the interface that interacts with the learner. The learner can use the interface to send requests to the server, and then the server evokes the proper servlets to handle the requests. Due to the need to process XML files, some tools are selected extensively from the Apache XML Project, which provides a series of commercial-quality standards-based XML solutions that are developed in an open and cooperative fashion. Apache XML Prject currently consists of seven sub-projects, each focusing on a specific aspect of XML. Two of them are used in this system to handle the XML files: Xerces - XML parsers in Java, which searches the XML file for special elements and attributes. Xalan - XSLT stylesheet processor in Java, which can transform XML file to HTML or other XML file. Both tools can be encapsulated to jar files. These jar files are placed under the lib directory of Tomcat, so that the servlets can use the classes in these files to parse and transform XML files. 5.2.2 The Basic Components of the Learning Management System All functionalities of the Learning Management System are built upon four Java applications that handle the four types of XML documents in this e-Learning system. These Java classed are described below: LearnerInfo.java This Java class is responsible for accessing information in the learner profile document. It may be used by several modules to read proper information about the learner or rewrite the learners profile information. LOParser.java

76

This class deals with learning objects. When a learning object inherits content from other learning objects, the class assembles the content from the current learning object with content from its parent learning objects to form a learning object that contains the complete content. Moreover, this class implements the functionality of extracting the <test> elements in learning objects to form a complete quiz. CPParser.java This class transforms the content packaging file into a tree structure for learning object retrieval. At each point, the class determines which learning object should be the next one for the learner based on the information from learner profile. MDParser.java This class is responsible for accessing information in metadata. It is used by Search Module to find the learning objects that includes the keywords required by the users. Based on these classes, the six modules discussed in Section 4.3.2 are implemented, which construct a complete e-Learning system. 5.2.3 Implementation of the Modules In this section, the implementation of six modules is described in details. 5.2.3.1 Implementation of the Learning Management Module This module includes the servlet registration file and the login interface for learners. Tomcat provides a way to register the servlet with a <servlet> element and a <servletmapping> element in the WEBAPP/ROOT/WEB-INF/web.xml file. The two elements define the name and initial params for the newly installed servlet and then optionally map this servlet to URI requests relative to some context. Therefore, the client may access the servlet via a URI similar to http://localhost:8080/Login, which invokes the WEBAPP/ROOT/WEB-INF/classes/LoginServlet.class file.

77

In this system, all servlets are registered in the web.xml file, so Tomcat always invokes the right servlet to response to the learners request. Moreover, the login.htm and LoginServlet.java files provide the interface for the learner to log in the system and then set up the session between the learner and LMS sever. Therefore, the learning management module establishes an environment in which other modules may work correctly. 5.2.3.2 Implementation of the Delivery Module The following four standard XSL style sheet files, loxsl.xsl, lomenu.xsl, mdxsl.xsl, and learnerInterface.xsl comprise the Delivery Module: loxsl.xsl Transform the learning objects to HTML files for presentation in the browser. lomenu.xsl Transform the record of the learners progress into a menu in HTML. mdxsl.xsl Transform the metadata to HTML files for presentation. learnerInterface.xsl Transform the learners profile information to HTML files. Through these XSL files, all XML files in this system may be transformed to the proper format to present before learners. Figure 5.6 represents the XSL file for learning objects. In this file, the elements in the learning objects are assigned to some templates, which define how the elements should be transformed. This standard way makes it possible for all learning objects to share the same XSL file for presentation.

78

Figure 5.6 XSL File for Learning Objects 5.2.3.3 Implementation of the Tracking/Sequencing Module This module is the most important one in the LMS, which implements the functionality to provide personalized learning content to the learners. It includes two following servlets: GetTutorial.java This servlet is invoked when the learner logs in the system. As figure 5.7 shows, this servlet generates an interface dynamically based on the learners profile information. This interface illustrates which tutorials the learner has chosen to learn, which tutorials have been finished, and which have not. Therefore, the learner may choose any tutorial to go on. Moreover, this interface provides links to revise the learners profile information and to search learning objects by keywords.
79

Figure5.7 System Interface GetContent.java This servlet selects the appropriate learning objects for the learner. It finds the next learning object that is especially suitable for the current learner and tracks the learners progress at the same time. Figure 5.8 presents the HTML page generated by this servlet. This page contains three frames. The top frame includes a navigation button to the next learning object. The left frame is a menu listing the content that the learner has gone through. It also maintains the results for each test the learner has taken. Therefore, it is

80

possible for the learner to go back to any learning objects or quiz to go over the previous learning content. The learning object is shown in the right frame in the format of HTML.

Figure 5.8 Learning Content In figure 5.8, the web page shows what the learner has learned for the tutorial about encryption. In this case, the learner skips the mathematics part because of his/her good performance in the first quiz. Also, the advanced level of knowledge is provided to fit the learners requirement, which includes the description about such thing as Euclidean algorithm and Euler Phi function.

81

5.2.3.4 Implementation of the Assessment/Testing Module This module contains an applet, quiz_applet.jar, and a servlet, QuizResults.java (the applet is adopted from Christopher Brooks work, [Brooks 2002]). When a quiz is necessary, the module sends the learner the applet and the quiz file that conforms to QTI. Figure 5.9 shows how the quiz appears at the learners side. After the learner finishes the quiz and submits the result, the servlet is invoked, which records the result into the learners profile document.

Figure 5.9 Quiz

82

5.2.3.5 Implementation of the Learner Profile Module When the learner goes through the instruction, this module records all learning objects the learner has learned. Figure 5.10 illustrates how the information about the learner is recorded in the <learningactivity> element of the profile document. The information in this element may be transformed into a menu through the lomenu.xsl file. The learner may also change his/her learning requirement in this module. Figure 5.11 illustrates the interface for changing learner information. The new selection will be saved to learner profile documents to replace the old one.

Figure 5.10 Records of Learning Activity

83

Figure 5.11 Changing Learner Information 5.2.3.6 Implementation of the Searching Module This module provides the interface used for searching learning objects. After the user inputs the keywords, the SearchLO.java servlet checks the metadata of learning objects and provides a list of learning objects that includes the input keywords. Figure 5.12 presents the result of searching for learning objects about RSA. The metadata are transformed into HTML by a standard XSL file, and provide detailed information about the learning objects. This module may be used to find the proper learning objects when the course developers begin to construct a new course.

84

Figure 5.12 Searching Results

5.3 System Testing

In this system, the reusability of learning objects was shown by the courses developed. The library included 68 learning objects, based on which four tutorial courses are

85

designed. These four tutorials used a total of 76 learning objects. This means that 8 learning objects were reused directly. Moreover, 10 learning objects were reused in an indirect way, with contents inherited by other learning objects. For example, the RSA1.xml inherits the content in RSA.xml and adds some new materials to form a learning object that includes knowledge suitable for high-level learners. To order to test whether this e-Learning system can provide individually tailored learning content, four learner profile documents were defined for a test of all tutorials, which separately represent Learner A, Learner B, Learner C and Learner D. While Learner A and Learner B always require the basic level learning content, Learner C and Learner D demand the advanced level knowledge. The study capability of the four learners is set to be medium. During the learning process, Learner B and Learner D always give the wrong answers for the quiz that they take, but Learner A and Learner C answer each quiz correctly. As a result, the system should change the learning paths of the learners according to their performance. To test the system in this manner, one computer was connected to the system through the IP address of the server. On this computer, four browsers were opened and each browser was used to represent one learner defined as A, B, C, or D. All of the four simulated learners went through the four tutorials and acted as described previously. The whole learning progress and performance of the learners were recorded in the learner profile documents, which were subsequently used to verify that the system works properly. Figure 5.13 shows the learning paths that the four learners went through for the encryption tutorial. Learner A performs well in the first quiz, so he skips the mathematical part. However, Learner B has to learn the mathematical knowledge, since he fails the first quiz. Moreover, the system just provides the basic knowledge to the two learners according to their requirement for low level knowledge. For Learner C and Leaner D, the system offers high level knowledge. Except for the difference in the mathematical part, the system chooses l2-m2-n2 for Learner D instead of l1-m1-n1, due to his bad performance in the previous quiz. Eventually, the two learners achieve the same learning

86

level, but with different learning content. Moreover, for the firewall tutorial in which multiple alternative paths are also available, the similar result was obtained. This test illustrates that the system can dynamically compose personalized learning content according to the learners requirement and performance.

Figure 5.13 Record of Learning Paths for the Encryption Tutorial

87

5.4 Conclusion
This section gave a detailed description of the implementation of the e-Learning system. It explained how the tutorials are developed based on reusable learning objects and how the functionalities of the Learning Management System are fulfilled. Moreover, a test was designed to illustrate that the system can provide individually tailored learning content.

88

Chapter 6 Conclusions 6.1 Summary of Thesis Work

E-Learning provides a mechanism for creating instruction courses based on reusable learning objects and supplying individually tailored learning content. The designing of an e-Learning system involves works about defining the granularity of learning objects and finding an effective way to retrieve and sequence learning objects. This thesis presents the detailed design and the implementation of a reusable and adaptive e-Learning system, which adopts XML as the basic framework. This research provides four XML schemas through which the development and organization of reusable learning content and the tracking of the learners progress can be realized. The schema for learning objects is established based on the new definition and features about learning objects summarized in the thesis. It provides a standard way to develop learning objects that may be reused in different instruction contexts. The metadata schema consists of the elements selected from the IMS Metadata Specification, which are combined together to describe and distinguish learning objects. To order to represent the structures of instruction courses, the content packaging schema is developed by adding new approaches, such as hierarchical branching and alternative learning paths, to the IMS Content Packaging Specification. Finally, the schema for learner profile is established to record the requirement, background and performance of learners. In this thesis, four online tutorial courses are designed to illustrate how these schemas can work together to make it possible to reuse learning objects in different learning contexts and to provide learners with individually tailored learning content. A Learning Management System is also developed to work as a run-time environment for course

89

delivery, which responds to the learners requests in the server side. This LMS implements a suite of functionalities designed to deliver, track, and search learning content, and record and manage learner progress and interactions.

6.2 Research Contributions

As a new instructional technology, learning objects have been predicted to succeed in the next generation of instruction design, development and delivery, due to the potential for reusability, adaptability, and flexibility. However, the great potential of learning objects will never be realized without the effort to adopt this technology to practical uses in instruction design areas, automatically or manually combining learning objects to facilitate learning. Currently, it is unlikely that there will be a global library of learning objects in near future. Therefore, a major contribution of this research is the demonstration that it is possible to develop a campus-wide or department-wide instructional e-Learning system based on learning objects for courseware design and delivery. The e-Learning system designed in this research illustrates the achievement of developing flexible, reusable, interoperable, and personalized learning content in a XML environment. Learning objects in this system are reused in different instruction context, and learners receive different learning content according to their requirement and performance. Moreover, this system can also be used to deal with any learning objects, metadata or course structures that follow the schemas defined in Chapter 3. This allows course developers to just focus on the development of learning content and the description of course structure without considering which Learning Management System they are using and how the instruction courses are delivered or presented during the learning process. The search functionality for retrieving learning objects based on metadata can also help the course developers to reuse learning objects when they are designing new instruction courses.

90

A second contribution of this research is that a new concept of learning objects is defined and a schema for learning objects is designed. This approach helps to solve the problem regarding the granularity of learning objects, which represents the trade-off between the possible benefits of reuse and expense of combination of learning objects. By defining learning objects in a precise way and confining one learning object to a core concept it is possible to develop learning objects that may stand alone as a collection of learning materials independent of course context and may be reused by different instruction courses. The schema for learning objects in this research represents the features of this new definition. It provides a simple structure for learning objects development. This standard way of tagging a learning object enhances its interoperability to transfer different platforms and its flexibility to be transformed to a variety of formats. Moreover, this schema is open to other standard XML languages and may import those languages whenever it is necessary. In this research, the importation of the QTILite specification brings the schema an advantage to develop the test items that may be reused by any system adopting IMS QTI specifications. A third contribution of this research is to provide a way to allow the simplified application of an instructional design mechanism to the learning object approach. The course structure is described by XML documents following content packaging schema, which use the nested elements and conditional branching to implement multiple learning sequences. This mechanism enables the system to deliver individually tailored learning content, which is an important function of e-Learning. Finally, this research provides a common ground for future research on learning objects. The library of learning objects in this research may be referenced and reused by other instruction courses in this department. It is also possible to further explore the role of XML in e-Learning based on the learning content and metadata that have been developed for this thesis.

91

6.3 Future Work

While this research is targeted at constructing four small simple tutorial courses to illustrate the possibility of reusing learning objects and providing individually tailored learning content, the ideas behind this e-Learning system are applicable well beyond tutorial instruction. Actually, a complete e-Learning system may provide a suite of mechanisms that can support efficient instruction design, development and delivery. Based on the current system and the schemas, it is possible to develop a more integrated and powerful e-Learning system, which may be used by the department for future instruction course development. To implement this, new work should be done, part of which may become potential future research topics. 6.3.1 Improving Search Functionality Searching the appropriate learning objects for course developers is the basic functionality an e-Learning system may provide to improve instruction development. When course developers begin to author a course, they normally have some significant information about the course. For example, it includes what the objective of the course is, what concepts or topics the course covers, what the education level is, and more. Then if the developers wish to add any resource to this course, they may use this information to conduct a highly selective search of resources. In such case, the e-Learning system should consults the repository of learning objects and runs a search based on metadata. In this research, the search functionality just supports the mechanism to retrieve learning objects from local repository by keywords. The limitation of this functionality is that it ignores potential reusable learning objects from other resources. It is more likely that the system needs to search an online learning objects repository, or sometimes try to find the resources widely distributed on websites around the world. It is necessary to implement the mechanism of retrieving learning objects from the Internet. Moreover, searching learning objects just by keywords impairs the accuracy of the retrieval result. Other features about the learning objects in the metadata, such as the classification or format of
92

the learning objects, should also be used as the basis for retrieval. The improvement of search functionality can make the process of instruction development more quick and efficient. 6.3.2 Generating Learning Objects from Databases or HTML files Today by far the most common medium for learning content is hypertext markup language (HTML), or some central databases containing huge amount of individual learning bits. The problem with these HTML pages is that they are not portable. When a web page designed for one course at one university is used or adapted by another course, the pages normally need to be redesigned. For the same reason, the leaning bits stored in one database is difficult to be accessed by other systems. Therefore, in order to reuse the huge learning resources from the Internet, it is necessary to generate learning objects from the currently existing HTML files and databases. With the schema for learning objects available, it is possible to automatically select learning bits from databases to form new learning objects. This approach needs an effort to study the relationship between database and XML schema. However, transforming HTML files to XML files will require more work. Currently, the web site of this department includes more than 50 tutorials in HTML that have been developed in past few years. Generating learning objects from these tutorials will greatly increase the library of learning objects, which may be useful for future instruction development. 6.3.3 Display Learning Objects with Different Formats Because learning objects are distributed as XML files, they may be displayed in a wide variety of formats. Each element in an XML file may be associated with an output format in the XSL file. Therefore combining the XML and XSL definitions the system may use one XSL file to produce an HTML page, another XSL file to produce a LATEX page, and yet a third XSL file to produce a PDF page. In this research, the only presentation format for learning object is HTML. There should be more XSL files, which may transform

93

learning objects to PDF or WML (Wireless Markup Language). This can fit with the learners requirement for the printable or wireless version of learning objects. 6.3.4 Expanding Content Packaging Schema and Learner Model Schema In the current content packaging schema, only three rules are used to distinguish alternative learning paths. However, for a department-wide e-Learning system that includes many instruction courses, more rules should be involved in content packaging schema. For example, the schema should be able to define that the course CMPT 115 needs to be finished before the course CMPT 250. The adding of new features to the content packaging schema requires the update of the Learning Management System. Accordingly, the learner model schema should be expanded to record more information about learners.

6.3.5 Developing Tools for Authoring Learning Objects and Content Packaging Files Since the schemas for learning objects and content packaging are complex, some tools should be designed to help course developers to handle those files. The tools may provide the functionality such as displaying the structure of learning objects and content packaging files in figures and allowing course developers to add new nodes in the structures freely. This mechanism not only accelerates the development of learning content, but also ensures the generated XML files conforming to the schemas.

6.4 Conclusion
This research has demonstrated that it is possible to build a reusable and adaptive eLeaning system based on learning objects and XML technologies. This system provides four tutorial courses, which illustrate the reuse of learning objects and the distribution of individually tailored learning content. Additional research should be done to make this system be used by the department for future course development and delivery.

94

References
[ADL 2002] Advanced Distributed Learning (ADL), 2002. http://www.adlnet.org/ (Accessed on Feb. 3, 2002) [Adolphe 2000] Adolphe, K.: Intelligent eLearning with XML. XML 2000, Washington, DC, December 3, 2000. [AICC 2002] Aviation Industry Computer-Based Training Committee, 2002.

http://www.aicc.org/ (Accessed on Feb. 3, 2002) [Berlund et al. 2000] Adler, S., Berglund, A., Caruso, J., Deach, S., Grosso, P., Gutentag, E., Milowski, A., Parnell S., Richman J. and Zilles, S.: Extensible Stylesheet Language (XSL) Version 1.0, 2000, Candidate Recommendation. http://www.w3.org/TR/xsl/ (Accessed on Feb. 7, 2000). [Bosak 1997] Bosak, J: XML, Java, and the future of the Web, 1997. http://www.ibiblio.org/pub/sun-info/standards/xml/why/xmlapps.htm (Accessed on July 5, 2001) [Box et al. 2000] Box, D., Skonnard, A. and Lam, J. (2000). Essential XML beyond markup. One Jacob Way, Reading, Massachusetts: Addison-Wesley. [Boyle 2000] Boyle, B.: Knowledge Extraction Using Semantic Metadata Mining. XML 2000, Washington, DC, December 3, 2000. [Brooks 2002] Brooks, C: IMS Question & Test Interoperability Implementation. Department of Computer Science, University of Saskatchewan. [CanCore] CanCore Initiative 2002. http://www.cancore.org (Accessed on Feb. 3, 2002)

95

[CC 2001] Computer Curriculum 2001. http://www.computer.org/education/cc2001/ (Accessed on October. 1, 2002) [Clayton 2000] Julian Clayton: Content Reuse for XML Based Courseware. XML 2000, Washington, DC, December 3, 2000. [Cover 2000] Cover, R.: The XML Cover Pages, 2000. http://www.oasis-open.org/cover (Accessed on Feb. 7, 2001) [Daniel 2001] Daniel, D.: (2001). Most Learning Objects Arent. www.NYUonline.com/vn_3/inside/articles/objects_arent.html (Accessed on Feb. 3, 2002) [DCMI 2002] Dublin Core Metadata Initiative (DCMI), 2002. http://dublincore.org/ (Accessed on Feb. 3, 2002) [Decker 2000] Stefan Decker: The Semantic Web: The roles of XML and RDF. IEEE Internet Computing, September/October 2000 (Vol. 4, No. 5), pp. 63-74 http://www.cs.vu.nl/~frankh/abstracts/IEEE-IC00.html (Accessed on July 5, 2001) [Downes 1998] Downs S. (1998): The future of online learning. http://www.atl.ualberta.ca/downes/future/home.html (Accessed on Feb. 7, 2001) [Downes 2001] Downs, S. (2001). Learning Objects. http://www.atl.ualberta.ca/downes/naweb/column000523.htm (Accessed on Feb. 1, 2002) [EML 2002] Educational Modelling Language (EML). (2002) http://eml.ou.nl/ (Accessed on October. 1, 2002)

96

[Fallside 2000] Fallside C.D.: XML Schema Recommendation, 24 October 2000 on Feb. 7, 2001).

Part 0: Primer Candidate

http://www.w3.org/TR/xmlschema-0/ (Accessed

[Feemster 2000] Feemster, R. (2000). The Future of Online Learning lies in Course Objects. University Business; 2000. http://www.universitybusiness.com/0007/merlot.html (Accessed on July 5, 2001) [Fox 2000] Geoffrey Fox: Shared places on the web: XML for Web-based Collaboration and Distance Education. XML Developers Conference, Montreal August 19-20, 1999. http://www.ibiblio.org/bosak/conf/xmldev99/fox.htm (Accessed on July 5, 2001) [Gerber 2001] Gerber, C. (2001). XML: New Formula for e-Learning. Federal Computer Week, Jan. 22, 2001. http://www.few.com/few/articles/2001/01/0122/tec-xml-01-2201.asp (Accessed on Feb. 7, 2001) [Gertner 2000] Matthew Gertner: Schema-Based Development: A New Paradigm for Web Application. XML 2000, Washington, DC, December 3, 2000. [Goldfarb and Prescod 2000] Goldfarb, F.C. and Prescod, P. (2000). The XML handbook, second edition. Upper Saddle River, NJ: Prentice Hall Inc. [IDC 2001] IDC White Paper (2001). The Learning Content Management System: A New e-Learning Market Segment Emerges. http:// www.wbtsystems.com/products/ whitepaper_request_idc.html (Accessed on Feb. 7, 2001) [IMS 2000] Instructional Management System (IMS). (2000). http://www.imsproject.org/ (Accessed on Feb. 7, 2001)

97

[IMS 2000a] Instructional Management System (IMS). (2000). IMS Content Packaging Best Practices and Implementation Guide. http://www.imsproject.org/content/packaging/index.html (Accessed on October. 1, 2002) [IMS 2000b] Instructional Management System (IMS). (2000). IMS Learner information Best Practices and Implementation Guide. http://www.imsproject.org/profiles/index.html (Accessed on October. 1, 2002) [IMS 2000c] Instructional Management System (IMS). (2000). IMS Learning Resource Meta-data Best Practices and Implementation Guide. http://www.imsproject.org/metadata/index.html (Accessed on October. 1, 2002) [IMS 2000d] Instructional Management System (IMS). (2000). IMS Question & Test Best Practices and Implementation Guide. http://www.imsproject.org/question/index.cfm (Accessed on October. 1, 2002) [Jamlan 2001] Jamlan, M. (2001) A Critique of Stephen Downs Article, Learning Objects; A Perspective from Bahrain. International Review of Open and Distance Learning: 2(1). http://www.icaap.org/iuicode?149.2.1.12 (Accessed on Feb. 3, 2002) [Klassen 2000] Klassen, P. (2000). Architectures for Learning Objects Repositories. TeleLearning 2000; Toronto Ontario. [Klein et al. 2000] M. Klein, D. Fensel, F. van Harmelen, and I. Horrocks: The relation between ontologies and schema-languages: Translating OIL-specifications in XMLSchema. In Proceedings of the Workshop on Applications of Ontologies and Problemsolving Methods, 14th European Conference on Artificial Intelligence ECAI'00, Berlin, Germany August 20-25, 2000. http://www.cs.vu.nl/~mcaklein/KIRMIT/ (Accessed on Feb. 3, 2002).

98

[Lin 2001] Lin, F.O. (2001) A Critique of Stephen Downs Article, Learning Objects; A Chinese Perspective. International Review of Open and Distance Learning: 2(1), July, 2001. http://www.icaap.org/iuicode?149.2.1.8 (Accessed on Feb. 3, 2002) [Longmire 2001] Longmire, W. (2001). A Primer on Learning Objects. Managing WebBased Training (ASTD, 1999). http://www.learningcircuits.org/mar2000/primer.html#bio (Accessed on Feb. 3, 2002) [LTSC 2002] Learning Technology Standards Committee (LTSC), 2002. http://ltsc.ieee.org/ (Accessed on Feb. 3, 2002) [McClure 1995] McClure, C. (1995). Model-Driven Software Reuse: Practicing Reuse Information Engineering Style. http://www.reusability.com/papers2.html (Accessed on Oct. 20, 2001) [McLaughlin 2000] McLaughlin, B. (2000): Java and XML. Cambridge, Mass: O'Reilly. [Nauer et al. 2000] Nauer, E., Hulou, R. and Napoli, A.: What can XML do for textual information retrieval on the WEB? 2000. 101-114 [Morrison 2000] Michael Morrison: Unleash the Power of XML, Sams Publishing, 2000. [Pemberton 2000] Pemberton, S.: XHTML-1.0: The Extensible HyperText Markup Proceedings of the 7th International Workshop on Knowledge Representation meets Databases (KRDB 2000), Berlin, Germany, August 21,

Language- A Reformulation of HTML 4 in XML 1.0. 2000, Recommendation. http://www.w3.org/TR/xhtml1/ (Accessed on Feb. 7, 2000) [Shata 2001] Shata, O. (2001) A Critique of Stephen Downs Article, Learning Objects; A Middle Eastern Perspective. International Review of Open and Distance Learning: 2(1), July,2001. http://www.icaap.org/iuicode?149.2.1.8.3 (Accessed on Feb. 3, 2002)

99

[Shepherd 2001] Shepherd, C. (2001). Objects of Interests. http://www.fastrakconsulting.co.uk/tactix/features/objects/objects.htm (Accessed on July 5, 2001) [Smith and Poulte 1999] Howard Smith and Kevin Poulte: The Role of Shared Ontology in XML-Based Trading Architectures. Communications of the ACM (CACM), Volume 42, 1999. http://www.ontology.org/main/papers/cacm-agents99.html (Accessed on Nov. 30, 2000) [Walsh 1998] Walsh, N: A Technical Introduction to XML, October 03, 1998. http://www.xml.com/pub/a/98/10/guide0.html (Accessed on July 5, 2001) [Wiley 2000] Wiley, D. A. (2000). Learning Object Design Sequencing Theory. Doctoral Dissertation. Brigham Young University: department of Psychology and Instructional Technology [Wiley 2001] Wiley, D. A. (2001). Connecting Learning Objects to Instructional Design Theory: Definition, a Metaphor, and Taxonomy. Digital Learning Environment Research Group. Utah State University. [Wiley et al. 2001] Wiley, Gibson, Recker (2001). Reformulation of the Issue of Learning Object Granularity and its Implication for the Design of Learning Object. http://reusability.org/granularity.pdf (Accessed on Feb. 3, 2002) [XML 2000] Extensible Markup Language (XML) 1.0 (Second Edition), W3C Recommendation 6 October 2000. http://www.w3.org/TR/REC-xml (Accessed on July 5, 2001)

100

Appendix A: Schema for Learning Objects <?xml version="1.0" encoding="UTF-8"?> <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified" xmlns:qtil = "http://www.imsproject.org/xsd/ims_qtil_rootv1p1"> <xs:import schemaLocation="ims_qtil_rootv1p1.xsd" namespace="http://www.imsproject.org/xsd/ims_qtil_rootv1p1" /> <xs:element name="learningObject" type="learningObjectType"/> <xs:simpleType name="multimedia" final="restriction"> <xs:restriction base="xs:string"> <xs:enumeration value="sound"/> <xs:enumeration value="image"/> <xs:enumeration value="video"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="statusType" final="restriction"> <xs:restriction base="xs:string"> <xs:enumeration value="substitution"/> <xs:enumeration value="integration"/> <xs:enumeration value="connection"/> </xs:restriction> </xs:simpleType> <xs:complexType name="learningObjectType"> <xs:choice minOccurs="0" maxOccurs="unbounded"> <xs:element name="title" minOccurs="0"> <xs:complexType> <xs:simpleContent> <xs:extension base="xs:string"> <xs:attribute name="id" type="xs:string" use="required"/> <xs:attribute name="reference" type="xs:string" use="optional"/> <xs:attribute name="status" type="statusType" use="optional"/> </xs:extension> </xs:simpleContent> </xs:complexType> </xs:element> <xs:element name="definition" type="contentType" minOccurs="0"/> <xs:element name="description" type="contentType" minOccurs="0" maxOccurs="unbounded"/> <xs:element name="example" type="exampleType" minOccurs="0" maxOccurs="unbounded"/>
101

<xs:element name="application" type="xs:anyURI" minOccurs="0"/> <xs:element name="conclusion" type="contentType" minOccurs="0"/> <xs:element name="exercise" type="testType" minOccurs="0"/> <xs:element name="test" type="testType" minOccurs="0"/> </xs:choice> <xs:attribute name="inheritance" type="xs:anyURI" use="optional"/> </xs:complexType> <xs:complexType name="contentType"> <xs:choice minOccurs="0" maxOccurs="unbounded"> <xs:element name="head" type="xs:string" minOccurs="0"/> <xs:element name="paragraph" type="paragraphType" minOccurs="0" maxOccurs="unbounded"/> <xs:element name="media" type="mediaType" minOccurs="0" maxOccurs="unbounded"/> <xs:element name="example" type="exampleType" minOccurs="0" maxOccurs="unbounded"/> <xs:element name="code" type="codeType" minOccurs="0" maxOccurs="unbounded"/> <xs:element ref="table" minOccurs="0" maxOccurs="unbounded"/> <xs:element name="list" type="listType" minOccurs="0" maxOccurs="unbounded"/> </xs:choice> <xs:attribute name="id" type="xs:string" use="required"/> <xs:attribute name="reference" type="xs:string" use="optional"/> <xs:attribute name="status" type="statusType" use="optional"/> </xs:complexType> <xs:complexType name="listType"> <xs:choice> <xs:element ref="ul" minOccurs="0" maxOccurs="unbounded"/> <xs:element ref="ol" minOccurs="0" maxOccurs="unbounded"/> <xs:element ref="dl" minOccurs="0" maxOccurs="unbounded"/> </xs:choice> </xs:complexType> <xs:complexType name="exampleType"> <xs:choice minOccurs="0" maxOccurs="unbounded"> <xs:element name="head" type="xs:string" minOccurs="0"/> <xs:element name="paragraph" type="paragraphType" minOccurs="0" maxOccurs="unbounded"/> <xs:element name="media" type="mediaType" minOccurs="0" maxOccurs="unbounded"/> <xs:element name="code" type="codeType" minOccurs="0" maxOccurs="unbounded"/> <xs:element ref="table" minOccurs="0" maxOccurs="unbounded"/> <xs:element name="list" type="listType" minOccurs="0" maxOccurs="unbounded"/> </xs:choice>

102

<xs:attribute name="id" type="xs:string" use="required"/> <xs:attribute name="reference" type="xs:string" use="optional"/> <xs:attribute name="status" type="statusType" use="optional"/> </xs:complexType> <xs:complexType name="paragraphType" mixed="true"> <xs:sequence> <xs:any processContents="skip" maxOccurs="unbounded"/> </xs:sequence> </xs:complexType> <xs:complexType name="codeType" mixed="true"> <xs:sequence> <xs:any processContents="skip" maxOccurs="unbounded"/> </xs:sequence> </xs:complexType> <xs:complexType name="mediaType"> <xs:choice minOccurs="0" maxOccurs="unbounded"> <xs:element name="text" type="xs:string" minOccurs="0" maxOccurs="unbounded"/> </xs:choice> <xs:attribute name="type" type="multimedia" use="required"/> <xs:attribute name="mimeType" type="xs:string" use="required"/> <xs:attribute name="uri" type="xs:anyURI" use="required"/> </xs:complexType> <xs:complexType name="testType" mixed="true"> <xs:sequence minOccurs="0" maxOccurs="1"> <xs:element name="questestinterop" type="qtil:questestinteropType"/> </xs:sequence> <xs:attribute name="id" type="xs:string" use="required"/> <xs:attribute name="reference" type="xs:string" use="optional"/> <xs:attribute name="status" type="statusType" use="optional"/> </xs:complexType> <xs:attributeGroup name="id"> <xs:attribute name="id" type="xs:ID"/> </xs:attributeGroup> <xs:attributeGroup name="class"> <xs:attribute name="class" type="xs:NMTOKENS"/> </xs:attributeGroup> <xs:attributeGroup name="title"> <xs:attribute name="title" type="xs:string"/> </xs:attributeGroup> <xs:attributeGroup name="Core.attrib"> <xs:attributeGroup ref="id"/> <xs:attributeGroup ref="class"/> <xs:attributeGroup ref="title"/> </xs:attributeGroup> <xs:attributeGroup name="BIDI"/>

103

<xs:attribute name="dir"> <xs:simpleType> <xs:restriction base="xs:NMTOKEN"> <xs:enumeration value="ltr"/> <xs:enumeration value="rtl"/> </xs:restriction> </xs:simpleType> </xs:attribute> <xs:attributeGroup name="I18n.attrib"> <xs:attributeGroup ref="BIDI"/> </xs:attributeGroup> <xs:attributeGroup name="Common.attrib"> <xs:attributeGroup ref="Core.attrib"/> <xs:attributeGroup ref="I18n.attrib"/> </xs:attributeGroup> <xs:attributeGroup name="dt.attlist"> <xs:attributeGroup ref="Common.attrib"/> </xs:attributeGroup> <xs:complexType name="dt.type" mixed="true"> <xs:attributeGroup ref="dt.attlist"/> </xs:complexType> <xs:element name="dt" type="dt.type"/> <xs:attributeGroup name="dd.attlist"> <xs:attributeGroup ref="Common.attrib"/> </xs:attributeGroup> <xs:complexType name="dd.type" mixed="true"> <xs:attributeGroup ref="dd.attlist"/> </xs:complexType> <xs:element name="dd" type="dd.type"/> <xs:attributeGroup name="dl.attlist"> <xs:attributeGroup ref="Common.attrib"/> </xs:attributeGroup> <!---> <xs:group name="dl.content"> <xs:sequence> <xs:element ref="dt"/> <xs:element ref="dd"/> </xs:sequence> </xs:group> <!---> <xs:complexType name="dl.type" mixed="true"> <xs:group ref="dl.content" maxOccurs="unbounded"/>

104

<xs:attributeGroup ref="dl.attlist"/> </xs:complexType> <!---> <xs:element name="dl" type="dl.type"/> <!---> <xs:attributeGroup name="li.attlist"> <xs:attributeGroup ref="Common.attrib"/> </xs:attributeGroup> <!---> <xs:complexType name="li.type" mixed="true"> <xs:attributeGroup ref="li.attlist"/> </xs:complexType> <!---> <xs:element name="li" type="li.type"/> <!---> <xs:attributeGroup name="ol.attlist"> <xs:attributeGroup ref="Common.attrib"/> </xs:attributeGroup> <!---> <xs:complexType name="ol.type"> <xs:sequence> <xs:element ref="li"/> </xs:sequence> <xs:attributeGroup ref="ol.attlist"/> </xs:complexType> <!---> <xs:element name="ol" type="ol.type"/> <!---> <xs:attributeGroup name="ul.attlist"> <xs:attributeGroup ref="Common.attrib"/>

105

</xs:attributeGroup> <!---> <xs:complexType name="ul.type"> <xs:sequence> <xs:element ref="li" maxOccurs="unbounded"/> </xs:sequence> <xs:attributeGroup ref="ul.attlist"/> </xs:complexType> <!---> <xs:element name="ul" type="ul.type"/> <xs:attributeGroup name="CellHAlign.attrib"> <xs:attribute name="align"> <xs:simpleType> <xs:restriction base="xs:NMTOKEN"> <xs:enumeration value="left"/> <xs:enumeration value="center"/> <xs:enumeration value="right"/> </xs:restriction> </xs:simpleType> </xs:attribute> </xs:attributeGroup> <!---> <xs:attributeGroup name="CellVAlign.attrib"> <xs:attribute name="align"> <xs:simpleType> <xs:restriction base="xs:NMTOKEN"> <xs:enumeration value="top"/> <xs:enumeration value="middle"/> <xs:enumeration value="bottom"/> </xs:restriction> </xs:simpleType> </xs:attribute> </xs:attributeGroup> <!---> <xs:attributeGroup name="scope.attrib"> <xs:attribute name="align"> <xs:simpleType> <xs:restriction base="xs:NMTOKEN">

106

<xs:enumeration value="row"/> <xs:enumeration value="col"/> </xs:restriction> </xs:simpleType> </xs:attribute> </xs:attributeGroup> <!---> <xs:attributeGroup name="table.attlist"> <xs:attributeGroup ref="Common.attrib"/> </xs:attributeGroup> <!---> <xs:group name="table.content"> <xs:sequence> <xs:element ref="caption" minOccurs="0"/> <xs:element ref="tr" maxOccurs="unbounded"/> </xs:sequence> </xs:group> <!---> <xs:complexType name="table.type"> <xs:group ref="table.content"/> <xs:attributeGroup ref="table.attlist"/> </xs:complexType> <xs:element name="table" type="table.type"/> <!---> <xs:attributeGroup name="caption.attlist"> <xs:attributeGroup ref="Common.attrib"/> </xs:attributeGroup> <!---> <xs:complexType name="caption.type" mixed="true"> <xs:attributeGroup ref="caption.attlist"/> </xs:complexType> <!---> <xs:element name="caption" type="caption.type"/> <!--

107

--> <xs:attributeGroup name="tr.attlist"> <xs:attributeGroup ref="Common.attrib"/> <xs:attributeGroup ref="CellHAlign.attrib"/> <xs:attributeGroup ref="CellVAlign.attrib"/> </xs:attributeGroup> <!---> <xs:group name="tr.content"> <xs:choice maxOccurs="unbounded"> <xs:element ref="th"/> <xs:element ref="td"/> </xs:choice> </xs:group> <!---> <xs:complexType name="tr.type"> <xs:group ref="tr.content"/> <xs:attributeGroup ref="tr.attlist"/> </xs:complexType> <!---> <xs:element name="tr" type="tr.type"/> <!---> <xs:attributeGroup name="th.attlist"> <xs:attributeGroup ref="Common.attrib"/> <xs:attribute name="headers" type="xs:IDREFS"/> <xs:attributeGroup ref="scope.attrib"/> <xs:attribute name="rowspan" type="xs:int" use="optional" default="1"/> <xs:attribute name="colspan" type="xs:int" use="optional" default="1"/> <xs:attributeGroup ref="CellHAlign.attrib"/> <xs:attributeGroup ref="CellVAlign.attrib"/> </xs:attributeGroup> <!---> <xs:complexType name="th.type" mixed="true"> <xs:attributeGroup ref="th.attlist"/> </xs:complexType> <!--

108

--> <xs:element name="th" type="th.type"/> <!---> <xs:attributeGroup name="td.attlist"> <xs:attributeGroup ref="Common.attrib"/> <xs:attribute name="headers" type="xs:IDREFS"/> <xs:attributeGroup ref="scope.attrib"/> <xs:attribute name="rowspan" type="xs:int" use="optional" default="1"/> <xs:attribute name="colspan" type="xs:int" use="optional" default="1"/> <xs:attributeGroup ref="CellHAlign.attrib"/> <xs:attributeGroup ref="CellVAlign.attrib"/> </xs:attributeGroup> <!---> <xs:complexType name="td.type" mixed="true"> <xs:attributeGroup ref="td.attlist"/> </xs:complexType> <!---> <xs:element name="td" type="td.type"/> </xs:schema>

109

Appendix B: Schema for Content Packaging <?xml version="1.0"?> <xsd:schema targetNamespace="http://www.imsglobal.org/xsd/imscp_v1p1" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:x="http://www.w3.org/XML/1998/namespace" xmlns="http://www.imsglobal.org/xsd/imscp_v1p1" elementFormDefault="unqualified" > <xsd:import namespace="http://www.w3.org/XML/1998/namespace" schemaLocation="ims_xml.xsd"/> <xsd:annotation> <xsd:documentation>Attribute Declarations</xsd:documentation> </xsd:annotation> <!-- **************************** --> <!-- ** Attribute Declarations ** --> <!-- **************************** --> <xsd:attributeGroup name="attr.base"> <xsd:attribute ref="x:base" use="optional"/> </xsd:attributeGroup> <xsd:attributeGroup name="attr.default"> <xsd:attribute name="default" type="xsd:IDREF" use="optional"/> </xsd:attributeGroup> <xsd:attributeGroup name="attr.href"> <xsd:attribute name="href" use="optional"> <xsd:simpleType> <xsd:restriction base="xsd:anyURI"> <xsd:maxLength value="2000"/> </xsd:restriction> </xsd:simpleType> </xsd:attribute> </xsd:attributeGroup> <xsd:attributeGroup name="attr.href.req"> <xsd:attribute name="href" use="required"> <xsd:simpleType> <xsd:restriction base="xsd:anyURI"> <xsd:maxLength value="2000"/> </xsd:restriction> </xsd:simpleType> </xsd:attribute> </xsd:attributeGroup> <xsd:attributeGroup name="attr.identifier.req"> <xsd:attribute name="identifier" type="xsd:ID" use="required"/> </xsd:attributeGroup>
110

<xsd:attributeGroup name="attr.identifier"> <xsd:attribute name="identifier" type="xsd:ID" use="optional"/> </xsd:attributeGroup> <xsd:attributeGroup name="attr.isvisible"> <xsd:attribute name="isvisible" type="xsd:boolean" use="optional"/> </xsd:attributeGroup> <xsd:attributeGroup name="attr.parameters"> <xsd:attribute name="parameters" use="optional"> <xsd:simpleType> <xsd:restriction base="xsd:string"> <xsd:maxLength value="1000"/> </xsd:restriction> </xsd:simpleType> </xsd:attribute> </xsd:attributeGroup> <xsd:attributeGroup name="attr.identifierref"> <xsd:attribute name="identifierref" use="optional"> <xsd:simpleType> <xsd:restriction base="xsd:string"> <xsd:maxLength value="2000"/> </xsd:restriction> </xsd:simpleType> </xsd:attribute> </xsd:attributeGroup> <xsd:attributeGroup name="attr.identifierref.req"> <xsd:attribute name="identifierref" use="required"> <xsd:simpleType> <xsd:restriction base="xsd:string"> <xsd:maxLength value="2000"/> </xsd:restriction> </xsd:simpleType> </xsd:attribute> </xsd:attributeGroup> <xsd:attributeGroup name="attr.resourcetype.req"> <xsd:attribute name="type" use="required"> <xsd:simpleType> <xsd:restriction base="xsd:string"> <xsd:maxLength value="1000"/> </xsd:restriction> </xsd:simpleType> </xsd:attribute> </xsd:attributeGroup> <xsd:attributeGroup name="attr.structure.req"> <xsd:attribute name="structure" use="optional" default="hierarchical"> <xsd:simpleType> <xsd:restriction base="xsd:string">

111

<xsd:maxLength value="200"/> </xsd:restriction> </xsd:simpleType> </xsd:attribute> </xsd:attributeGroup> <xsd:attributeGroup name="attr.version"> <xsd:attribute name="version" use="optional"> <xsd:simpleType> <xsd:restriction base="xsd:string"> <xsd:maxLength value="20"/> </xsd:restriction> </xsd:simpleType> </xsd:attribute> </xsd:attributeGroup> <xsd:annotation> <xsd:documentation>element groups</xsd:documentation> </xsd:annotation> <xsd:group name="grp.any"> <xsd:annotation> <xsd:documentation>Any namespaced element from any namespace may be included within an &quot;any&quot; element. The namespace for the imported element must be defined in the instance, and the schema must be imported. </xsd:documentation> </xsd:annotation> <xsd:sequence> <xsd:any namespace="##other" processContents="strict" minOccurs="0" maxOccurs="unbounded"/> </xsd:sequence> </xsd:group> <!-- ************************** --> <!-- ** Element Declarations ** --> <!-- ************************** --> <xsd:element name="branch" type="branchType"/> <xsd:element name="branches" type="branchesType"/> <xsd:element name="condition" type="conditionType"/> <xsd:element name="dependency" type="dependencyType"/> <xsd:element name="file" type="fileType"/> <xsd:element name="item" type="itemType"/> <xsd:element name="manifest" type="manifestType"/> <xsd:element name="metadata" type="metadataType"/> <xsd:element name="organization" type="organizationType"/> <xsd:element name="organizations" type="organizationsType"/> <xsd:element name="resource" type="resourceType"/> <xsd:element name="resources" type="resourcesType"/> <xsd:element name="schema" type="schemaType"/> <xsd:element name="schemaversion" type="schemaversionType"/> <xsd:element name="title" type="titleType"/>

112

<!-- ******************* --> <!-- ** Complex Types ** --> <!-- ******************* --> <!-- **************** --> <!-- ** dependency ** --> <!-- **************** --> <xsd:complexType name="dependencyType"> <xsd:sequence> <xsd:group ref="grp.any"/> </xsd:sequence> <xsd:attributeGroup ref="attr.identifierref.req"/> <xsd:anyAttribute namespace="##other" processContents="strict"/> </xsd:complexType> <!-- ********** --> <!-- ** file ** --> <!-- ********** --> <xsd:complexType name="fileType"> <xsd:sequence> <xsd:element ref="metadata" minOccurs="0"/> </xsd:sequence> <xsd:attributeGroup ref="attr.href.req"/> <xsd:anyAttribute namespace="##other" processContents="strict"/> </xsd:complexType> <!-- ********** --> <!-- ** item ** --> <!-- ********** --> <xsd:complexType name="conditionType"> <xsd:sequence> <xsd:element name="difficulty" type="rangeType" minOccurs="0"/> <xsd:element name="semanticdensity" type="rangeType" minOccurs="0"/> <xsd:element name="prerequirement" type="prerequirementType" minOccurs="0"/> </xsd:sequence> </xsd:complexType> <xsd:complexType name="rangeType"> <xsd:sequence> <xsd:element name="min" type="xsd:integer" minOccurs="0"/> <xsd:element name="max" type="xsd:integer" minOccurs="0"/> </xsd:sequence> </xsd:complexType> <xsd:complexType name="prerequirementType"> <xsd:sequence> <xsd:element name="min" type="xsd:int" minOccurs="0"/> <xsd:element name="max" type="xsd:int" minOccurs="0"/> </xsd:sequence> <xsd:attributeGroup ref="attr.identifierref"/>

113

<xsd:anyAttribute namespace="##other" processContents="strict"/> </xsd:complexType> <xsd:complexType name="testItemType"> <xsd:sequence> <xsd:element name="beginItem" type="xsd:string" minOccurs="0"/> <xsd:element name="endItem" type="xsd:string" minOccurs="0"/> </xsd:sequence> <xsd:attributeGroup ref="attr.identifier.req"/> <xsd:attributeGroup ref="attr.identifierref"/> <xsd:attributeGroup ref="attr.isvisible"/> <xsd:anyAttribute namespace="##other" processContents="strict"/> </xsd:complexType> <xsd:complexType name="itemType"> <xsd:choice minOccurs="0" maxOccurs="unbounded"> <xsd:element ref="title" minOccurs="0"/> <xsd:element ref="item" minOccurs="0" maxOccurs="unbounded"/> <xsd:element name="testItem" type="testItemType" minOccurs="0" maxOccurs="unbounded"/> <xsd:element ref="branches" minOccurs="0"/> <xsd:element ref="metadata" minOccurs="0"/> </xsd:choice> <xsd:attributeGroup ref="attr.identifier.req"/> <xsd:attributeGroup ref="attr.identifierref"/> <xsd:attributeGroup ref="attr.isvisible"/> <xsd:attributeGroup ref="attr.parameters"/> <xsd:anyAttribute namespace="##other" processContents="strict"/> </xsd:complexType> <xsd:complexType name="branchType"> <xsd:choice maxOccurs="unbounded"> <xsd:element ref="condition" minOccurs="0"/> <xsd:element name="testItem" type="testItemType" minOccurs="0" maxOccurs="unbounded"/> <xsd:element ref="item" minOccurs="0" maxOccurs="unbounded"/> </xsd:choice> <xsd:attributeGroup ref="attr.identifier.req"/> <xsd:attributeGroup ref="attr.identifierref"/> <xsd:attributeGroup ref="attr.isvisible"/> <xsd:attributeGroup ref="attr.parameters"/> <xsd:anyAttribute namespace="##other" processContents="strict"/> </xsd:complexType> <xsd:complexType name="branchesType"> <xsd:sequence> <xsd:element ref="branch" minOccurs="0" maxOccurs="unbounded"/> </xsd:sequence> <xsd:attributeGroup ref="attr.identifier.req"/> <xsd:attributeGroup ref="attr.identifierref"/>

114

<xsd:attributeGroup ref="attr.isvisible"/> <xsd:attributeGroup ref="attr.parameters"/> <xsd:anyAttribute namespace="##other" processContents="strict"/> </xsd:complexType> <!-- ************** --> <!-- ** manifest ** --> <!-- ************** --> <xsd:complexType name="manifestType"> <xsd:sequence> <xsd:element ref="metadata" minOccurs="0"/> <xsd:element ref="organizations"/> <xsd:element ref="resources"/> <xsd:element ref="manifest" minOccurs="0" maxOccurs="unbounded"/> </xsd:sequence> <xsd:attributeGroup ref="attr.identifier.req"/> <xsd:attributeGroup ref="attr.version"/> <xsd:attribute ref="x:base"/> <xsd:anyAttribute namespace="##other" processContents="strict"/> </xsd:complexType> <!-- ************** --> <!-- ** metadata ** --> <!-- ************** --> <xsd:complexType name="metadataType"> <xsd:sequence> <xsd:element ref="schema" minOccurs="0"/> <xsd:element ref="schemaversion" minOccurs="0"/> <xsd:group ref="grp.any"/> </xsd:sequence> <xsd:attributeGroup ref="attr.href"/> </xsd:complexType> <!-- ******************* --> <!-- ** organizations ** --> <!-- ******************* --> <xsd:complexType name="organizationsType"> <xsd:sequence> <xsd:element ref="organization" minOccurs="0" maxOccurs="unbounded"/> </xsd:sequence> <xsd:attributeGroup ref="attr.default"/> <xsd:anyAttribute namespace="##other" processContents="strict"/> </xsd:complexType> <!-- ****************** --> <!-- ** organization ** --> <!-- ****************** --> <xsd:complexType name="organizationType"> <xsd:choice maxOccurs="unbounded"> <xsd:element ref="title" minOccurs="0"/>

115

<xsd:element ref="item" minOccurs="0" maxOccurs="unbounded"/> <xsd:element name="testItem" type="testItemType" minOccurs="0" maxOccurs="unbounded"/> <xsd:element ref="metadata" minOccurs="0"/> </xsd:choice> <xsd:attributeGroup ref="attr.identifier.req"/> <xsd:attributeGroup ref="attr.structure.req"/> <xsd:anyAttribute namespace="##other" processContents="strict"/> </xsd:complexType> <!-- *************** --> <!-- ** resources ** --> <!-- *************** --> <xsd:complexType name="resourcesType"> <xsd:sequence> <xsd:element ref="resource" minOccurs="0" maxOccurs="unbounded"/> </xsd:sequence> <xsd:attributeGroup ref="attr.base"/> <xsd:anyAttribute namespace="##other" processContents="strict"/> </xsd:complexType> <!-- ************** --> <!-- ** resource ** --> <!-- ************** --> <xsd:complexType name="resourceType"> <xsd:sequence> <xsd:element ref="metadata" minOccurs="0"/> <xsd:element ref="file" minOccurs="0" maxOccurs="unbounded"/> <xsd:element ref="dependency" minOccurs="0" maxOccurs="unbounded"/> </xsd:sequence> <xsd:attributeGroup ref="attr.identifier.req"/> <xsd:attributeGroup ref="attr.resourcetype.req"/> <xsd:attributeGroup ref="attr.base"/> <xsd:attributeGroup ref="attr.href"/> <xsd:anyAttribute namespace="##other" processContents="strict"/> </xsd:complexType> <!-- ****************** --> <!-- ** Simple Types ** --> <!-- ****************** --> <!-- ************ --> <!-- ** schema ** --> <!-- ************ --> <xsd:simpleType name="schemaType"> <xsd:restriction base="xsd:string"> <xsd:maxLength value="100"/> </xsd:restriction> </xsd:simpleType> <!-- ******************* -->

116

<!-- ** schemaversion ** --> <!-- ******************* --> <xsd:simpleType name="schemaversionType"> <xsd:restriction base="xsd:string"> <xsd:maxLength value="20"/> </xsd:restriction> </xsd:simpleType> <!-- *********** --> <!-- ** title ** --> <!-- *********** --> <xsd:simpleType name="titleType"> <xsd:restriction base="xsd:string"> <xsd:maxLength value="200"/> </xsd:restriction> </xsd:simpleType> </xsd:schema>

117

Appendix C: Schema for Metadata <?xml version="1.0" encoding="UTF-8"?> <xsd:schema targetNamespace="http://www.imsglobal.org/xsd/imsmd_v1p2" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.imsglobal.org/xsd/imsmd_v1p2"> <xsd:attributeGroup name="attr.type"> <xsd:attribute name="type" use="optional" default="URI"> <xsd:simpleType> <xsd:restriction base="xsd:string"> <xsd:enumeration value="URI"/> <xsd:enumeration value="TEXT"/> </xsd:restriction> </xsd:simpleType> </xsd:attribute> </xsd:attributeGroup> <xsd:element name="context" type="contextType"/> <xsd:element name="description" type="descriptionType"/> <xsd:element name="difficulty" type="difficultyType"/> <xsd:element name="educational" type="educationalType"/> <xsd:element name="format" type="formatType"/> <xsd:element name="general" type="generalType"/> <xsd:element name="identifier" type="xsd:string"/> <xsd:element name="interactivitytype" type="interactivitytypeType"/> <xsd:element name="keyword" type="keywordType"/> <xsd:element name="langstring" type="langstringType"/> <xsd:element name="language" type="xsd:string"/> <xsd:element name="learningresourcetype" type="learningresourcetypeType"/> <xsd:element name="location" type="locationType"/> <xsd:element name="lom" type="lomType"/> <xsd:element name="technical" type="technicalType"/> <xsd:element name="title" type="titleType"/> <!-- ******************* --> <!-- ** Complex Types ** --> <!-- ******************* --> <xsd:complexType name="contextType"> <xsd:sequence> <xsd:element ref="langstring" maxOccurs="unbounded"/> </xsd:sequence> </xsd:complexType> <xsd:complexType name="descriptionType"> <xsd:sequence> <xsd:element ref="langstring" maxOccurs="unbounded"/>
118

</xsd:sequence> </xsd:complexType> <xsd:complexType name="difficultyType"> <xsd:sequence> <xsd:element ref="langstring" maxOccurs="unbounded"/> </xsd:sequence> </xsd:complexType> <xsd:complexType name="educationalType" mixed="true"> <xsd:sequence> <xsd:element ref="interactivitytype" minOccurs="0"/> <xsd:element ref="learningresourcetype" minOccurs="0" maxOccurs="unbounded"/> <xsd:element ref="context" minOccurs="0" maxOccurs="unbounded"/> <xsd:element ref="difficulty" minOccurs="0"/> </xsd:sequence> </xsd:complexType> <xsd:complexType name="generalType" mixed="true"> <xsd:sequence> <xsd:element ref="identifier" minOccurs="0"/> <xsd:element ref="title" minOccurs="0"/> <xsd:element ref="language" minOccurs="0" maxOccurs="unbounded"/> <xsd:element ref="description" minOccurs="0" maxOccurs="unbounded"/> <xsd:element ref="keyword" minOccurs="0" maxOccurs="unbounded"/> </xsd:sequence> </xsd:complexType> <xsd:complexType name="interactivitytypeType"> <xsd:sequence> <xsd:element ref="langstring" maxOccurs="unbounded"/> </xsd:sequence> </xsd:complexType> <xsd:complexType name="keywordType"> <xsd:sequence> <xsd:element ref="langstring" maxOccurs="unbounded"/> </xsd:sequence> </xsd:complexType> <xsd:complexType name="langstringType"> <xsd:simpleContent> <xsd:extension base="xsd:string"> <xsd:attribute name="lang" type="xsd:language"/> </xsd:extension> </xsd:simpleContent> </xsd:complexType> <xsd:complexType name="learningresourcetypeType"> <xsd:sequence> <xsd:element ref="langstring" maxOccurs="unbounded"/> </xsd:sequence>

119

</xsd:complexType> <xsd:complexType name="locationType"> <xsd:simpleContent> <xsd:extension base="xsd:string"> <xsd:attributeGroup ref="attr.type"/> </xsd:extension> </xsd:simpleContent> </xsd:complexType> <xsd:complexType name="lomType"> <xsd:sequence> <xsd:element ref="general" minOccurs="0"/> <xsd:element ref="technical" minOccurs="0"/> <xsd:element ref="educational" minOccurs="0"/> </xsd:sequence> </xsd:complexType> <xsd:complexType name="technicalType" mixed="true"> <xsd:sequence> <xsd:element ref="format" minOccurs="0" maxOccurs="unbounded"/> <xsd:element ref="location" minOccurs="0" maxOccurs="unbounded"/> </xsd:sequence> </xsd:complexType> <xsd:complexType name="titleType"> <xsd:sequence> <xsd:element ref="langstring" maxOccurs="unbounded"/> </xsd:sequence> </xsd:complexType> <!-- ****************** --> <!-- ** Simple Types ** --> <!-- ****************** --> <xsd:simpleType name="formatType"> <xsd:restriction base="xsd:string"/> </xsd:simpleType> </xsd:schema>

120

Appendix D: Schema for Learner Information <?xml version="1.0" encoding="UTF-8"?> <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified" attributeFormDefault="unqualified"> <xsd:element name="learnerinformation" type="learnerinformationType"/> <xsd:element name="accessibility" type="accessibilityType"/> <xsd:element name="goal" type="goalType"/> <xsd:element name="goals" type="goalsType"/> <xsd:element name="description" type="descriptionType"/> <xsd:element name="reference" type="xsd:string"/> <xsd:element name="priority" type="xsd:string"/> <xsd:element name="status" type="xsd:string"/> <xsd:element name="activity" type="activityType"/> <xsd:element name="learningactivity" type="learningactivityType"/> <xsd:element name="address" type="addressType"/> <xsd:element name="eligibility" type="xsd:string"/> <xsd:element name="preference" type="preferenceType"/> <xsd:element name="email" type="emailType"/> <xsd:element name="gender" type="genderType"/> <xsd:element name="identification" type="identificationType"/> <xsd:element name="name" type="nameType"/> <xsd:complexType name="addressType"/> <xsd:complexType name="genderType"> <xsd:sequence/> <xsd:attribute name="gender" use="required"> <xsd:simpleType> <xsd:restriction base="xsd:string"> <xsd:enumeration value="M"/> <xsd:enumeration value="F"/> <xsd:enumeration value="NA"/> </xsd:restriction> </xsd:simpleType> </xsd:attribute> </xsd:complexType> <xsd:complexType name="nameType"> <xsd:sequence> <xsd:element name="langstring" type="xsd:string" minOccurs="0"/> </xsd:sequence> </xsd:complexType> <xsd:complexType name="identificationType"> <xsd:sequence> <xsd:element ref="name"/> <xsd:element ref="address"/>
121

<xsd:element ref="email"/> <xsd:element ref="gender"/> </xsd:sequence> </xsd:complexType> <xsd:complexType name="goalType"> <xsd:sequence> <xsd:element ref="reference"/> <xsd:element ref="priority"/> <xsd:element ref="status"/> </xsd:sequence> </xsd:complexType> <xsd:complexType name="goalsType"> <xsd:sequence> <xsd:element name="goal" type="goalType" maxOccurs="unbounded"/> </xsd:sequence> </xsd:complexType> <xsd:complexType name="descriptionType"> <xsd:sequence> <xsd:element name="langstring" type="xsd:string" minOccurs="0"/> </xsd:sequence> </xsd:complexType> <xsd:complexType name="referenceType"> <xsd:sequence> <xsd:element name="langstring" type="xsd:string" minOccurs="0"/> </xsd:sequence> </xsd:complexType> <xsd:complexType name="priorityType"> <xsd:sequence> <xsd:element name="langstring" type="xsd:string" minOccurs="0"/> </xsd:sequence> </xsd:complexType> <xsd:complexType name="statusType"> <xsd:sequence> <xsd:element name="langstring" type="xsd:string" minOccurs="0"/> </xsd:sequence> </xsd:complexType> <xsd:complexType name="activityType"> <xsd:sequence> <xsd:element ref="status"/> <xsd:element ref="learningactivity"/> </xsd:sequence> </xsd:complexType> <xsd:complexType name="learningactivityType"> <xsd:sequence> <xsd:element name="item" type="xsd:string" minOccurs="0" maxOccurs="unbounded"/>

122

</xsd:sequence> </xsd:complexType> <xsd:complexType name="accessibilityType"> <xsd:sequence> <xsd:element ref="eligibility"/> </xsd:sequence> </xsd:complexType> <xsd:complexType name="preferenceType"> <xsd:sequence> <xsd:element name="langstring" type="xsd:string" minOccurs="0"/> </xsd:sequence> </xsd:complexType> <xsd:complexType name="eligibilityType"> <xsd:sequence> <xsd:element name="langstring" type="xsd:string" minOccurs="0"/> </xsd:sequence> </xsd:complexType> <xsd:complexType name="learnerinformationType"> <xsd:sequence> <xsd:element ref="identification" minOccurs="0"/> <xsd:element ref="accessibility" minOccurs="0"/> <xsd:element ref="goals" minOccurs="0" maxOccurs="unbounded"/> <xsd:element ref="activity" minOccurs="0"/> </xsd:sequence> </xsd:complexType> <xsd:simpleType name="emailType"> <xsd:restriction base="xsd:string"/> </xsd:simpleType> </xsd:schema>

123