COURSE CONTENT AUTHORING AND

SEQUENCING USING XML

by

BILLY BROOKS YORK, B.S.

A THESIS

IN

COMPUTER SCIENCE

Submitted to the Graduate Faculty of Texas Tech University in

Partial Fulfillment of the Requirements for

the Degree of

MASTER OF SCIENCE

Approved

/

August, 1999

l^ ^ ACKNOWLEDGEMENTS

m /lO' /^^ I would like to thank each of my committee members: Dr. Bharti Temkin and Dr.

^ ^ ' Terence Ahem. Their help was invaluable in this research. I would like to extend my

deepest gratitude to my chairperson. Dr. Nancy Van Cleave. Her help and support has

taught me many things and made me a better person.

I would also like to thank my family and my fiance for all of their love and

support. Without their help, none of this would have been possible. Lastly, I would like

to thank God, without whom none of this would have been possible.

11

TABLE OF CONTENTS

ACKNOWLEDGEMENTS ii

ABSTRACT vii

LIST OF FIGURES vih

CHAPTER

L INTRODUCTION 1

1.1 Overview 1

1.2 Introduction to Educational Issues 2

1.3 Educational Resources 3

1.3.1 Money 3

1.3.2 Computers 4

1.4 Classroom Software 5

1.4.1 Creating Educational Software 5

1.4.2 Classroom Software is Static 5

1.5 The Internet 6

1.5.1 Open Systems 6

1.5.2 Proprietary Systems 6

1.5.3 Pros and Cons of Open and Proprietary Systems 7

1.5.4 The Internet is an Open System 8

1.5.5 The Internet as an Educational Tool 8

1.5.6 Internet Instructional Standards 9

1.6 Summary of Educational Issues 10

iii

II. CURRENT RESEARCH 12

2.1 An Overview of Commercial Authoring Tools 12

2.2WebCT 13

2.3 Non-Commercial Authoring Tools 14

2.4 Significance of this Work 15

m. COMPUTER ASPECTS 17

3.1 Introduction 17

3.2 Requirements Definition 18

3.3 Overview of Solution 19

3.4 Document Type Definition 20

3.4.1 What is a Document Type Definition? 20

3.4.2 Prototype of "Syllabus.dtd" 21

3.5 Extensible Markup Language (XML) 22

3.6 Java 24

3.7 Justification for Using Java 24

3.8 Statement of Work to Accomplish 24

IV. ALGORITHMS 26

4.1 Introduction 26

4.2 General Algorithms 26

4.3 Refined Algorithms 28

4.3.1 Create Lesson 28

4.3.2 Edit Lesson 32

4.3.3 Merge Lesson 34

IV

4.3.4 View Lesson 35

V. IMPLEMENTATION ISSUES 38

5.1 Introduction 38

5.2 Java Related Issues 38

5.2.1 The Authoring Tool as a Java Application or Applet 38

5.2.2 File Filters 38

5.2.3 Data Structure 39

5.2.4 Initializing the Current Node 40

5.3 Java Applet Issues 41

5.3.1 Loading Files 41

5.3.2 Internet Explorer and Netscape 42

VL CONCLUSIONS 43

6.1 Showing Feasibility 43

VII. FUTURE WORK 45

7.1 Introduction 45

7.2 Usability Study 45

7.3 User Interface Improvement 46

7.4 Creating a Student View Lesson 46

7.5 A Possible Alternative to the View Lesson 46

7.6 Scheme for Delivery of Material 49

7.7 Dynamic Structures 49

BIBLIOGRAPHY 51

APPENDLX

A. GLOSSARY 53

B. SAMPLE SOURCE CODE 55

VI

ABSTRACT

For a variety of reasons, classroom computers in our public schools are not being

utilized to the fullest extent possible. In an effort to provide more accessible software, in

this work we explore the feasibility of using an open systems model to develop course

authoring applications. These programs may be used by educators to produce tutorials

quickly and simply at little or no cost. As educator gathers all files and URLs which are

to be part of the tutorials, and organizes them using the authoring software. This is

accomplished using a Document Type Definition (DTD) to define a series of rules for a

direct instructional model based on Gagne's Nine Events of Instruction. We then

developed a Java application which may be used to produce tutorial files based on the

DTD in Extensible Markup Language (XML) format. We then produced a Java applet

which may be used to view the tutorial files.

We met our goal of showing the feasibility of using an open system model with a

protocol for course authoring software. In addition, our programs form a complete

system for creating, editing, and storing tutorials. Beyond this, they are also inexpensive,

produce cross-platform tutorials, and provide a GUI to aid in ease of use.

vu

LIST OF FIGURES

3.1 "Syllabus.dtd" 22

3.2 A tree showing a possible file using "Syllabus.dtd" 23

4.1 Main Menu 27

4.2 Creating a Lesson with Add Enabled 29

4.3 Creating a Lesson with Presentation, Practice, and Performance Enabled 30

4.4 Allowing the User to Enter a URL or Filename 31

4.5 Allowing the User to Select a Local File 31

4.6 Saving a File 32

4.7 Opening a File 33

4.8 Editing a File 33

4.9 Merge Menu 34

4.10 Viewing a Local File 36

4.11 Viewing a URL 37

7.1 An XML File 48

7.2 XML File in IE 5.0 48

VlU

CHAPTER I

INTRODUCTION

1.1 Overview

Using Computers for the delivery of instructional material should be an excellent

match of technology to education. There are countless products currently on the market

that deliver instructional material via computers, yet little of it is being utilized in

America's classrooms. Several factors may account for this including cost, lack of

flexibility in the software, start up learning curves, and limited classroom usefulness.

Using the Internet to deliver instructional material is becoming increasingly

popular. The Internet provides access to vast amounts of information, however Internet-

based instructional tools must still direct the learner through the material to some extent

or the acquisition of content suffers.

There are two possible designs for any computer-based instructional tool; they

may be either proprietary or open. The first is based on a proprietary or closed system

software approach. Using this design, only the group implementing the product,

application, or system has total knowledge of the inner workings of the software and

generally does not release these to the public at large. This generally prevents third party

vendors from developing add-ons or extensions to the system.

The other approach to the development of instructional tools is based on an open

system model. The exciting aspect of using this model is that the protocols and data

representations used are publicly published and are thus available to all parties. This

allows anyone to develop a tool that can utilize a specific protocol, which in turn may

extend the usefulness of the system.

This research investigates the feasibility of developing a protocol for course

authoring tools using Extensible Markup Language (XML). We first developed a general

and flexible protocol, then produced a course authoring application utilizing it.

We have shown using an open system for the development of authoring tools is

feasible and very promising. We have also shown that it is feasible to develop such tools

based on an open system model. It is our hope that such an open systems idea will grow,

begin to enrich education, and help educators everywhere.

1.2 Introduction to Educational Issues

The technological revolution in education began in the early eighties with the

advent of the Apple computer by Steve Jobs and Steve Wozniak. Since then, technology

has gained momentum and led to changes in almost every aspect of our daily lives.

Computers are an integral part of this revolution and have been a dominant factor

in the spread of technology. Owing to their potential as learning tools, computers have

been proclaimed the next cure-all for most of the problems confronting K-12 educators

today. However, with all of the time and money spent on technology in our schools,

should not the majority of eighth graders do more than just write papers on computers

[DE 97]?

In spite of all the funds that have been and will be spent on educational

technology there does not appear to be many effective software applications targeted for

classrooms that utilize the Internet. With the currently evolving Internet instructional

standards for education moving toward an extremely complex model, it does not appear

there will be many in the future either. To fill the gap caused by this lack of educational

software and standards, we have written a curriculum and course authoring application

geared toward K-12 educators which allows them to author their own computer based

lessons and distribute them to other educators. This application is based upon the

concept that such an authoring tool should be inexpensive, simple to use, allow

modification of lesson content, and produce lessons which can be presented across

various computer platforms. Most importantly, it is based upon an open systems model.

1.3 Educational Resources

1.3.1 Money

As every taxpayer knows, the United States earmarks a vast amount of money for

education every year. This money includes funds from federal, state, and local agencies

as well as the private sector. Much of this money is used for the everyday functions of a

school, but politicians and others are pushing for the use of technology in the classroom.

For example, the Telecommunications Act of 1996 provided deep discounts to make

Internet access affordable to schools and libraries. "The [Clinton] Administration also

increased its investment in educational technology (computers, software, teacher training)

from $23 million in 1993 to over $700 million in 1998" [Wh99, p. 3]. With this much

money at stake, it becomes very important to find the best ways to utilize the technology

being acquired in our classrooms.

1.3.2 Computers

There exists an underlying framework of hodgepodge and legacy computers that

have already been purchased. "In 1995, the average public school contained 72

computers" [DE 98, p. 2]. Obviously a significant amount of money has already been

spent on existing computer systems. The number of computers in our schools continues

to increase. "The number of U.S. students for every instructional multimedia computer

dropped from 21 in 1997 to 13 in 1998" [Je 98, p. 1]. Considering the large number of

computers already in the classroom as well as computers to be added in the future, it is

important to understand the variety of platforms used in schools.

Common sense and casual observation leads to the conclusion that the current

makeup of technology in the classroom is a hodgepodge at best. "Ann Arbor's recent

Technology Bond ($10 milhon) paid entirely for Macs. Many U.S. schools are now

purchasing Wintel [PC based] machines, making schools probably the largest truly multi-

platform, Mac and Wintel, market" [So 98, p. 12]. To further illustrate the non-uniform

nature of classroom computers, in 1998, 45 percent of all computers in public schools

were classified as a multimedia computer [Je 98]. This implies the otner 55 percent of

the computers currently in school classrooms and labs cannot play a CD-ROM. However,

even though some of these systems are older, they still function and thus should be

utilized, if possible.

1.4 Classroom Software

1.4.1 Creating Classroom Software

Properly utilized, computers and other technologies inherently improve learning,

[CI 85] but no one is making money in educational software. It is basic economirs:

prices are high because they must reflect the costs for developing good educational

software [So 98]. One reason why educational software costs so much is a development

issue. Such software basically contains two parts: the content and the delivery system or

engine. Most commercial software, games for example, are built upon a preexisting

engine. The content is designed, then added to the presentation engine which may be

tweaked to allow for new advances in technology. This separation of content from

delivery system is an important concept because the reuse of code decreases development

time. With decreased development time comes a decrease in cost of the finished software

product. However, with educational software the content and the engine must be written

nearly from scratch every time. This is due to the fact that currently there is no

educational engine. And since educational software does not generate a profit, no one is

bothering to develop such an engine.

1.4.2 Classroom Software is Static

Demand for educational software is low because schools are choosing not to

spend their funds on software [So 98]. This is because the content of most courses is

always evolving, but software packages are currently static and usually focus only on one

subject area. This means current instructional software's content cannot be changed as

the course changes. Soloway states that due to the unmodifiable nature of the software,

an educator might spend their entire budget for a CD which then may be used

infrequently, or they can choose to spend the money on a book which can be used all

year. To quote Soloway, educators are forced to ask, "How does that snazzy CD tie to

the curriculum, which ties to the state standards, which ties to the state tests, which ties to

the textbook?" [So 98, p. 13].

1.5 The Internet

1.5.1 Open Systems

An open system is one in which it is possible for various types of computers to

exchange information due to public standardized interfaces. "Open systems are

characterized by the fact that their key interfaces are published" [CoDoKi 94, p. 16]. An

interface can simply be thought of as a definition of certain data types and how they are

stored. A standard is a commonly accepted way of doing a particular task. The process

by which an interface becomes a public standard is through the request for comment

process (RFC). Using this process a new standard is proposed and after lengthy

discussion by the computing community, it is either formally accepted or rejected. If it is

accepted, developers can be assured systems will support it, thus making communication

easier between disparate systems.

1.5.2 Proprietarv Svstems

The opposite of an open system is a proprietary system. This is a system that is

completely self contained, and all the interfaces work only on the specific machines for

which they were designed. It is difficult to develop third party software for proprietary

systems since the inner workings of proprietary systems are not generally shared with the

public.

1.5.3 Pros and Cons of Open and Proprietary Svstems

Both open systems and proprietary systems have advantages and disadvantages,

and some of the main ones are highhghted in Table 1.1 [KaGil^Se 98]. Each has

something to offer but for education, scalability, cost, and simpler functionality are very

important. Scalability allows a system to grow as needed without much change to the

overall system design. The simpler functionality of open systems allows more people to

have access to the system due to its uncomplicated nature.

Table 1.1: Advantages and Disadvantages of Open and Proprietary Systems

Functionality

Administration tools

Scalability

Cost

Open Systems

Current standards push interoperability and simplicity, not features. Typically done by editing configuration files.

The Internet was designed from the beginning to be large and scalable.

Generally requires less server and system administration support.

Proprietary System '

Typically offer a much richer feature set.

Typically offer nice graphic tools.

Generally not very scalable.

Typically requires a lot of server and system administration support.

Note: Advantage (^)

Source: IBM Systems Journal, J. Von Kanel

1.5.4 The Internet is an Open System

The framers of the Internet originally intended for the Internet to remain open so

information can be relayed between hosts on different transport systems by a host on both

transport systems [Po82]. The "Internet was based on the idea that there would be

multiple independent networks of rather arbitrary design, beginning w ith the

ARPANET..." [ISOC 98, p. 4]. It is this open system concept of a variety of computers

interconnected on a variety of networks that gives the Internet many of its inherent

strengths, especially since the interfaces are published. Public interfaces are crucial

because computer systems are all very different: computers are not created equal. A Cray

supercomputer is different in both hardware and the software which runs on it from a

Wintel machine. And both of these machines are different from a Macintosh.

Fortunately, due to well established protocols and standards, they have the ability to

communicate with each other. This ability is facilitated by the Internet's openness

through each machine's published interface.

1.5.5 The Internet as an Educational Tool

Used correctly the Internet can provide a great medium for delivering information

to students. Eighty-five percent of K-12 schools are connected to the Internet and the

majority of educators are more likely to use the Internet as a source of information than

as a tool for communication [DE 98]. This shows educators are willing to use the

Internet as a powerful resource for collection of information.

The fact the Internet allows access to vast quantities of information cannot be

questioned. However, this deluge of information may overwhelm a user, especially if

that user is a student attempting to learn specific material. According to Edwards and

Hardman, the Internet can provide a means for sending information to potential students,

but the Internet is too broad and inhibits the user from learning [EdHa 89]. This is

because the Internet does not restrict students to the content material. They are able to

follow links in a dynamic rather than linear fashion, allowing students to get lost or

sidetracked. This is not a negative aspect from a recreational viewpoint, but it is

detrimental when trying to focus on specific facts or concepts in a limited amount of

time.

1.5.6 Internet Instructional Standards

Many people are currently working to set standards for educational instruction

over the Internet, since such standards are essential for further development of Internet-

based instruction. The standards currently proposed involve how learning materials

should be developed, with key emphasis on the Internet as the delivery medium. A major

problem with all of these proposed standards is they violate the underlying principle of

openness in the Internet. One very good example is the set of standards proposed by

EDUCOM/NLII [EDU 98]. These standards consist of 295 pages in an early release

version that is complicated and dependent upon proprietary technology. Other

organizations besides EDUCOM, for example IEEE, are considering standards based on

proprietary technology as well. Should any of these proprietary standards be adopted, it

will make it more difficult for developers to create products which conform to the

standards. This is partially due to the nature of proprietary systems and also due to the

complexity of the standards.

1.6 Summary of Educational Issues

Educational issues are very important to many people. These issues are not only

concerned with the future of the nation; they also involve the way tax money is spent. A

problem surrounding technology is that currently it is viewed as requiring replacement

every few years to keep it useful. This planned obsolescence makes countless systems

that have already been purchased outdated, while in reality these systems are still useful

for a wide variety of educational tasks.

Another problem with educational software is no one is making money writing it,

so the impetus for innovation from developers is lacking. This is because most

educational software packages must be developed from scratch. Further, the demand for

educational software is low since it is not modified easily to adapt to individual

classrooms.

The open system of the Internet is an alternative to commercial proprietary

systems for instructional delivery. The Internet is preferable over proprietary systems

which require a specific set of hardware to make them useful. An open system by

definition has public interfaces which allows greater diversity in hardware. Both of these

systems have advantages and disadvantages, but the advantages of scalability, cost, and

simpler functionality that open systems provide are very important in education.

The Internet owes much of its inherent strength to its open system design. It is a

great medium for finding information, but one problem from an instructional view is the

10

Internet is so broad it tends to inhibit users from learning due to the hypertext

environment. Some people are working to set standards for the delivery of educational

information, but most of these standards are very complicated and violate the underlying

principles of the Internet.

Educational issues are very complex and extremely important because the future

of a nation depends on the education of its citizens.

11

CHAPTER n

CURRENT RESEARCH

2.1 An Overview of Commercial Authoring Tools

Various conmiercial authoring tools are available, but as Soloway pointed out

there is very little profit in educational software. In fact, many authoring tools are no

longer supported by the companies that created them. Macromedia's Authorware once

retailed for several thousand dollars in the mid 1990's, but now the company no longer

supports this software. Claris Corporation's HyperCard once retailed for several hundred

dollars in the mid 1990's, but it too is no longer supported.

Why are these once successful products no longer supported? A key problem is

these authoring tools were unable to incorporate and adapt to rapid technological change.

Authorware did not have support for the Internet, while HyperCard did not even support

color when it was dropped from the products supported by Claris Corporation.

Another authoring environment, HyperStudio, was first marketed by Roger

Wagner Publishing in 1978. As of 1999, HyperStudio retailed for $199.95 for a single

user license. HyperStudio was designed by a teacher and uses constructivist design

methodologies. Constructivism is the idea that students learn best by doing. HyperStudio

revolves around allowing the student to create and present instructional material.

HyperStudio supports most of the current technological innovations including

video and digital cameras. It also provides a means of publishing finished lessons to the

Internet through the use of plug-ins for web browsers.

12

Personal observation in the classroom confirms that Microsoft's PowerPoint is

extremely popular for the delivery of instructional material. One reason for this is

PowerPoint allows for rapid development of material. PowerPoint also supports many of

the same components and has the same look and feel other Microsoft products have,

allowing for a short learning curve and ensuring PowerPoint always supports the newest

technology. While PowerPoint is popular, it should be noted that it was not designed to

be a course authoring environment. PowerPoint does not require or force any structure in

a presentation, neither does it allow any other educational activities such as online testing

or discussions.

2.2 WebCT

WebCT, currently the official tool used by Texas Tech University, is an extremely

popular Internet authoring tool. The Computer Science department at the University of

British Columbia developed WebCT, headed by faculty member Murray W. Goldberg.

WebCT allows course designers to include components such as online discussion

groups and online testing, as well as many other features found in education using a

direct instructional model. In this model instructional design is linear in nature.

Components for the lesson are placed in order of the expected use, and there is no

branching allowed in the lesson.

All of the material from WebCT is accessed from any web browser. WebCT is

free for use in development, but a user license must be purchased for course delivery.

The fee for this license is based on the number of student accounts on a single se^/er for a

particular course. The current price for an unlimited number of students on WebCT is

13

$1,200 for four months, $1,680 for six months, $2,160 for eight months, and $3,000 for

twelve months. A private company recently purchased WebCT and they have stated

current license holders will not face more than a 5% per year increase in the license fees.

2.3 Non-Commercial Authoring Tools

There are two interesting tools currently under development in academia. The

first, presented in an article in Computers & Education by Nkambou, Frasson, and

Gauthier [NkFrGa 98], highlights the design and implementation of a curriculum and

course authoring tool developed in Canada. According to the authors, they created "[a]n

authoring environment dedicated to the development of curriculum and course material

that can be handled by an Intelligent Tutoring System (ITS)" (p. 105). The ITS is a

proprietary system that runs separately from the authoring environment. This authoring

environment is concerned with instructional design and uses a subject-matter model

called CREAM (Curriculum REpresentation and Acquisition Model). "In this model, a

curriculum is represented and organized according to three points of view: the domain

knowledge, the pedagogical aspect, and the didactic point of view" (p. 108). The domain

knowledge is implemented as a multi-graph where nodes represent capabilities, or

knowledge, stored in a person's long term memory. The pedagogical aspect consists of

instructional objectives represented and organized together, while the didactic point of

view consists of a network of relations for the resources used. The authors force the user

to adhere to the CREAM model by using an expert system to validate the curriculum.

The second authoring tool was found in an abstract entitled "Using a High-Level

Language to Describe and Create Web-Based Learning Scenarios" by Miguel Rodriguez-

14

Artacho. The full paper for this work is currently unavailable, but it will be presented in

the 1999 Frontiers in Education (FIE 99) conference in November. This abstract

describes the author's work as an SGML-based language called PALO. The purpose of

PALO is to provide educators with no knowledge of HTML a tool for preparing

documents for the Internet.

2.4 Significance of this Work

Although there are many similarities between this work and the programs

discussed above there are also several key differences. The first distinction is we are

looking at the feasibility of using an open system for the development of authoring tools.

With the exception of the Rodriguez-Artacho work, every product described above is

based on a proprietary system. The Rodriguez-Artacho work uses an open system for

delivery, but users are restricted to the author's SGML-based language instead of XML,

which the World Wide Web Consortium is working to standardize.

This work uses a cross-platform application for creating and editing courseware,

and a web-based Java applet for viewing the resulting lessons. Both were created to

utilize the Internet, partially due to representing the syllabus protocol in XML and using a

web browser in the applet inherently includes support for the Internet. Several of the

products described above include support for the Internet. These products tend to be fair

in price, but if this work were ever to become a protocol the price would be free. It

should also be noted products such as WebCT also have high overhead costs since they

require a system administrator to ensure the server is running correctly.

15

Another difference is this work does not force the user to adhere strictly to a

specific design methodology as some of the products described above. This work is

loosely based on Gagne's Nine Events of Instruction which is a commonly accepted

instructional design methodology for direct instruction. Gagne's Nine Events of

Instruction is seen below [GaBrWa 88, p. 196]:

1. Gaining attention,

2. Informing the learner of the objective,

3. Stimulating recall of prerequisite material,

4. Presenting the stimulus material,

5. Providing learning guidance,

6. Eliciting the performance,

7. Providing feedback about performance correctness,

8. Assessing the performance,

9. Enhancing retention and transfer.

The only items which are specified in the authoring application are items four, six, and

eight. These items are available to the designer using the protocol which we developed.

16

CHAPTER m

COMPUTER ASPECTS

3.1 Introduction

As discussed in Chapter I, many issues which impact educational software

development. The first relevant problem is schools have invested in and continue to

acquire a wide range of computer systems which are mutually incompatible and/oi have

differing capabilities. The second issue of interest to us is currently tLere is a lack of

motivation to develop educational software because it has not been profitable for

commercial developers to invest resources in producing a reusable delivery system. This

is partially due to software development issues stemming from the creation of an engine

separate from the content in educational software. Also, current software is not very

profitable since most educational software is static or not easily modifiable to evolve as

class content changes, thus discouraging educators from incorporating it into their

classrooms. Another problem is most of the available packages run on proprietary

(closed) systems which require specific machine configurations and usually disallow

third party developers.

The use of open systems like the Internet is an option since the interfaces are

standardized, making them available to all that need them. The Internet can also serve as

a very effective means of delivering information when used correctly, but proposed

Internet instructional standards threaten the openness of the Internet.

K-12 teachers want to utilize technology in their classrooms, but have been

frustrated by both the expense and difficulty of using available software.

17

3.1 Requirements Definition

As a result of above considerations, our proposed authoring package must meet

the following criteria:

1. Take advantage of the variety of platforms and functionality of current

computer systems in public schools, i.e., both the authoring tool and the

delivery system should be cross-platform.

2. A delivery system or engine, separate from the changeable educational

content, should be developed to enable faster, cheaper production of software

for classrooms. This system should also allow simple modification of content

for more extensive educational utilization.

3. Creation and editing must be simple and rapid to be useful to teachers.

4. Both the authoring/editing tool and the engine should adhere to open

standards, encouraging third party add-ons.

Thus our requirements definition for our solution includes:

• The protocol should be based on open standards -

In order to make it possible for the protocol to become a standard, it must be

open so that many people will be able to develop applications that can utilize

the product.

• Separate the content from the delivery system or engine -

The development of a separate re-usable engine will make the production of

educational software easier and more cost effective.

• Make our solution cross-platform -

18

>'i'P%V

Because of the non-uniform nature of computer systems, the product should

run on as many platforms as possible.

The product should be inexpensive -

Since educational money is taxpayer money, the product should be as

inexpensive as possible. Which also makes the product available to more

people.

The product should have a short, flat learning curve -

Because teachers are always busy, the proposed product must be easily

learned and simple to use.

The product should allow modifiable lessons -

As a teacher finds or creates more material, it should be simple for him/her to

incorporate this material into an existing lesson.

The product should allow lessons to be shared -

Once the effort has been expended to create a lesson, it would be desirable to

make it accessible to other teachers.

3.2 Overview of Solution

The authoring system is software that will be used to produce tutorials,

instructional material, etc., which in turn will be data processed by another application.

How we propose to meet these requirements to produce an authoring system bas^d on an

open systems model involves several important items.

First, we developed an appropriate protocol to represent our instructional model

using a Document Type Definition (DTD). Next we developed a two-part engine

19

consisting of a Java application for editing and a Java applet for viewing the lessons

created. This engine utilizes the protocol developed using the DTD and produces an

Extensible Markup Language (XML) file representing a lesson or content. The engine is

kept separate from the content, since the content for a lesson is created elsewhere and the

Java application is used to sequence the material into lessons.

The product should be cross platform, utilizing the Internet. Therefore, Java and

XML were used to develop the authoring system. In addition, this product should be

simple, fast, and include a nice graphical user interface (GUI) for the user.

3.4 Document Type Definition

3.4.1 What is a Document Type Definition?

A document type definition (DTD) can be thought of as a layout standard or

template for an Internet document that is published and available for all users. For

example, the standards that hypertext markup language (HTML) uses can be considered a

DTD. Once a DTD is downloaded, through an Internet browser for example, an

extensible markup language (XML) capable program can interpret the formatting of

documents based on that particular DTD. These documents are usually contained on the

same web page. Technically, a DTD is a set of specifications that completely define

what elements and attributes data may have in a user defined markup language. A user-

defined markup language is simply a set of instructions for manipulating data that any

user can modify or create.

20

We developed a DTD named "Syllabus.dtd" which incorporates the rules for a

lesson based on a direct instruction model developed from Gagne's Nine Events of

Instruction. Users of the authoring software are restricted to these rules which specify all

of the legal elements which may be produced.

3.4.2 Prototype of "Syllabus.dtd"

The "Syllabus.dtd" may be considered a general set of rules or grammar for a

lesson created using this software. The term syllabus was selected after much

consideration because the final product could be a single lesson or it could be a series of

lessons for the entire course.

As can be seen in Figure 3.1, the Syllabus.dtd consists of three main parts. The

first part is a course which consists of a name (a text identifier), and zero or more courses

or units. A unit also consists of a name, zero or more units or lessons, and a performance

section (an exam) that may occur only once. The next piece is a lesson which also has a

name, and zero or more presentations, practices, performances, or Lessons. A

presentation is considered to be any material that contains information of relevance, such

as an article or a web site. A practice could be a practice test or it could be something

similar to a discussion board. A performance is some type of exam or quiz to evaluate or

assess the student.

After much thought, we decided the general design of "Syllabus.dtd" shown in

Figure 3.1 would be the best approach. The first reason is the goal of this project is to

give the educator the power to create what they need while imposing the fewest possible

restrictions. The second reason is that with a general design, it will be more intuitive to

21

make modifications by hand to the files which a user may have previously created using

the authoring tool. This is a possible alternative to using the authoring tool once the

structure of the DTD is known, a user simply needs to modify tags much like those in

HTML. Lastly, the DTD created echoes tables of contents with which most teachers are

familiar. This helps organize the information that teachers have.

A DTD and XML are inherently tree structures. The tree showing a possible file

using "Syllabus.dtd" is shown in Figure 3.2.

<

<

<

<

<

<

<

<

<

<

-Syllabus DTD Version 1.0~> —Brooks York—> ELEMENT Syllabus (Course)> ELEMENT Course (name,(Course|Units)*)> ELEMENT Units (name,(Units|Lesson)*,performance?)> ELEMENT Lesson (name,(presentation|practice|performance|Lesson)*)> ELEMENT name (#pcdata)> ELEMENT presentation (#pcdata)> ELEMENT practice (#pcdata)> ELEMENT performance (#pcdata)>

Figure 3.1: "Syllabus.dtd"

3.5 Extensible Markup Language (XML)

Extensible Markup Language (XML) has been developed by a group of the Worid

Wide Web Consortium (W3C) with the goal of bringing the advantages of the already

standardized SGML (Standard Generalized Markup Language) to the Internet. The

reason XML was needed is because SGML is very complicated and not easy for

designers to utilize. The first working draft of XML was published in 1996, and since

then it has gained considerable favor with developers due to some of the strengths of the

design. 22

XML is considered a markup language. Another example of a markup language is

hypertext markup language (HTML). Due to the use of DTDs, XML is not limited to a

fixed set of element types as HTML is. Instead, elements are defined in the DTD with

the attributes or plug-ins the user wishes to utilize in the document. XML is designed to

fit into areas for which HTML was never intended. The advantages of XML include a

tightly controlled document display, flexibility to describe different and specific types of

information, and the ability to convey information in a variety of media formats [TiMiCh

98].

Civil War (Course)

n Reconstruction

(Course)

The South (Unit)

Figure 3.2: A tree showing a possible file using "Syllabus.dtd"

23

3.6 Java

Java was developed at Sun Microsystems by James Gosling. The basic idea

behind Java is that it should be a small language, but not as small or hard as machme

language, and it should run on any kind of computer chip [DeHi 98]. The ability of Java

to run on many different types of machines is one reason why IBM and Sun

Microsystems have switched to Java for their development languages. Java is a modem

object-oriented programming language that bears a resemblance to C++. Java programs

are secure, robust, and portable [LaOs 99].

3.7 Justification for Using Java

Java was our language of choice because of the nature of school systems with

their many different types of computer systems. In order to provide access to as many

users as possible, a program must be cross-platform and Java allows for this.

We used J Builder 2.0 Professional to implement our project. J Builder was

chosen simply because of its interface, but any environment that uses Java 1.1 would

have been feasible.

3.8 Statement of Work

The key features of this project include:

• The development of a protocol using an appropriate DTD for representation of

a "Syllabus."

24

The implementation of "Create Lesson" functionality —

This allows the user to input data (filenames or URLs) and to create the

corresponding XML structure (highlighted in Figure 3.1), which

represents a standardized lesson.

The implementation of "Edit Lesson" functionality —

This function allows an author to open an already existing file, edit the

data associated with it, and choose to replace or rename the new file.

The implementation of "Merge Lessons" functionality —

This function makes it possible for users to take multiple existing files and

create a single file from them. This is important if an entire section,

chapter, or semester's worth of work is to be included in one large

"lesson."

The implementation of "View Lesson" functionality —

This is a Java Applet that will be launched from a web browser. This

applet was used to test the files created in "Create Lesson," "Edit Lesson,"

and "Merge Lessons" by displaying the files and connecting them to the

URLs specified in them when needed.

25

CHAPTER rV

ALGORITHMS

4.1 Introduction

The logic for this program utilized several built-in features of the source language

discussed in CHAPTER III and an associated library (Swing 1.1) of routines. These will

be identified as they are encountered in this discussion. Since one goal of this research

was to create a graphical user interface (GUI) for educators, the overall design revolves

around the GUI components that Java provides. Many of the code segments use listeners

and events to trigger a section of code to execute, but the overall discussion of the

algorithms will not show this.

4.2 General Algorithms

The Main_Menu of the program is based on the general algorithm given below.

A screenshot of the highest level menu is shown in Figure 4.1. The Main_Menu provides

the user with the option of creating a lesson (the Create object), editing a lesson (the Edit

object), merging several lesson (the Merge object), and exiting the program. The general

algorithm of the main program is as follows:

Start Main_ Menu

Loop

Case user selects

Create : Create_Lesson

Edit: Edit_Lesson

26

Merge: Merge_Lesson

Exit: System_Exit

Until (System Exit invoked by user)

End Main_Menu

This menu works in a manner similar to most other menus. When the user selects

the CREATE A LESSON button by clicking on it with a mouse, an instance of the Create

object is created and displayed on the screen. This is also true of the EDIT A LESSON

and MERGE LESSONS. When these buttons are selected (or clicked) an instance of the

Edit and Merge objects are, respectively, created and displayed. The pull-down menu

under File has the same functionality as the buttons of Main_Menu.

^ C o u i s e Content Sequencing Using XML

Fie Help

CREATE A LESSON

EDIT A LESSON

MERGE LESSONS

EXIT

Figure 4.1: Main Menu

27

4.3 Refined Algorithms

4.3.1 Create Lesson

The interface to a Create object is a dialog box as shown in Figure 4.2. This

object allows the user to create a file which adheres to the Syllabus.dtd protocol

discussed earlier. Once the file is created to the user's satisfaction, the file is saved when

the Finish button is pressed and the user is taken back to the Main_Menu discussed in the

previous section. The algorithm for Create is as follows:

Start Create

Loop

Case user selects:

A: Add

R : Remove

Pr: Presentation

Pa: Practice

Pf: Performance

F : Finish

Until (Exit invoked by user)

End Create

As can be seen from Figure 4.2 and Figure 4.3, the Create object has different

functionality based on where the user is in the creation process. The Add and Remove

buttons respectively insert or delete children from the parent in the tree, where parent

refers to the tree node which is currently selected. It should be noted that the Remove

button removes the currently selected node and all of the selected node's children. This

28

can have a very dramatic and highly agitating effect if the user does not understand the

remove process.

If the user is on the appropriate level of the tree (depth three, or at a Lesson level

for Presentation and Practice, Lesson or Unit for Performance) then the Presentation,

Practice, and Performance buttons become active and the Add button is no longer

selectable (Figure 4.3). This forces the user to insert children with the names

presentation, practice, and performance, as dictated by the Syllabus.dtd file.

^& Cieating a Lesson

Please Enter a Unit Name

•^d\^.~ V,

/• ^/' Add

Presentation s -artice

Item Selected

Selected: Dinosaurs

Remove

PaiformancS

9 [13 Syllabus __ [^ iDinosaurs

Figure 4.2: Creating a Lesson with Add Enabled

29

Once a presentation, practice, or performance node has been inserted, the user

may provide a URL or filename as a legal presentation, practice, and performance item

(Figure 4.4). If no item is entered in the text box, then the Open dialog window appears

and allows the user to select a local file (Figure 4.5). Once the Finish button is selected,

the Save dialog window opens, and the user is allowed to save the file (Figure 4.6).

^ Creating a Lesson

Please Make a Selection

idd-

Presentation Practice

Item Selected Selected: Tt ieeratops

Remove

Performance

9 [l3 Syllabus 9 C3 Dinosaurs

9 CH Plant Eatery Dpceratups;

Figure 4.3: Creating a Lesson with Presentation, Practice, and Performance Enabled

30

^ d e a l i n g a Lesson

. . _.-.,r. -'.' -.• - , t -•' ^i- *.-.-, - . „», .y ,

lease Make a Selection -; -; JftK-

' . . " - ' : r t . . ^ , . J . / .

mil till I

I Presimtafion •l*HIMMM

Item SeCectetf Sleeted: MevaNodel

Remove

. ^ •". * V

Practice -I PiTrtoffhahce

V f E!3 Syllabus

9 (SI Dinosaurs ^ S Plant Eaters

''•- D Presentation

2 j«

."V

Figure 4.4: Allowing the User to Enter a URL or Filename

M^d

D SampleWav.wav

Q Twenty.bmp

D congressg.jpg

Q triceratops_-_wireframe.large

Figure 4.5: Allowing the User to Select a Local File

31

4.3.2 Edit Lesson

The Edit object is very similar to the Create object. The key difference between

them is the user is first asked for an XML file to open (Figure 4.7), and then the file is

read and parsed and an instantiation of a tree is initialized using the syllabus stored in the

file (Figure 4.8). Once this occurs, the functionality available is exactly the same as the

Create object.

j Look H i :Mi ,

u:± ^LT>^. y y->

l l ! ] Java

javax

sun

^ untitled2 Q DJno.xmI..;.;f; . T."!i V -t^^, ^ ^ ; ^ ^ y^^j''^:^r''/: '4" .^ ^ ^

9 / y^ 'A / , / ^ y ' ^ / K - S - * ' "

^K,..rrt,...f,ri.<..<f«<»yMoi ..w

Q Money.xml

D readmaxml

Q trlaLxml

File name:

FOes or^e:

Dino-xml ''/'^fM{^{^^0^/^9f^^f^/0y^P^i^p^^^^^^^ '.•/' ,^-

%y/4iS.//<^.-M/x:y^~'. ^'.. \f}^sm£!k?^/.Sm'Z iAbortflle chooser diafei%it+3

Figure 4.6: Saving a file

32

Figure 4.7: Opening a file

^ ^ E d i t i n g a Lesson

Please Entera Lesson Name era UiittTest

Add Remove

Pr^semst.r- Pr- :»-? I Perfomriance

Item Selected Setectad: Platrt Eateis

9 1:3 Syllabus 9 (I3 Dinosaurs

9 aifkjPf\B9ieri

' , f ; ffiVM'i

9 (I3 Triceratops 9 C3 Presentation

|~" D C:\downloads\tncer; ^ n www.zoomschool c<

',-> ,*-'', * .. *

Hi >.

Figure 4.8: Editing a File

33

4.3.3 Merge Lessons

The Merge object begins by requiring the user to specify the filename under

which they wish to save the new merged file. The Save dialog window shown in Figure

4.6 opens and allows the user to enter an existing filename or select a new filename.

Once a filename has been chosen, a new Merge object is created (Figure 4.9). The

interface for this object is a dialog box with two simple functions. The first function is

the Add a File button which causes the Open dialog window shown in Figure 4.7 to

appear, allowing the user to select a file to add. The user may select the Add a File

button repeatedly to add any number of files. Once the Finish button is pressed, the

object is closed, the new file is saved as an XML file, and the user is returned to the

Main Menu.

^ M e r g i n g Lessons

Add a File

>.'^-

Finish (Save> • • ; . ' ; •

- A -"•*

Figure 4.9: Merge Menu 34

4.3.4 View Lesson

Once a lesson has been created and stored as an XML file, the View object, a Java

applet, allows a user to see the components of the lesson by processing the XML file.

This file may have been created using the previously described Java application or

possibly by hand, but it must conform to the Syllabus.dtd specifications previously

outlined in CHAPTER in. The algorithm for View Lesson is as follows:

Start View

Loop

Case user selects:

L : Load (string Filename)

0 : 0 K

H: Home

V : View (string Item)

N : Next (string Item)

B : Back (string Item)

Until (Exit invoked by user)

End View

The user begins by loading an HTML file which contains the applet, into a v/cb

browser, which will automatically start the applet. The user must firs* enter into the text

box the filename of the XML file they wish to view. Once the Load button is selected,

the file contents are parsed and used to create a tree, much like what was done with the

Edit object. The user must then make selections using the pull-down menus for Coarse,

Unit, Lesson, and Available Files. Once viewable material is specified by selecting a

35

path through the tree to a viewable leaf (presentations, practices, and performances) the

user is then able to select the View button, causing the item to be displayed in the lower

frame. Viewable items include local files, as shown in Figure 4.10, or URLs as shown in

Figure 4.11.

Navigation through the viewable material is simple. The user can use the Next

and Back buttons to load the material pertaining to the next and previous items,

respectively. The user may move directly to a desired leaf by selecting different material

using the pull-down menus and pressing the View button to load the selected item.

' 3 picluie - Miciosolt Internet Exploiei UMM P » gdt ifiev* Fjjyofies look tielp

Stop Rehesh Home i Seach Favoiitet Hotory Mail ftmt EcSl

i <#4

j ^j(fa»« | @ C \jbulde(2\inyclanes\picluie.htin " 3 «^8o li'-***'*!

Enter afite to toad.

c ^ibulder2\iriyclasses\dino.ianl Load

Matte 9 seteetion and Pren OtC

Cou«8 ^ Lfr»t /JJ/J^ l e t w n AvalafcfeRkstoView

I j _ ] | ~i. _ I t jtjp. _J IC \downloads\lriceratops__w«diai_;J

OK

VIEW NEXT

«]£><»» T i " i j } My'Computer

Figure 4.10: Viewing a local file

36

£i« t A ) ^ FaMMkat lock M«t>

l m?" |A(|ita»*J^ D\)>uidei2\iiiyclattes\picluta hlin

flaitV I - KM W «

^ttttflbtlaiMd

jc \|biJdei2\ir)yda»es\dno lonl load

"4

M«lu»aMl«eiian«nilRw>aK

3 1 1 vwm zooimchool com/siiiieclt/'dr^

u

ZOOM

lablcj i i Coatcnts

iDinnsaurs

DinD iNcws

Plmse visit ouf sponsor.

ZoomPittosaur i. com

j

Figure 4.11: Viewing a URL

37

CHAPTER V

IMPLEMENTATION ISSUES

5.1 Introduction

Several implementation issues arose during development. Some of these issues

stemmed from learning Java during development, while others were problems with the

Java interpreter itself (including a few documented bugs). Due to these issues, several

choices had to be made and these are highlighted below.

5.2 Java Related Issues

5.2.1 The Authoring Tool as a Java Application or Applet

The first important decision encountered was whether the authoring tool, which

implements the "Create", "Edit", and "Merge" objects, should be created as a Java

application or a Java applet. A Java application is a traditional program which requires a

Java interpreter. A Java applet is a segment of code that is downloaded and run locally

through a web browser.

We were forced to choose an application since applets are heavily restricted in

opening, creating, and saving files due to Internet security concerns.

5.2.2 File Filters

The next problem that arose with the authoring software was how to implement a

file filter. A file filter is an object that only allows files of a selected type, in this case

XML files, to be shown in Open File and Save File dialog windows.

38

The problem stenmied from the JDK Chooser class. This class implements Open

and Save dialog windows and if a duplicated filename is specified it asks the user if they

wish to replace the file that already exists. This particular class does not property

implement file filters, which is a bug documented on many Java discussion groups. A

possible solution to this was to use the new Swing 1.1 classes. Swing is a new set of

classes Sun Microsystems has released to allow easier GUI implementation. The Swing

version of the file filters work, but the object does not notify the user when a file already

exists when saving. This means a user must be careful about what filename they select

when saving since they can easily overwrite existing files without warning.

The solution chosen was to use the Swing 1.1 classes. It was decided it would be

more important to show a user which file type was needed (i.e., XML files), than to allow

the user to attempt to load any type of file into the authoring software for editing. The

trade-off to this choice is the user is not notified that a selected file is about to be replaced

by a new file if the filenames are the same.

5.2.3 Data Structure

Because XML is inherently a tree structure, it was determined the best approach

for reading, storing, and manipulating data would be to implement a tree data structure to

contain the data in a user created XML file.

Originally, a custom tree structure was considered. The decision to use Swing

classes for the file filters led to the decision to use a preexisting data structure. Th^

Swing classes have a tree structure already implemented in the JTree -:lass. Images of the

JTree can be seen on the right hand side of the windows in Figure 4.2 and Figure 4.8.

39

The decision to use the JTree was made because we determined writing a custom

tree data structure would be redundant. The JTree has a steep learning curve, but the use

of the tree made the implementation of the "Create", "Edit", and "View Lesson" object

quite easy. The JTree also has many nice extra features, for example, allowing selected

items to have their names directly edited, automatically expanding/collapsing the tree

when invoked by the user, and it has the look and fell of a typical Microsoft Windows

File Manager with which many users are already familiar.

5.2.4 Initiahzing the Current Node

This problem involved selecting the root, which is always Syllabus, as can be

seen in Figure 4.2 and Figure 4.3. Actions in Create and Edit depend on which node is

current or selected, i.e., highlighted (Figure 4.2). Thus, in Create and Edit, it would be

desirable to have the root initially selected so the user can begin entering data with out

being forced to first select the root node.

Unfortunately, the tree uses a listener to respond to selections a user may make

with the mouse. The listener is simply an object which determines when an element in

the tree is clicked and then invokes an appropriate action. A problem arises in the case of

the Create object when the only activated node in the tree is the root. If the root is

already selected, the listener will never be activated regardless of how many times the

root is clicked.

Since this problem is inherent in the design of the listener the Create and Edit

objects require the user to first select an item to begin. Obviously, in the case of editing

40

any element may be selected. However, when creating a new syllabus, the root must be

selected by the user to begin.

5.3 Java Applet Issues

5.3.1 Loading Files

Applets were designed to be pieces of code downloaded by a web browser from

the Internet and executed locally. Owing to this, many restrictions were placed on

applets for the sake of security. One of these restrictions pertains to the circumstances

under which an applet can open a file. The reason a user would not want software of

dubious origin downloaded from the Internet to have access to their local files is obvious,

but in our case we developed the software ourselves and needed the ability to access local

files referenced in the XML tutorial files. To get an applet to read a file requires a small

compromise.

The only files an applet is allowed to access are those which reside in the same

directory as the HTML file that launched the applet. This condition can be met locally if

the HTML file is local, or it can be accomplished by running the applet on a server and

bundling the necessary files in the same directory. If neither of these options is used, the

applet gives a Java security exception and the file will not load. A possible solution to

this is discussed in CHAPTER VII: Future Work.

However, it was beyond the scope of this work to write a server to control the

input file of the applet. We instead require the user to execute the "View Lesson" applet

locally and to place all necessary input files in the same directory as the applet's HTML

file.

41

5.3.2 Internet Explorer and Netscape

There are two inconsistencies with running the "View Lesson" applet in Internet

Explorer or Netscape. The first is that the applet does not repaint properly when another

window is opened over it and then closed. The buttons are still present on the applet, but

they will not be visible. Numerous repaint fixes were tried, but the applet will not refresh

properly.

The second problem with these two browsers is that Internet Explorer loads the

item the user wishes to view as expected and into the desired frame, which is located in

the bottom half of the window below the horizontal line shown in Figure 4.10 and Figure

4.11. Netscape, on the other hand, loads the item into an entirely new and different

browser window. Since this inconsistency only occurs in Netscape, it has been attributed

to the Netscape browser and we recommend using Internet Explorer until Netscape fixes

this bug.

42

CHAPTER VI

CONCLUSIONS

6.1 Showing Feasibihtv

The purpose of this work was to show the feasibility of using an open system

model in the development of course authoring tools. Since an open system is based on

protocols, we first developed an XML-based protocol as a template for a Syllabus. This

Syllabus is expressed as a Document Type Definition, or DTD, and tutorials adhering to

this protocol should also be created as XML documents.

We then showed the feasibility of such a protocol by developing a Java

application which allows the user to create, edit, merge, and store tutorials according to

the Syllabus format. A separate applet allows the user to view the finished tutorial using

a web browser.

The authoring application and the viewing applet both separate the engine* from

the content. The separation of the content from the engine allows our programs to adhere

to the open system model (as previously discussed). This idea is significant since anyone

can develop authoring or viewing tools for these tutorials as long as they have the DTD.

Our solution is also cross-platform because we used both Java and XML in the

development of our authoring application and viewing applet. This is extremely

important since as long as a potential user has one machine which runs the authoring

software and has a web browser, then they can create and view a tutorial.

43

Our solution is also cost effective since it uses an open system model. This can

be seen in many of the applications that have been developed for UNIX and the

availability of the source code which was used to create those applications.

As we have stated above, we met our goal of showing the feasibility of using an

open system model with a protocol for course authoring software. In addition, our

programs form a complete system for creating, editing, and storing tutorials. Beyond

this, they are also inexpensive, cross-platform, and provide a GUI to aid in ease of use.

44

CHAPTER Vn

FUTURE WORK

7.1 Introduction

Even though this work fulfills all of the requirements set forth in the Thesis

proposal, a few issues arose which should be given consideration in any future work

relating to this study. By considering the items addressed below, this work could be

extended to become a more complete study in the development of an open protocol

model for the delivery of educational material.

The items listed below are of interest for several reasons. The completion of the

usability study mentioned in section 7.2, would be required to verify the appropriateness

of this work in an actual educational setting. The completion of sections 7.3 through 7.7

is necessary in order for this work to be considered a production-quality model with

production quality features and reliability rather than simply a prototype.

7.2 Usability Study

A usability study aids in determining the actual effectiveness of a work in a real

setting. A study featuring educators using the tool we developed based on the open

protocols proposed in this work should be completed. In-service and pre-service tearher

feedback from such a study would provide valuable insights to improve the tool created

for this work.

45

7.3 User Interface Improvement

After the usability study mentioned above is completed, it would be advantageous

to look at ways to improve the user interface based on the input provided by the test

subjects. Many issues are involved in the development of a user interface: designs that

prohibit/promote learning and special considerations for education which help to improve

the overall effectiveness of an educational tool.

7.4 Creating a Student View Lesson

There are several aspects requiring further study in order to improve the View

Lesson object created as part of this work. The first item includes determining the best

approach to designing a View Lesson component for a student. The View Lesson object

we created is for use by an author to see how the components of the tutorial file they

created appear. However, it would be extremely easy to modify the existing source code

to allow the applet to read a data file containing the name of the lesson to open. It would

then be possible to limit the access provided to a student to the lesson named in the data

file, and Umit them to only the Back, View, and Next buttons provided in the applet

(Figure 4.10 and Figure 4.11). These restrictions would force a student to access the

tutorial sequentially as the instructor intended, rather than randomly as the curreii

software allows.

7.5 A Possible Alternative to the View Lesson

The second item relevant to the View Lesson object involves a possible

alternative to using Java applets that may cure some of the problems mentioned in section

46

5.3, which describes problems with loading data files and problems encountered with

Netscape. A programmer could use Common Gateway Interface (CGI) scripting and

XML style sheets to create a seamless view, one in which there would be no frames and

no obvious Java applet. This method would involve using CGI for the buttons to

navigate the course material. CGI should be investigated because the tool's buttons

would actually be embedded in the web page that is loaded, unlike a Java applet which

requires a frame context in which to run.

The XML stylesheet tells the web browser how to display a certain file, in this

case an XML file that conforms to the Syllabus.dtd document type definition. As of this

writing, the only web browser recognizing XML is Internet Explorer 5.0. The file listing

seen in Figure 7.1 is loaded into a text editor, this file represents the XML file created for

Figure 4.8, Figure 4.10, and Figure 4.11. The same file is shown in Figure 7.2 using the

default XML style sheet in Internet Explorer (IE). If the stylesheet were modified, it

would be possible to alter the look of the XML file, perhaps into a more useful

representation for the presentation, practice, and performance items a user may wish to

view, as opposed to loading them into a separate frame as they are currently done.

This method could help with the idea of using an open protocol, since the style

sheet could be changed to reflect any new items whenever changes to the document type

definition changed to accommodate new technological innovations.

47

M Dino - Notepad

lEte £ « "Search i i l p

<!DOCTVPE Syllabus SYSTEM "Syllabus.dtd"> <Syllabus> <Course> <nanie>Dlnosaurs</naine> <Unit> <naine>Plant Eaters</nanie> <Lesson> <nane>Triceratops</naiiie> <presentation>C:\downloads\triceratops_-_wirefi-ane.large</presentation> <presentation>www.zoomschool.con/subjects/dinosaurs/</presentation> </Lesson> </Unit> </Course> </Syllabus>

iammmm\mmtmmuutmui W!k ^ ^^ /^

"3

? n . •^/•' t

Figure 7.1: An XML file

3 C Aibuildei2\mycIasses\Dmo

g i p / * : ^ i> i3 IS ^ Jii # : > ^ % ^ ^ ^C'^^f Step Reiinh Horn Ssaich FavortM

ia?^

-««UA)MM^ • » * < MJ^-'^^xl

^ C \jbuldei2\mycldsse$\Dro xml ^ 6 o ' U * i * • . ^ < ^ f

<!DOCTYPE Syllabus fWew Source for fiilldoctYpe...)> • <Syllabus>

- <Course> <name>Dinosaurs</name>

- <Unit> <name>Plant Eaters</name>

- <Lesson> <name>Triceratops</name> <presentat ion>C: \downloads\ t r iceratops_-_wlrBframe. large</pre5entat ion> <prBsentat ion>v«iww.zoomschool .com/subjects /d inosaurs/< /presentat ion>

</Lesson> </Unit>

</Course> </'Syllabus>

"i r ,'3TSyC<wput«

S

^ i I

i *

^

Figure 7.2: XML file in IE 5.0 48

7.6 Scheme for Delivery of Material

Further investigation into the delivery of the content material is needed to allow

centralized distribution and easy access by educators. The idea of a centralized location

is important because it would create a known distribution center that could be accessed

by educators for help, content ideas, and possibly bundled content packages.

The first issue concerns the delivery of the material needed for execution. The

applet, application, and content material could be delivered via a server that is set up to

handle this kind of material. Such a server would solve some of the applet issues

discussed above, but would make distribution more complicated beca ise it necessitates a

system administrator.

The second consideration is the bundling of content material, the DTD used to

create the tutorial, and the XML file created for distribution. Possible methods include

using an index to keep track of the files or creating a database with the files inside.

Although the current project keeps track of where the presentation, practice, and

performance files are, it does not force the educator to use some predefined scheme for

itemizing files used in the lessons created. This implies that the tutorial creator has some

knowledge of where all the files are located.

7.7 Dynamic Structures

The last item suggested for future consideration is the addition of the ability of the

Java application and applet to dynamically read the document type definition. This

would allow the modification of the Syllabus.dtd file for future enhancements without

loss of functionality to the authoring tools. It may be this could be done rather easily

49

using a class similar to the IBM class for parsing XML files and incorporating the style

sheets mentioned above.

50

BIBLIOGRAPHY

[CI 85] Clark, R. E., (1985). Confounding in Educational Computing Research. Journal of Educational Computing Research. 1. 2. 137-147.

[CoDoKi 94] Coulouris, G., Dollimore, J., & Kindberg, T. (1994). Characterization of Distributed Systems. In A. D. McGettrick (Ed.), Distributed Systems Concepts and Design (pp. 1-28). Hariow, England: Addison-Wesley Publishing Company.

[DE 97] Department of Education National Center for Educational Statistics. (1997). National Assessment of Educational Progress. Washington, D.C.: Author.

[DE 98] Department of Education National Center for Educational Statistics. (1998). National Assessment of Educational Progress. Washington, D.C.: Author.

[DeHi 98] Decker, R., & Hirshfield, S. (1998). An Introduction to Programming Using Java. Boston, MA: PWS Publishing Company.

[EdHa 89] Edwards, D. M., & Hardman, L. (1989). 'Lost in Hyperspace': Cognitive Mapping and Navigation in a Hypertext Environment. Hypertext: theory into practice, 105-125.

[EDU 98] EDUCOM/NLII (1998) Instructional Management Systems Specifications Document [online] Available: http://www.imsproject.org.

[GaBrWa 88] Gagne, R., Briggs, L., & Wager, W. (1988). Principles of Instructional Design. Orlando, Florida: Holt, Rinehart, and Winston, Inc.

[ISOC 98] Leiner, B., Cerf, C , Clark, D., Kahn, R., Kleinrock, L., Lynch, D., Postel, J., Roberts, L., & Wolff, S., (1998) A Brief History of the Internet, [online] Available: http://www.isoc.org/intemet/history/brief.htm.

[Je 98] Jerald, C. D., (1998). By the Numbers. Education Week on the Web [On-Line]. Available: http://www.edweek.org/sreports/tc98/data/exsum.htm.

[KaGiLeSe 98] Kanel, J., Givler, J. S., Leiba, B., & Segmuller, W. (1998). Internet Messaging Frameworks. IBM Systems Journal 37,1, 4-18.

[LaOs 99] Lambert, K. A., & Osborne, M. (1999). Java: A Framework for Programming and Problem Solving. Pacific Grove, CA: Brooks/Cole Publishing Company.

51

[NkFrGa 98] Nkambou, R., Frasson, C , & Gauthier, G. (1998). A new approach to ITS-curriculum and course authoring: the authoring environment. Computers & Education, 31, 105-130.

[Po 82] Postel, J. (1982). Simple Mail Transport Protocol. (No. RFC 821). Information Sciences Institute, University of Southern California.

[So 98] Soloway, E. (1998). No One Is Making Money In Educational Software. Communications of the ACM, 41,2, 11-15.

[TiMiCh 98] Tittel, E., Mikula, N., & Chandak, R. (1998). XML for Dummies. Foster City, CA: IDG Books.

[Wh 99] The White House, Office of the Vice President. (1998). Information Technology for the Twenty-first Century: A Bold Investment in America's Future [online] Available: http://www.pub.whitehouse.gov/uri-res/I2R?um:pdi://oma.eop.gov.us/1999/l/25/12.text.l

52

APPENDDC A

GLOSSARY

1. Computer Aided Instruction (CAI) - the use of (personal) computers in education and

training.

2. Curriculum REpresentation and Acquisition Model (CREAM) - an instructional

design model based on creating instructional material for intelligent tutoring systems and

discussed in detail in Chapter II.

3. Engine - a program which performs a core or essential function for other programs.

An engine can be a central or focal program in an operating system, subsytem, or

application that coordinates the overall operation of a related set of programs. It is also

used to describe a special-purpose program containing an algorithm that can sometimes

be changed.

4. Event - an action which occurs in a program, in this work particularly mouse clicks.

5. Lesson - a series of sequential steps used to instruct a user.

6. Listener - an object which responds to certain events.

7. Markup - refers to the sequence of characters or other symbols inserted at certain

places in a text or word processing file to indicate how the file should look when it is

printed or displayed, or to describe the document's logical structure. The markup

indicators are often called "tags."

8. Multimedia - media which utilizes more than one concurrent presentation medium

(for example, on CD-ROM or a Web site). Although still images are a different medium

than text, multimedia is typically used to mean the combination of text, sound, and/or

motion video. 53

9. Nine Events of Instruction - Robert Gagne made a significant contribution when he

examined the internal learning processes proposed by cognitive learning theory and

developed a set of "external events" designers might incorporate in lessons to stimulate

the corresponding internal processes. This set of nine "Events of Instruction" aie:

motivation, objectives, prior knowledge, teach, guide, practice, feedback, test, and

transfer.

10. Open System - a system which adheres to a publicly-known and sometimes standard

set of interfaces so anyone using it can also use any other system that adheres to the

standard.

11. Package - a method of formally storing data in order to distribute it.

12. Proprietary System - a completely self contained system, in which all interfaces

work only on the specific machines for which the system was designed to run.

13. Protocol - a set of standardized rules to follow.

14. Syllabus - Used in this discussion, any single lesson or series of lessons that have an

instructional objective.

15. World Wide Web Consortium (W3C) - an industry consortium which seeks to

promote standards for the evolution of the Web and interoperability between WWW

products by producing specifications and reference software. Although W3C is funded by

industrial members, it is vendor-neutral and its products are freely available to all.

16. Wintel - a computer trade industry term for personal computers based on the Intel

microprocessor and one of the Windows operating systems from Microsoft. The term

"PC" has often been used for this purpose.

54

APPENDDC B

SAMPLE SOURCE CODE

//Title: Edit.java //Version: 1.0 //Created On: 06/08/99 //Copyright: Copyright (c) 1998 //Author: Billy Brooks York //Company: Texas Tech University //Description: This section of code allows for the editing of "Syllabus" // files that meet the specifications set in Syllabus.dtd

//package Thesis 1;

import java.awt.Color; import java.awt.Frame; import borland.jbcl.layout.XYLayout; import borland.jbcl.layout.XYConstraints; import j avax. swing. tree.DefaultMutableTreeNode; import javax.swing.tree.TreePath; import j avax. swing, tree .DefaultTreeModel; import javax.swing.tree.TreeSelectionModel; import javax.swing.tree.TreeNode; import j avax. swing. tree. MutableTreeNode; import javax.swing.event.TreeSelecfionListener; import javax.swing.event.TreeSelectionEvent; import java.awt.event.ActionEvent; import j ava. io. lOException; import java.io.OutputStream; import java.io.FileOutputStream; import java.io.PrintWriter; import java.io.FileReader; import java.io.BufferedReader; import javax.swing.JDialog; import javax.swing.JPanel; import javax.swing.JLabel; import javax.swing.JFileChooser; import com. inprise.jbcl.control.ButtonControl; import com.inprise.jbcl.control.LabelControl; import com.inprise.jbcl.control.TextFieldControl;

public class Edit extends JDialog { JPanel panel 1 = new JPanel(); XYLayout xYLayoutl = new XYLayout(); //This is the tree stuff. //"root" is the root of the tree and it is always "Syllabus" //the "treeModel" is default because that is all that is needed. protected DefaultMutableTreeNode root = new DefaultMutableTreeNode("Syllabus"); protected DefauItTreeModel treeModel = new DefaultTreeModel(root); protected javax.swing.JTree tree = new javax.swing.JTree(treeModel); javax.swing.JScroUPane jScroUPanel = new j avax. s wing. JScrollPane(tree); javax.swing.JPanel jPanell = new javax.swing.JPanelQ; XYLayout xYLayout2 = new XYLayout();

//Design Items

55

// XYLayout xYLayoutl = new XYLayout(); public ButtonControl bttnChild = new ButtonControl(); public ButtonControl present = new ButtonControl(); public ButtonControl pract = new ButtonControl(); public ButtonControl perform = new ButtonControl(); public ButtonControl bttnFinish = new ButtonControl(); public ButtonControl bttnRemove = new ButtonControl(); public LabelControl label 1 = new LabelControl(); public LabelControl labelControU = new LabelControl(); public LabelControl Ibll = new LabelControl(); public JLabel j Label 1 = new JLabel(); public TextFieldControl textl = new TextFieldControl();

//These are variables //"Current_State" is used to determine where the user is. //"newNodeSuffix" is used when no name is provided for a node. //"remove" is used when a node is removed to ensure that the // Listener does not crash. //"UnitTest" is used when a user enters a Unit Test (there can only be one). public String Current_State="start"; public String Selection; public int newNodeSuffix =1; public boolean remove=false; public boolean UnitTest=false;

//The Swing choosers (for files) JFileChooser jchooser = new JFileChooser(); JFileChooser selector = new JFileChooser();

//The Selection Listener that has given me so much trouble. TreeSelectionListener Listener2;

public Edit(Frame frame, String title, boolean modal) { super(frame, title, modal); try { jblnitQ; MakeltO; DoListenerO;

}//end try

catch (Exception ex) { ex.printStackTraceO;

}//end catch packO;

}//end public edit

public Edit() { this(null,"", false);

}

void jblnitO throws Exception {

panel 1. setLayout(x YLayout 1); X YLayout 1. setHeight(480); xYLayoutl .setWidth(640); getContentPaneO. add(panel 1);

56

//getContentPane().setLayout(xYLayoutl); // getContentPane().setSize(new Dimension(640,480)); panell.add(bttnRemove, new XYConstraints(155, 102, 149, 46)); panel l.add(bttnChild, new XYConstraints(8, 102, 149,46)); panell.add(labell, new XYConsti-aints(39, 14, 281, 30)); panell.add(textl, new XYConstraints(44,43, 204, 43)); panell.add(lbll, new XYConstraints(44,9, 203, 32)); panell.add(jLabell, new XYConstraints(17, 252, 221, 24)); panell.add(pract, new XYConstraints(107, 192, 93, 34)); panell.add(present, new XYConstraints(15, 192, 93, 34)); panell.add(perform, new XYConstraints(200, 192, 93, 34)); panell.add(i5ttnFinish, new XYConstraints(20, 350, 257,43)); panell.add(labelControll, new XYConstraints(17, 234, -1, -1));

jLabell.setText("NO ITEM SELECTED"); labelControll .setText("Item Selected"); lbll.setText("labelContioll");

//Set the Buttons to work present. setEnabled(false); present. setLabel (" Presentation"); present.setToolTipText("Insert a presentation section"); present.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(ActionEvent e) { present_actionPerformed(e);

} });

pract. setEnabled( false); pract.setLabel("Practice"); pract.setToolTipText("Insert a practice section"); pract.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(ActionEvent e) { pract_actionPerformed(e);

} });

bttnRemove.setLabel("Remove"); bttnRemove.setToolTipText("Remove selected node and all children."); bttnRemove.addActionListener(newjava.awt.event.ActionListener() {

public void actionPerfonned(ActionEvent e) { bttnRemove_actionPerformed(e);

} });

bttnFinish.setBackground(new Color(0, 0,205)); bttnFinish.setForeground(Color.white); bttnFinish.setLabel("Finish"); bttnFinish.setToolTipText("Save the file and reUim to the main screen"); bttnFinish.addActionListener(newjava.awt.event.ActionListener() {

public void actionPerformed(ActionEvent e) { bttnFinish_actionPerformed(e);

} });

perform. setEnabled(false); perform. setLabel(" Performance"); perform.setToolTipText("Insert a performance section"); perform.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(ActionEvent e) {

57

perform_actionPerformed(e); }

});

bttnChild.setLabel("Add"); bttnChild.setToolTipText("Add a child item to the selected item"); bttnChild.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(ActionEvent e) { bttnChild_actionPerformed(e);

} });

//Set the tree up. tree. setShowsRootHandles(true); tree. setEditable(tiiie); ti-ee. setForeground(Color.black); tree.getSelectionModel().setSelectionMode

(TreeSelectionModel.SINGLE_TREE_SELECTION); tree.putClientProperty("JTree.lineStyle","Angled"); jPanel 1 .setLayout(xYLayout2); panell.add(jPanell, new XYConstraints(357, 8, 254, 426)); jPanell.add(jScrollPanel, new XYConstraints(0, 1, 253,423)); jScrollPanel .getViewport().add(tree, null);

}// end JBINIT

//Makelt takes in a file and parses it. It then takes all of the nodes and //places them into the tree, public void Makelt() { JFileChooser jchooser = new JFileChooser(); jchooser.setMultiSelectionEnabled(false); Stiing[] files = new String[] {"xml"}; jchooser.addChoosableFileFilter(newSimpleFileFilter(files,"XMLFiles(*.xml)")); String filename=null;

FileReader theFile; BufferedReader fileln=null; String oneLine; String Currentltem=null;

String Item=null; int Stringl^ngth=0;

//Need to keep track of these items int NumofPresentations=0; int NumofPractices=0; int NumofPerformances=0;

//These nodes are used to determine where to insert nodes DefaultMutableTreeNode currentParent=root; DefaultMutableTreeNode UnitParent=root; DefaultMutableTreeNode LessonParent=root; DefaultMutableTreeNode presentationParent=null; DefaultMutableTreeNode practiceParent=null; DefaultMutableTreeNode performanceParent=null; DefaultMutableTreeNode InsertMe=null;

int option =jchooser.showOpenDialog(this);

58

if(option==JFileChooser.APPROVE_OPTION) { if(jchooser.getSelectedFile()!=null) { filename=jchooser.getSelectedFile().getAbsolutePath(); if (!filename.endsWith(".xml"))

filename=filename + ".xml"; //System.out.println(filename); }//end jchooser.getSelectedFileO !=null try { theFile=new FileReader(filename); fileln= new BufferedReader(theFile);

while ((oneLine = fileIn.readLine())!=null) { if(oneLine.equals("<Course>"))

Currentltem=" Course"; else if (oneLine.startsWith("<Unit>"))

CurrentItem="Unit"; else if (oneLine.startsWith("<Lesson>"))

CurrentItem="Lesson"; else if (oneLine.startsWith("<presentation>")) { NumofPractices=0; NumofPerformances=0; if (NumofPresentations==0) { InsertMe = new DefaultMutableTreeNode("Presentation"); treeModel.insertNodeInto(InsertMe, presentationParent,presentationParent.getChildCount()); presentationParent = (DefaultMutableTreeNode) (InsertMe); tree.scrollPathToVisible(newTreePath(InsertMe.getPath()));

}//end if NumofPresentations==0 S tringLength=oneLine. length(); Item=oneLine. substring( 14,StringLength-15); //System.out.print("Found a name "); //System.out.printin(Item); InsertMe = new DefaultMutableTreeNode(Item); treeModel.insertNodeInto(InsertMe, presentationParent,presentationParent.getChildCount()); tree.scrollPathToVisible(newTreePath(InsertMe.getPath())); NumofPresentations++;

}//end else if presentation

else if (oneLine.startsWith("<practice>")) { NumofPresentations=0; NumofPerformances=0; if (NumofPractices==0) { InsertMe = new DefaultMutableTreeNode("Practice"); treeModel.insertNodeInto(InsertMe, practiceParent,practiceParent.getChildCount()); practiceParent = (DefaultMutableTreeNode) (InsertMe); tree.scrollPathToVisible(newTreePath(InsertMe.getPath()));

}//end if NumofPractices==0 S tiingLength=oneLine. length(); Item=oneLine. substring( 10, S tringLength- II); //System.out.print("Found a name"); //System.out.printin(Item); InsertMe = new DefaultMutableTreeNode(Item); treeModeI.insertNodeInto(InsertMe, practiceParent,practiceParent.getChildCount()); tree.scrollPathToVisible(newTreePath(InsertMe.getPath()));

59

NumofPractices++; }//end else if practice

else if (oneLine.startsWith("<performance>")) { NumofPresentations=0; NumofPractices=0; if (NumofPerformances==0) { InsertMe = new DefaultMutableTreeNode("Performance"); treeModel.insertNodeInto(InsertMe, performanceParent,performanceParent.getChildCount()); performanceParent = (DefaultMutableTreeNode) (InsertMe); tree.scrollPathToVisible(newTreePath(InsertMe.getPath()));

}//end if NumofPerformances==0 StringLength=oneLine .lengthO; Item=oneLine.substring(13,StringLength-14); //System.out.print("Found a name "); //System.out.println(Item); InsertMe = new DefaultMutableTreeNode(Item); treeModel.insertNodeInto(InsertMe, performanceParent,performanceParent.getChildCount()); tree.scrollPathToVisible(newTreePath(InsertMe.getPath())); NumofPerformances++;

}//end else if performance

else if (oneLine.startsWith("<name>")) { StringLength=oneLine.length(); Item=oneLine.substring(6,StringLength-7); //System.out.print("Found a name "); //System.out.println(Item);

if (CurrentItem=="Course") { tree. setSelectionRow(O); TreePath parentPath = tree.getSelectionPath(); currentParent = (DefaultMutableTreeNode)(parentPath.getLastPathComponent()); InsertMe = new DefaultMutableTreeNode(Item); treeModel.insertNodeInto(InsertMe, currentParent,currentParent.getChildCount()); UnitParent = (DefaultMutableTreeNode) (InsertMe); treeModel.reloadO;

}//end if CurrentItem==Course

else if (CurrentItem=="Unit")

{ InsertMe = new DefaultMutableTreeNode(Item); treeModel.insertNodeInto(InsertMe, UnitParent,UnitParent.getChildCount()); tree.scrollPathToVisible(newTreePath(InsertMe.getPath())); LessonParent = (DefaultMutableTreeNode) (InsertMe); performanceParent = (DefaultMutableTreeNode) (InsertMe); treeModel.reloadO;

}//end else if CurrentItem==Unit

else if (CurrentItem=="Lesson")

{ InsertMe = new DefaultMutableTreeNode(Item); treeModel.insertNodeInto(InsertMe, LessonParent,LessonParent.getChildCount()); tree.scroIlPathToVisible(newTreePath(InsertMe.getPath())); NumofPresentations=0; NumofPractices=0; NumofPerformances=0; presentationParent = (DefaultMutableTreeNode) (InsertMe);

60

practiceParent = (DefaultMutableTreeNode) (InsertMe); performanceParent = (DefaultMutableTreeNode) (InsertMe); treeModel.reloadO;

}//end else if CurrentItem==Unit }// end oneline Starts with name System.out.printin(oneLine);

}//end while((oneLine = fileIn.readLine())!=null) theFile.closeO;

}//end try catch (lOException x) { System.out.println("Error Opening!!");

} }// end if(option==JFileChooser.APPROVE_OPTION) else

this.disposeO; }//end MakelT

private void DoListenerO { tree.addTreeSelectionListener(newListener2());

}//end DoListener

void bttnChild_actionPerformed(ActionEvent e) { if (Current_State=="start") { labell.setText("Please make a selection from the tree.");

}//end if Current_State=="start"

else if (Current_State=="root") { DefaultMutableTreeNode parentNode=null; TreePath parentPath = tree.getSelectionPath(); Object child=null; Object compare=""; String text=null; text=text 1. getTextO;

if (text.equals(compare)) addObject("New Node" + newNodeSuffix++);

else addObject(textI .getTextO);

textI.setText(""); }//end else if Current_State=="root"

else if (Current_State=="Course") { DefaultMutableTreeNode parentNode=null; TreePath parentPath = tree.getSelectionPath(); Object child=null; Object compare=""; String text=null; text=textl .getTextO;

if (text.equals(compare)) addObject("New Node" + newNodeSuffix++);

else addObject(textl .getTextO);

61

textl.setText(""); } //end else if Current_State=="Course"

else if (Current_State=="Unit") { DefaultMutableTreeNode parentNode=null; TreePath parentPath = tree.getSelectionPath(); Object child=null; Object compare=""; String text=null; text=textl.getTextO;

if (text.equals(compare)) addObject("New Node" + newNodeSuffix++);

else addObject(textI .getTextO);

textl.setText(""); } //end else if Current_State=="Unit"

else if (Current_State=="ThreeP") { boolean childExists = CheckPerformanceChild();

if (childExists==true) { labell.setText("There can only be ONE Unit Test!");

} else { DefaultMutableTreeNode parentNode=null; TreePath parentPath = tree.getSelectionPath(); Object child=null; Object compare=""; String text=null; selector.setMultiSelectionEnabled(false); text=text 1. getTextO;

if (text.equals(compare)) { int option = selector.showDialog(this,"Add"); if(option==JFileChooser.APPROVE_OPTION) { if(selector.getSelectedFile()!=null)

{ child=selector.getSelectedFile().getAbsolutePath(); addObject(child);

}//end if !=null }//end if APPROVE

}//end equals compare else { addObject(textl .getTextO); textl.setText("");

}//end else }//end else ChildExists

}//end else if Current_State=="ThreeP" }//end bttnChild

void bttnRemove_actionPerformed(ActionEvent e)

{

62

remo veCurrentNodeO; }// end bttnRemove

void present_actionPerformed(ActionEvent e) { DefaultMutableTreeNode parentNode=null; TreePath pai-entPath = tree.getSelectionPath();

if (parentPath==null) { parentNode=root;

} else { parentNode = (DefaultMutableTreeNode)(parentPath.getLastPathComponent());

}

Object child; child="Presentation"; DefaultMutableTreeNode childNode = new DefaultMutableTreeNode(child);

//insert the node treeModel.insertNodeInto(childNode,parentNode,parentNode.getChildCount()); //set the new node to be visible tree.scrollPathToVisible(newTreePath(childNode.getPath())); textl.setText("");

}//end present_actionPerformed

void pract_actionPerformed(ActionEvent e) { DefaultMutableTreeNode parentNode=null; TreePath parentPath = tree.getSelectionPath();

if (parentPath==null) { parentNode=root;

} else { parentNode = (DefaultMutableTreeNode)(parentPath.getLastPathComponent());

} Object child; child="Practice"; DefaultMutableTreeNode childNode = new DefaultMutableTreeNode(child);

//insert the node treeModel.insertNodeInto(childNode,parentNode,parentNode.getChildCount()); //set the new node to be visible tree.scrollPathToVisible(new TreePath(childNode.getPath())); textl.setText("");

}//end pract_actionPerformed

void perform_actionPerformed(ActionEvent e)

{ //System.out.printin(Current_State); boolean check=CheckThis(); int SelectedChildren=0; TreePath parentPath = tree.getSelectionPath(); DefaultMutableTreeNode SelectedParent=null; SelectedParent = (DefaultMutableTreeNode)(parentPath.getLastPathComponent()); SelectedChildren=SelectedParent.getChildCount();

63

//System.out.printin(check);

if (check==true) { labell.setText("Performance can only be added once here!");

}//end if check==true else { DefaultMutableTreeNode parentNode=null; if (parentPath==null) { parentNode=root;

} else { parentNode = (DefaultMutableTreeNode)(parentPath.getLastPathComponent());

} Object child; child="Performance"; DefaultMutableTreeNode childNode = new DefaultMutableTreeNode(child);

//insert the node treeModel.insertNodeInto(childNode,parentNode,parentNode.getChildCount()); //set the new node to be visible tree.scrollPathToVisible(newTreePath(childNode.getPath())); textl.setText(""); check=true;

}//end else check==true }//end perform action_Performed

void bttnFinish_actionPerformed(ActionEvent e) { //This is essentially a big for loop, which fraveses the tree //and outputs the correct information to the file.

int a=0; int b=0; int c=0; int d=0; int f=0;

int rootNumChildren=0; int courseNumChildren=0; int unitNumChildren=0; int lessonNumChildren=0; int presNumChildren=0;

String rootChild=null; String text=null; String filename=null;

TreeNode courseNode=null; TreeNode unitNode=null; TreeNode lessonNode=null; TreeNode presentationNode=null;

String[] files = new String[]{"xml"}; jchooser.setMultiSelectionEnabled(false); jchooser.addChoosableFileFilter(newSimpleFileFilter(files,"XMLFiles(*.xml)"));

64

String CheckForTest=null; boolean finishedTest=false;

int option =jchooser.showSaveDialog(this);

if(option==JFileChooser.APPROVE_OPTION) { if(jchooser.getSelectedFile()!=null) { filename=jchooser.getSelectedFile().getAbsolutePath(); if (!filename.endsWith(".xml"))

filename=filename + ".xml";

fry { OutputStream fileout = new FileOutputStream(filename); Print Writer output = new PrintWriter(fileout);

rootNumChildren=root.getChildCount(); System.out.println("<!DOCTYPE Syllabus SYSTEM \"Syllabus.dtd\">"); output.prinan("<!DOCTYPE Syllabus SYSTEM \"Syllabus.dtd\">"); output.flushO; System.out.println("<Syllabus>"); output.println("<Syllabus>"); output.flushO;

for(a=0;a<rootNumChildren;a++) { System.out.println("<Course>"); output.println(" <Course>"); output.flushO;

System.out.print("<name>"); output.print(" <name>"); output.flushO; System.out.print(root.getChildAt(a).toString()); output.print(root.getChildAt(a).toString()); output.flushO; System.out.println("</name>"); output.printin("</name>"); output.flushO;

courseNode=root.getChildAt(a); courseNumChildren=courseNode.getChildCount(); if (courseNumChildren==0)

{ System.out.printin("</Course>"); output.printin("</Course>"); output.flushO;

}//end if courseNumChildren==0

for (b=0;b<courseNumChildren;b++)

{ System.out.printin("<Unit>"); output.println("<Unit>"); output.flushO; System.out.print("<name>"); output.print("<name>"); output.flushO; System.out.print(courseNode.getChildAt(b).toString()); output.print(courseNode.getChildAt(b).toString());

65

output.flushO; System.out.println("</name>"); output.println("</name>"); output.flushO;

unitNode=courseNode.getChildAt(b); unitNumChildren=unitNode.getChildCount(); if (unitNumChildren==0) { System.out.println("</Unit>"); output.println("</Unit>"); output.flushO;

}//end if unitNumChildren==0

for (c=0;c<unitNumChildren;c++) { CheckForTest=unitNode.getChildAt(c).toString();

if (CheckForTest=="Performance") { System.out.print("<performance>"); output.print("<performance>"); output.flushO; lessonNode=unitNode.getChildAt(c); System.out.print(lessonNode.getChildAt(0).toString()); output.print(lessonNode.getChildAt(0).toString()); output.flushO; System.out.println("</performance>"); output.println("</performance>"); output.flushO; finishedTest=true;

}//end if CheckForTest=="Performance" else { System.out.println("<Lesson>"); output.println("<Lesson>"); output.flushO; System, out. print(" <name>"); output.print(" <name>"); output.flushO; System.out.print(unitNode.getChildAt(c).toString()); output.print(unitNode.getChildAt(c).toString()); output.flushO; System.out.println("</name>"); output.println("</name>"); output.flushO;

}//end else if CheckForTest=="Performance"

lessonNode=unitNode.getChildAt(c); lessonNumChildren=lessonNode.getChildCount(); if ((lessonNumChildren==0) && (finishedTest==false)) { System.out.println("</Lesson>"); output.println("</Lesson>"); output.flushO;

} //end if ((lessonNumChildren==0) && (finishedTest==false))

for(d=0;d<lessonNumChildren;d++) { if(lessonNode.getChildAt(d).toStiing()=="Presentation") {

66

presentationNode=lessonNode.getChildAt(d); presNumChildren=presentationNode.getChildCount();

for (f=0;f<presNumChildren;f++) { System.out.print("<presentation>"); output.print(" <presentation>"); output.flushO; System.out.print(presentationNode.getChildAt(f).toString()); output.print(presentationNode.getChildAt(f).toString()); output.flushO; System.out.println("</presentation>"); output.printin("</presentation>"); output.flushO;

}//end f=0

if (presNumChildren==0) { System.out.println("</Lesson>"); output.printin("</Lesson>"); output.flushO; System.out.println("</Unit>"); output.println("</Unit>"); output.flushO; System.out.printin("</Course>"); output.println("</Course>"); output.flushO;

}//end if presNumChildren==0 }//end if Presentation

else if (lessonNode.getChildAt(d).toStringO=="Practice") { presentationNode=lessonNode.getChildAt(d); presNumChildren=presentationNode.getChildCount();

for (f=0;f<presNumChildren;f++) { System, out .print(" <practice>"); output.print( "<practice>"); output.flushO; System.out.print(presentationNode.getChildAt(f).toString()); output.print(presentationNode.getChildAt(f)toString()); output.flushO; System.out.printin("</practice>"); output.println("</practice>"); output.flushO;

}//end f=0

if (presNumChildren==0) { System.out.println("</Lesson>"); output.println("</Lesson>"); output.flushO; System.out.printin("</Unit>"); output.printin("</Unit>"); output.flushO; System.out.printin("</Course>"); output.println("</Course>"); output.flushO;

}//end if presNumChildren==0 }//end else if Practice

67

elseif(lessonNode.getChildAt(d).toString()=="Performance") { presentationNode=lessonNode.getChildAt(d); presNumChildren=presentationNode.getChildCount();

for (f=0;f<presNumChildren;f++) { System.out.print("<performance>"); output.print("<performance>"); output.flushO; System.out.print(presentationNode.getChildAt(f)toString()); output.print(presentationNode.getChildAt(f)toString()); output.flushO; System.out.println("</performance>"); output.println("</performance>"); output.flushO;

}//end f=0

if (presNumChildren-=0) { System.out.println("</Lesson>"); output.println("</Lesson>"); output.flushO; System.out.println("</Unit>"); output.println("</Unit>"); output.flushO; System.out.println("</Course>"); output.println("</Course>"); output.flushO;

}//end if presNumChildren==0 }//end else if performance

if ((d==lessonNumChildren-1 )&&(finishedTest==false))

{ System.out.println("</I^sson>"); output.println("</Lesson>"); outputflushO;

}//end if ((d==lessonNumChildren-l)&&(finishedTest==false)) }//end for d=0

if (c==unitNumChildren-1)

{ System.out.println("</Unit>"); output.println("</Unit>"); output.flushO;

}//end if (c==unitNumChildren-l) finishedTest=false;

}//end for c=0 if (b==courseNumChildren-l) { System.out.println("</Course>"); output.println("</Course>"); output.flushO;

}//end if (b==courseNumChildren-l) }// end for b=0

}//end for a=0 System.out.println("</Syllabus>"); output.println("</Syllabus>"); output.flushO; output.closeO;

68

}//end try

catch (lOException x) { System.out.printin("Error Saving!!");

} }//end if !null else { labelI.setText("PLEASE ENTER A FILENAME!!"); jLabell.setText("PLEASE ENTER A FILENAME!!");

} }//end if APPROVE OPTION

}// end bttnFinish

//This code is currently NOT used, but clears all nodes public void clear() { root.removeAUChildrenO; treeModel.reloadO;

}// end clear

/** Remove the currently selected node. */ public void removeCurrentNode() { TreePath currentSelection = tree.getSelectionPadi(); String blah=null; if (currentSelection != null) { DefaultMutableTreeNode currentNode = (DefaultMutableTreeNode)(currentSelection.getLastPathComponent()); MutableTreeNode parent = (MutableTreeNode)(currentNode.getParent()); //System.out.println(parent); if (parent != null) { fry

{ //System, out. println(parent); //System. out.println(currentNode); currentNode. setParent(parent); remove=true; treeModel.removeNodeFromParent(currentNode); remove=false; tree.addSelectionRow(O);

}//end try

catch(NullPointerException exc) { System.out.printin("ERROR!");

}//end catch return;

}//end if parent !=null }//end if currentSelection !=null

}//end removeCurrentNode

/** Add child to the currentiy selected node. */ public DefaultMutableTreeNode addObject(Object child) { DefaultMutableTreeNode parentNode = null; TreePath parentPath = tree.getSelectionPath();

if (parentPath == null)

69

parentNode = root; else

parentNode = (DefaultMutableTreeNode)(parentPath.getLastPathComponent());

return addObject(parentNode, child, true); }//end addObject

public DefaultMutableTreeNode addObject(DefaultMutableTreeNode parent,Object child) { return addObject(parent, child, false);

}// end addObject

public DefaultMutableTreeNode addObject(DefaultMutableTreeNode parent,Object child,boolean shouldBeVisible) { DefaultMutableTreeNode childNode = new DefaultMutableTreeNode(child); if (parent == null)

parent = root;

treeModel.insertNodeInto(childNode, parent,parent.getChildCount());

// Make sure the user can see the new node, if (shouldBeVisible)

tree.scrollPathToVisible(newTreePath(childNode.getPath()));

return childNode; }//end addObject

class Listener2 implements TreeSelectionListener! public void valueChanged(TreeSelectionEvent tse){

if (remove==true)

{ remove=false; //System.out.println("Hey I am removing!");

} else

//System.out.println("Hey I am NOT removing!"); TreePath tp= tse.getNewLeadSelectionPath(); int count=tp.getPathCount(); boolean LessonPresentation; boolean AddedUnitTest=CheckThis(); boolean AddedTestinfo=CheckForTest(); LessonPresentation=CheckLesson(tp); int SelectedChildren=0; //System.out.printin(AddedUnitTest); if (LessonPresentation==true)

{ count=5;

// CreateLesson.UnitTest=true; UnitTest=true;

} else

UnitTest=true; //CreateLesson.UnitTest=false;

switch(count) { case 1:

textl .setEnabled(true); UnitTest=false;

70

tree.setEditable(false); Current_State="root"; textl.setText(""); labelI.setText("Please Enter a Course Name"); present. setEnabled(false); pract. setEnabled(false); perform.setEnabled(false); bttnChild. setEnabled(true); break;

case 2: textl .setEnabled(true); UnitTest=false; tree. setEditable(true); Current_State="Course"; textl.setText(""); labell.setText("Please Enter a Unit Name"); present. setEnabled(false); pract. setEnabled( false); perform. setEnabled(false); bttiiChild. setEnabled(true); break;

case 3: text 1. setEnabled(true); UnitTest=false; tree. setEditable(true); Current_State="Unit"; textl.setText(""); labell.setText("Please Enter a Lesson Name or a Unit Test"); present.setEnabled(false); pract. setEnabled(false); DefaultMutableTreeNode SelectedParent=null; SelectedParent = (DefaultMutableTreeNode)(tp.getLastPathComponent()); SelectedChildren=SelectedParent.getChildCount();

if (SelectedChildren==0) perform. setEnabled(true);

int i = 0; for(i=0;i<SelectedChildren;i++)

{ if(SelectedParent.getChildAt(i).toString()=="Performance")

{ perform.setEnabled(false); tree.setEditable(false); break;

} else perform. setEnabled(true);

}//end for bttnChild. setEnabled(true); break;

case 4: textl .setEnabled( true); UnitTest=false; tree. setEditable(true); Current_State="Lesson"; textl.setText(""); labell.setText("Please Make a Selection");

71

present.setEnabled(true); pract. setEnabled(true); perform. setEnabled(true); bttnChild. setEnabled(false); break;

case 5: UnitTest=false; Current_State="ThreeP"; textl.setText(""); Iabell.setText("Please Enter a Complete File Name or URL"); if (AddedTestinfo!=true) { textl .setEnabled(tiaie); free.setEditable(false); present. setEnabled(false); pract. setEnabled(false); perform. setEnabled(false); bttaChild.setEnabled(true);

} else { text 1. setEnabled(false); tree. setEditable(true); present. setEnabled(false); pract. setEnabled(false); perform. setEnabled(false); btmChild. setEnabled(false);

} break;

case 6: text 1. setEnabled(tme); UnitTest=false; tree. setEditable(true); Current_State="END"; textI.setText(""); labell.setText("You Cannot Add Anything Here!"); present. setEnabled(false); pract. setEnabled(false); perform. setEnabled(false); bttnChild.setEnabled(false); break;

default: System.out.println("IN DEFUALT"); break;

}// end switch

//System.out.printin(count); jLabell.setText("Selected: " + tp.getLastPathComponentO); //Selection=tp. toS tringO; //System.out.printin(Selection); remove=false;

}//end else remove==true }//end valueChanged(TreeSelectionEvent tse)

}//end class Listener2 implements TreeSelectionListener!

public boolean CheckThis() { int SelectedChildren=0;

72

TreePath parentPath = tree.getSelectionPath(); DefaultMutableTreeNode SelectedParent=null; SelectedParent = (DefaultMutableTreeNode)(parentPath.getLastPathComponent()); SelectedChildren=SelectedParent.getChildCount(); int level=0; level=parentPath.getPathCount(); if ((level==3) && (SelectedChildren>0)) { //System.out.println(Current_State); int i = 0; for(i=0;i<SelectedChildren;i++) { if(SelectedParent.getChildAt(i).toString()=="Performance")

return true; }//end for

}//end if return false;

}//end checkthis

public boolean CheckPerformanceChild()

{ int SelectedChildren=0; TreePath parentPath = tree.getSelectionPath(); DefaultMutableTreeNode SelectedParent=null; SelectedParent = (DefaultMutableTreeNode)(parentPath.getLastPathComponent()); SelectedChildren=SelectedParent.getChildCount(); int level=0; level=parentPath.getPathCount(); if ((level==4) && (SelectedCliildren>0))

return true; return false;

} //end CheckPerformanceChild

public boolean CheckForTest()

I int SelectedChildren=0; TreePath parentPath = tree.getSelectionPath(); DefaultMutableTreeNode SelectedParent=null; TreeNode parent=null; SelectedParent = (DefaultMutableTreeNode)(parentPath.getLastPathComponent()); String info=null; int level=0; level=parentPath.getPathCount(); //System.out.print("Level is"); //System.out.prinfln(level); if(level==l)

info=SelectedParent.toString();

else

parent=SelectedParent.getParent(); info=parent.toString();

} //System.out.printin(info); if ((level==5) && (info=="Performance"))

return true; return false;

}//end CheckForTest

public boolean CheckLesson(TreePath tp)

{ int SelectedChildren=0;

73

//System.out.prinfln(Current_State); DefaultMutableTreeNode currentNode = (DefaultMutableTreeNode)(tp.getLastPathComponent()); int level=0; level=tp.getPathCount(); String stringOne=currentNode.toString(); if ((level==4) && (stringOne=="Performance")) return true;

return false; }//end CheckLesson

}//end EDIT

74

PERMISSION TO COPY

In presenting this thesis in partial fulfillment of the requirements for a

master's degree at Texas Tech University or Texas Tech University Health Sciences

Center, I agree that the Library and my major department shall make it freely

available for research purposes. Permission to copy this thesis for scholarly

purposes may be granted by the Director of the Library or my major professor.

It is understood that any copying or publication of this thesis for financial gain

shall not be allowed without my further written permission and that any user

may be liable for copyright infringement.

Agree (Permission is granted.)

Sttident's Signature (/ Date

Disagree (Permission is not granted.)

Student's Signature Date

HECKMAN BINDERY INC.

SEPT99