MILE: A Markup Language for Interactive Drill Courseware

MILE: A Markup Language for Interactive Drill Courseware
Geoffrey M. Rockwell
McMaster University
grockwel@mcmaster.ca
Joanna Johnson
McMaster University
johnson@mcmaster.ca
Rocco Piro
McMaster University
piro@mcmaster.ca
Keywords: multimedia, education, markup

The Faculty of Humanities at McMaster University has, since 1986, developed a substantial amount of interactive language courseware in an environment called mcBOOKmaster. As mcBOOKmaster is a DOS program these materials look dated, cannot easily be updated with multimedia content, and cannot be ported to other platforms like the Macintosh. More importantly mcBOOKmaster content was encoded in a markup language that was designed for the DOS screen, and cannot easily be massaged into a form usable elsewhere. For this reason in 1994 we started developing the MILE environment and the accompanying MILE Markup Language (MML). While this paper will demonstrate the MILE environment, the primary focus will be on the design of the markup language.
Specifically, in this paper we will do the following:

Discuss the history of interactive drill software at McMaster, showing the need for a well designed markup language for interactive lessons of this sort.
Demonstrate the types of courseware that can be produced with MILE and the process of creating a particular lesson from a MML script.
Discuss the design of the MILE markup language.
Discuss the future of the MILE environment.
A short history of MILE
McMaster University has been using drill style courseware in language classes since our first experiments in 1986 under the direction of Dr. Samuel Cioran. In the late 1980s Dr. Cioran and Joanna Johnson developed the mcBOOKmaster environment which interprets appropriately marked up text files and presents the user with fill-in-the-blank and multiple-choice style exercises. The mcBOOKmaster environment is simple, robust, will work on almost all well behaved DOS computers, can be used to create printed documentation, and can be distributed easily with lessons on a single diskette. With it, instructors at McMaster and elsewhere, have created numerous titles for French, Italian, Russian, Linguistics, and German. One of its great strengths was that instructors could create materials easily without learning an authoring environment. They could use their word-processors to create their lessons.
More information about mcBOOKmaster is available at http://www.humanities.mcmaster.ca/~hcc/software/mcbook.htm.

mcBOOKmaster also has some limitations worth mentioning:

It cannot handle multimedia content like sound, or digital video. Many instructors now expect to be able to build multimedia exercises.
Due to the way the markup language was designed to work with the DOS screen the content cannot easily be parsed and converted into other forms like HTML.
This means that one cannot make mcBOOKmaster lessons available over the Internet or on a Macintosh.
For this reason we set out to create a successor to mcBOOKmaster that kept its good features and basic paradigm while moving to a more functional markup language. The MILE environment has the following characteristics:
Like mcBOOKmaster, in MILE the instructor creates lessons by creating marked up text files for processing.
Unlike mcBOOKmaster, in MILE the MML script is run through a Lesson Builder that then creates the courseware. The Lessons can then be modified and enhanced by a programmer, should that be needed. It also means we can have different Lesson Builders for different platforms or purposes.
Thus MILE supports multiple platforms and MML scripts should be reusable as new platforms emerge in the future.
MILE allows custom "looks" to be created for different lessons so that authors can have a unique graphic design for their lessons. This can be important when commercializing courseware.
Using the first version of MML and a first Lesson Builder implemented in ToolBook an instructor created materials for a Critical Thinking course that was first taught with the resulting software in the Fall of 1995. The first version of MML has thus been used for over a year by over 1500 students. We have now developed a second version of MML, enhanced the PC Lesson Builder, and created a Macintosh Lesson Builder. This is being used to develop courseware for computing, history, and French.
How does it work? A Demonstration
At this point in the paper we will switch to an appropriately configured PC and demonstrate the MILE environment. We will demonstrate the following:
A simple MILE script that illustrates the different types of exercises possible,
Building a Lesson with a Lesson Builder for Windows, and
The resulting Lesson.
The MILE markup language is intended for the creation of linear drill-style interactive courseware. An instructor creates a text file that is coded with MILE markup which can then be run through a MILE Lesson Builder to create an interactive lesson. The markup language, which resembles HTML (though it serves a different purpose) allows instructors to easily create interactive materials without mastering an authoring environment. All they need is a word-processor, which most humanists have, and an understanding of the markup language.
The design of the MILE Markup Language
The MILE Markup Language has evolved since the first version was used for developing Critical Thinking software. As it evolved we were forced to explicitly think out our design philosophy. The following are some of the characteristics we strove for:
First of all, MML is open so that any can use it without special permission as long as they clearly state that they are using it and which version of it. All are encouraged to build tools that create or use MML - the greater the number of conformant tools the better for all. One reason for MML is to encourage compatibility among such linear drill systems so that instructors can create content once and then move it from platform to platform over time.

Second, MML was designed to be as simple as was possible so that instructors who were familiar with only a word processor could be trained to create materials. By separating the creation of the script (which can be done with any text editor) from the creation of the Lesson with a Lesson Builder you don't have to have professional staff involved in a project except at the end when the scripts are run through the Lesson Builder or if you want to customize your Lesson after building. Our experience is that many instructors can, with further training build their own lessons using a Lesson Builder. We have also found that instructors can be taught to modify compiled Lessons where they want closer control over the look. This provides a way into authoring that does not involve learning all about an authoring system before you can do anything.

Third, MML was designed to encode the logic of a lesson, not the look. This allows us to separate the content from the implementation and graphical design. This is important when you have, as we do at McMaster, a substantial investment in carefully designed exercises. There is no reason why courseware should have to be rewritten from scratch each time the platform of choice changes or the fashions in interface design change. MML allows one to encode lessons so that your content can move over time from platform to platform, and from look to look.

Fourth, MML was designed for one application: to encode linear, interactive, drill-style lessons. By these we mean courseware where the user moves through a linear sequence of exercises (we do provide some branching features and hypertext annotation features). MML was not designed as an alternative to HTML or TEI. It is possible to create HTML pages with JavaScript code in them or combinations of HTML and CGI programs that can behave as MILE Lessons, but you cannot encode the interaction in HTML. (You cannot present three answers to a multiple choice question and indicate which is the correct answer and what should be done when the correct answer is pressed.)

Fifth, to keep MILE simple, we settled on four design principles:

All codes are surrounded by angle brackets <> as in most SGML applications like HTML.
Tags don't have to be closed except where necessary. When a tag has to be closed then it is paired with an off-tag that has a forward slash before the code, e.g.. </>.
There are no parameters within the tags. The whole script should be a sequence of tags and their content. Where we needed parameters they are treated as a type of content.
All Lesson and Exercise codes are two letters. All field codes are one letter.
At this point we will show a MML script that illustrates these design features. In our demonstration of a script we will point out the following things:
Lesson level codes that control the whole lesson or large parts of it. We will at this point discuss the three levels of codes: Lesson, Exercise, and Field.
An example exercise that illustrates many of the exercise features.
An example exercise that has a passage with embedded field tags that illustrate the field codes.
The future of MILE
Over the next couple of years the MILE project hopes to create a Lesson Builder for the WWW which would translate MML into a combination of JavaScript and HTML. We also hope to create a SGML DTD so that we can take advantage of the SGML tools available. This, along with input from users who desire more functionality, may lead to further revisions to MML. Finally, we expect to work with others who are interested in alternative tools that use MML and extend it.