Design and Development of Melbourne IT CreatorTM – a System for Authoring and Management of Online Education.

  Steve B. Goschnick
Department of Computer Science
The University of Melbourne Parkville,
Victoria 3052, Australia
July, 1998  



This paper presents a Case Study in the symbiotic use of new internet based technologies and an SQL server, to develop a software tool in a new category of generic software: a system for authoring and delivery of web-centric learning. In the design and implementation of the system, the developers drew upon the latest available languages and platforms, aiming for a high benchmark in this new software genre: Java for cross platform authoring tools; JavaScript and HTML V4 for scripting and markup; applets, video and other media types as object components; IIS (Microsoft’s Internet Information Server technology) to deliver dynamically constructed HTML markup. Behind the interfaces and business rules is robust SQL server technology, which is taking on an expanded role in proliferating web-based information systems. In the latter half of the paper, problems and solutions are discussed, including the use of metadata and XML (the eXtensible Markup Language) as part of the solutions.


1: Introduction


This paper partially documents the experience in specifying and developing an ambitious product in the rapidly moving fields of Internet web technology and distributed multimedia learning objects. It takes an innovative company with a committed focus on education, research and intellect property, to undertake such a project in these uncertain technological times - an era when major software tool vendors are more often in court than not, attempting to prove the others intent at monopolizing markets and breaking open standards.

The development of Melbourne IT CreatorTM - the underlying subject of this paper - is one companies attempt to genuinely advance the tools available to online educationalists (whilst not trying to derail any of our perceived competitors), so that teachers may get on with online endeavours useful to the students of mankind, in fields beyond market dominance, corporate law and dry economics.

Towards the end of this paper, a serious effort is made to flag any technologies and standards that were used during this project development, which do appear to be consolidating as certainties in the near future of software development.


2: Knowing the users, the users and the users


3: Technical goals


The most significant technical goals for the system development set at the outset, were:

There is a delicate tradeoff between the third and fourth goals, with significant risk involved in trying to pick a standard early. Prototyping with an open mind to technologies and tool vendors is most important in the pre-standard phase of an evolving area of Computer Science - scripting languages in proprietary web browser technologies, being the main example during the course of this project.

The selection of SQL amongst the setting of goals, was a more multifaceted decision than is usual, and therefore worth expanding on:

    Figure 1. Birds-eye view of Melbourne IT Creator™V1 database schema  

4: System Analysis and Design.


From the requirements of the various users outlined above, I did a system analysis and design, which included an extensive database schema, in January '97. A proof-of-concept was rapidly developed in the two following months, dubbed the Version 0.5. It had several purposes: to gauge the technical chances of a successful product; to get some early usability feedback for a generic product for which no obvious predecessor existed in the marketplace; to attract internal and external support for what was an ambitious project; to rationalize and refine the initial design.

With some tradeoffs to reduce complexity, the schema was narrowed down to 56 entity tables, which hold both media content and administrative data [3,4]. A cursory glance of the birds-eye view in Fig. 1 above, reveals a convergence of relationships about two tables in particular (marked as black rectangles): one is the generic Object entity, centre-left in the figure and the second is the Person entity, centre-right. Generally, the tables that are clustered around the Object entity are content specific, while those clustering around the Person entity are administrative specific. Naturally there are tables with relationships to both these sub-areas of the Creator schema, e.g. Object_Author, see Figure 2 below.


Figure 2. All Creator objects have generic properties, persistently stored as attributes of the table named OBJECT and in related tables via their attributes.


4.1: Object components


Although MS SQL Server V6.5 is a relatively standard relational database system, the Creator design built upon it, is really an Object-Relational system, enacted via custom-coded Java classes which use the JDBC interface to SQL Server tables. There are 15 internal Creator object types that are fully catered for within the Creator system, as follows:

    1. ICON
    2. IMAGE
    3. HTML_TEXT
    5. PAGE
    10. VIDEO
    11. AUDIO
    13. DOCUMENT
    15. EXTERNAL OBJECT (Applet, ActiveX, Shockwave, etc)


The 15th type, External Object, includes support for many other objects types such as: Java Applets; Shockwave Applets; ActiveX controls; etc – basically anything that can be displayed in a bounding rectangle, within an HTML V4 browser window, during the page authoring process. Such external object types may take numerous parameter types such as: environment, input, and output parameter types, and then any number of actual parameters. It is then up to the customers of Creator to enable all their relevant client machines to support the various external object types that they have decided to allow within their courseware (i.e. they'll need to install the appropriate browser or browser plug-ins).


Figure 3. All Creator object types can be accessed via the Resource Palette.

All objects share the common base of properties represented in Figure 2. Whenever a particular object is re-instantiated, the base information is read from SQL by a Java coded super-class, from which all other object types are derived. Then, the extra persistent properties for a specific object type, are correctly read from appropriate associated tables.

At a certain basic level, all objects are equal within the Creator system. Figure 3 represents a screen-shot of the Resource Palette, which is one of the tools within the Creator Authoring Tools package [5], written in Java V1.1. The different icons represent different object types, while specific individual objects have individual names. Though the view seen here is a grid-layout view, the user may flip to a table view of resources, in which each object occupies one whole line of the display, allowing the user to inspect more detailed object information. In addition, a property-sheet window may be popped-up via the right-mouse button for any object within the current Resource Palette, to inspect the full property details of an object - including recursive references to embedded sub-objects (e.g. an Image within a Page within a Reference-work).

A consequence of all content being represented by objects, is that common functionality such as keywords, can be used to reference all types of content, e.g. videos and applets. Hence, by using keywords, the same search strategies and interfaces can be used to find any sort of content, even if different indexing methodologies are used to assign those keywords.

[Note: The menus, toolbars and layouts of the GUIs featured in Figures 3, 4, 5 and 6 are largely courtesy of JavaSoft's recent JDK/Swing UI interface classes. The earlier beta version of the Creator Authoring Tools where based on in-house developed GUI components, by necessity. However, because the Java V1.1 event-model was programmed to, from the beginning, the conversion to JFC/Swing components took less than one week].


4.2: Simple creator objects


Most of the 15 object types are termed simple Creator object types, because they are self-contained e.g. Icon, Image, Animation, even Video, are self-contained object types. Most of these objects are created outside of Creator, i.e. Image would typically be a .GIF or a JPEG file, created in some specialised paint or art program. Video is typically a QuickTime file.

However, there are two particular simple Creator object types, which are authored within the built-in Creator Authoring Tools, namely: HTML-text and HTML-table objects, both of which are catered for by special WYSIWYG (What-You-See-Is-What-You-Get) editors.


4.3: Complex creator objects


There are some complex object types in the Creator system, complex in the following ways:

Complex Creator object types include: Reference-work; Learning-activity; Page; Question; Resource-Palette. I'll expand a little on Reference-work and Learning-activity:


4.3.1: Hypermedia reference works

A Creator Reference-work is a hierarchical arrangement of pages. A Creator Page object is equivalent to an HTML page, from the browsers point of view. However, unknown to the browser, such pages are dynamically constructed behind the scenes from other objects, both simple and complex ones. So a hypermedia online book or even an encyclopedia with images, sounds, animations, applets and videos, placed throughout the text, can be constructed within Creator as a single Reference-work. Figure 4 below, is a screen-shot of the deceptively simple opening screen of The Outliner, the built-in authoring tool used to create and edit a Reference-work. Each node on the Outliner tree represents a Page object, equivalent to a HTML page - the basic building block of the Web.

Figure 4. Opening UI screen of The Outliner

Apart from the hierarchical contents-page-like opening interface of the Outliner, normal HTML hyperlinks can be inserted within any page in a Reference-work, linking them to other internal pages or external URLs, in a networked hypertext manner.


4.3.2: Generic learning activities

The complex object type Learning-activity is a generic model that caters for the online rendering of numerous learning activities, with conventional names like:

Lecture; Tutorial; Lab Session; Prac Session; Case Study; Exercise; Exam; Test; Assessment unit; Period; etc.

The term Learning-activity is a generic name used within Creator, for any type of activity that has associated with it, a set of milestones or goals. The other main difference between Creators Learning-activities and Reference-works, is that Learning-activities have a network of inter-relationships, graphically created during the authoring process, based on conditions. See Fig. 5 further down, which represents a screen-shot of the Page Linker (also sometimes called the Networker), the Creator Authoring Tool used to create Learning-activities.

5: The Authoring Tools

The Creator Authoring Tools custom-coded in Java V1.1 and the JDK/Swing, are largely for the creation and editing of the complex object types: Reference-work, Learning-activity, Page and Question. See Table 1 below, for an overview of which Authoring Tool is used to edit what complex object type.

Tool Name

Creator object-type 


The Outliner (tree structure)


Figure 4. 

Page Linker (network struct.)


Figure 5.

Page Designer


Figure 6.

Question Editor



Resource Palette

can hold any/all object types

Figure 3.

  Table 1. Authoring Tool name, by edited object-type, by screen-shot.

The Figure 5. The Page Linker, used to build networks of paths between pages.

Page Linker is used to create and edit Learning Activities of all sorts, by constructing a network of paths and using Question objects to provide alternative user-driven hyperlinks. Question objects are constructed with the Question Editor - a sub-component of the Page Linker. Currently it can be used to create and edit several question types that transparently allow the browser user to interact with out-of-line links, i.e. multi-choice links, much like the newly proposed Xpointer links in XML [6]. In Creator they are activated via standard HTML V4, CSS and JavaScript, in a code module called the Content Viewer [7].  

Creator’s Learning-activities and Reference-works can be thought of as two styles of online interactive documents, each made up of numerous related pages. The Page object has special significance within Creator, in that it is outwardly equivalent to an HTML browser page. Fig. 6 below, is a screen-shot of Creator's WYSIWYG HTML V4 editor, the Page Designer. It allows the user to drag-and-drop all object types which can have a rectangular representation on-screen, i.e. HTML-text boxes, HTML-table, Image, Video and External-Object types including: Java Applets, JavaBeans, Shockwave and ActiveX controls.


Figure 6. Page Designer, a WYSIWYG editor used to glue together various Creator objects using underlying HTML V4 markup.


6: Characteristics of the resulting system.


Some interesting characteristics and observations drawn from the resulting system include:

  1. Instantiates complex objects from persistent data held in a standard SQL server.
  2. Holds Learning Activity repositories.
  3. Holds Reference Work repositories.
  4. Instantiates a user profile via the Administration System.
  5. Provides an online Examination system, also based on the dynamic multi-pathed Learning Activity model.
  6. Has sophisticated WYSIWYG authoring tools for creating and editing objects.


7: Problems encountered and their solutions

Obviously a project of this size, scope and mixture of evolving technologies and standards, came with considerable problems, both in technical and management terms:


7.1: Staff recruiting and rival technologies


As the newly appointed Project Manager in May’97 for version V1, my first task was to build up the necessary team. I started with just one software engineer who had been involved in the proof-of-concept (POC) which had been contracted to a related company (Clearview Pty Ltd, a Melbourne IT incubator company [8]). The POC included some browser interfaces to about one-quarter of the tables in the first design, using Microsoft IIS [2] and .ASP files (HTML with embedded JavaScript, which IIS uses to build HTML on the fly, via calls to SQL). Some content object types were enabled in the POC, but it wasn't possible for non-programming users to author them.

I took the project down two distinct technology paths to cater for the different user groups outlined in section 2 above, which meant building up two teams with different skills. It took until December '97 to get the two teams to full strength with six software engineers apiece:

Team 1 skills: SQL Server, IIS, HTML and JavaScript for dynamic web coding;

Team 2 skills: Java for the WYSIWYG Authoring Tools.

Melbourne IT P/L, as a commercial entity owned by the University of Melbourne, has several advantages in developing new technology, one of which is recruitment, via its proximity to the Department of Computer Science (one floor away). I hired five recent graduates most of them with double degrees, high final grades and good recommendations. Several of them had dabbled in Java in their course related project work – projects done for industry clients. I put some of them through industry based Java training courses. I hired two team leaders with 3 and 5 years of commercial hardened experience, who’d previously worked for Microsoft Solution Providers, to provide each team with complementary skills: open-mindedness to new technology and multiple vendors; and team leadering. More than anything else, this skill mix has enabled the Creator Team to deliver an ambitious, complex project, using cutting-edge technology at the forefront of a new application software genre.

A benefit of the difficult technological mix was that a constructive, friendly, rivalry developed between the Java team and the IIS/Dynamic Web team. Though they worked in different technologies, there were two common elements of the technology that affected both: the SQL backend and the client window front-ends. The embracing of both Java and IIS technologies removed more technical problems than it created. The technical synergy between system programming languages and scripting languages experienced during this project, is getting timely recognition in software engineering literature [9].

The complexities and problems went from technical ones to management ones: e.g. double the coordination and versioning of code modules. To maintain Creator team cohesion and keep in check the cross-team rivalry, off-site one-day team building events were held during the course of the project, to reinforce a sense of One Team, One Goal. With competitive vendors openly warring in the public arena on a constant basis, such team events are not just useful but have become necessary when using multi-vendor tools and platforms.


7.2: Early adopters beware


A management decision was taken to release alpha versions to a few early customers (at their own risk) and then attempt to cater for their needs during development of the generic product. Since a lot of the raw material for an online course consists of components: images, HTML-text, videos, animations, other simple-objects - a lot of material is not necessarily wasted, if a version of the generic system changes substantially. Therefore, several willing early adopters were found. The intention was to give the product an early commercial focus and to add pressure and focus to the young team, but the consequences were too often:


7.3: Design oversights


There were two significant positive aspects arising from the intake of early customers that helped to counter the associated problems. Firstly, a few design oversights were uncovered earlier than would otherwise have been the case. Secondly, it forced the early bedding-down of the database schema design, while application coding continued and functionality grew. Note: The database schema was really a second generation version, as significant refinement of the design came out of the POC version.


7.3.1: Externally authored pages

While one goal was to develop a WYSIWYG HTML authoring tool, in the first release it was never intended to be a complete drag-and-drop, fully-featured HTML V4 editor. Instead, a subset of tags representing a solid core of HTML V4 tags were supported, with particular emphasis on cascading style sheets (CSS), to place the rectangular representation of objects within the browser window, at (x,y) locations chosen by the user at design-time, using drag'and'drop. A perceived marketing strength of the Authoring Tools was that they would run across all major platforms (Windows, MAC and Unix), rather than do everything, on just one platform. The plan was then to cover all HTML V4 tags in a follow-up version of the Page Designer.

A problem that grew from this partial treatment of HTML, picked up by the early adopters, was the requirement to import some individual pages into a Creator Reference Work or Learning Activity, that had been authored in third party HTML authoring tools.

The Creator Page entity and the On_page_object entity had enough design flexibility to handle this new requirement for externally authored HTML pages with minimal change, due to the Data Normalization techniques used in the original Data Analysis, and to the use of Booch methodology for the interfacing Java classes. It simply required an import mechanism to place the externally authored pages at appropriate pre-determined URLs on a Creator Server, where the IIS/.ASP code could expect to find them. It was a one week fix.


7.4: Extended problems and their solutions, in the pipeline


Reference-works and Learning-activities authored in Creator are persistently stored across many database tables. While the authoring tools and the browser interface can readily access them, page-by-page in a client window, the transfer of such a document type, from one installation (database), to another, represents a significant import/export programming task. Ideally it requires an ASCII encoded go-between format, one that preferably retains the data structures, while in the transient state between databases.

A second consequence of the database backend, is that all content can be and usually is, put behind a username+password access screen. This is good for controlling access to commercially sold instructional material developed in Creator, but it prevents search engines from finding and indexing Creator-held content, thereby impeding potential discovery by new courseware customers. Both these problems are being addressed by drawing upon the XML language, for neat and clean solutions, involving metadata.


    7.4.1: XML in a nutshell

    The widely embraced XML (eXtensible Markup Language) - enables software developers and content publishers alike, to structure data in an ASCII file format. XML is being seriously considered as the foundation technology to transform the Internet from a globally distributed information system to a globally distributed knowledge system [10]. There is a strong parallel between an SQL database schema and an XML DTD (Data Type Definition) file. An XML DTD can be thought of and used as, an ASCII rendered database schema. Similarly, the actual data records in an XML file conforming to a specific XML DTD, are essentially ASCII database records, i.e. a lightweight database system with no vendor DBMS such as ORACLE or MS SQL Server, necessary – hence, one of the attractions of XML to current web publishers, including online educational content developers.


    7.4.2: Importing and exporting content via XML

    Given the SQL backend and the componentized nature of the data, getting content and other data between Creator database installations (e.g. between home and office PCs), or between Creator and other systems, requires an import and an export operation. A proprietary XML DTD, which represents all the complexities of the current Creator SQL schema, is currently being developed at Melbourne IT, to specifically streamline import and export of complex object content.


    7.4.3: EML, the Educational Metadata Language

    Melbourne IT is in the process of developing a metadata language, dubbed Educational Metadata Language or EML, to facilitate metadata output from Creator. The main purpose of EML metadata is to present information in publicly accessible XML and HTML file/s, that adequately advertises to human web-surfers and web search engines alike, the details of instructional content held within any given Creator Server site [11,12]. The metaphor used is that of the Department Handbook, with course and subject information outlined uniformly.


    7.5: Complexity in using SQL server technology


    The Creator V1 database schema consists of 56 inter-related tables, making it a complex database system. This is partly due to the ambitious nature of the project (almost a Virtual University, plus Authoring Tools) and partly due to the design not being a simple relational database schema, but one that uses SQL Server to serve as a persistent store of objects - both simple and complex ones.

    From a users point of view the complexity is hidden behind friendly GUI interfaces and WYSIWYG authoring tools. However, it is still worth identifying and differentiating the types of data held in SQL tables, in a quest to see where XML might be gainfully employed to simplify things when XML browser technology becomes mainstream:

    It is in the latter area of the complex object types that XML may help in the future, if large percentages of browser users end up using XML+ HTML parsing browsers. For example, tree-structures such as those used by outliners, are very well suited to XML.


    8: Conclusions


    In developing Creator, the use of old technology in the form of SQL and new technology in the form of Java, HTML V4 and JavaScript, has proven a successful strategy to deliver an innovative product, in a new genre of software: authoring and delivery tools for online education. Drawing from the experience, what follows are several wide ranging personal insights and conclusions, about the future of some of the main technologies used:


    8.1: Java is ready for prime time

    With the release of Java V1.1, the distributed Java event model came of age. With the recent release of the JFC/Swing GUI component package, as demonstrated by the Creator Authoring Tools interfaces, Java has gained a professional UI toolset. Performance improvements remain as the most significant aspect of Java that requires timely attention from JavaSoft Inc. There are positive signs that this is happening: while performance benchmarks between C/C++ and Java are not in Java's favour, comparisons between Java and the more populist language Visual BASIC, definitely are in Java’s favour.

    I view the performance arguments for programming in either C/C++ vs. Java, as analogous to the old performance arguments between character-based interfaces and GUIs: the non-performance gains by using Java over C/C++ are of that same order of magnitude of using GUIs over character-based UIs. Some performance hit will be more and more tolerated by developers, as the language settles down and the standard hardware platform gets faster and has more memory.

    The biggest strength of Java I’ve seen in context of the Creator project was in the productivity that recent graduates can achieve in Java, without the go-slows via pointer errors and other difficult bugs, that a project manager usually sees with the same cohort of programmers using C/C++ tools.


    8.2: SQL is holding its own


    The relational theory behind SQL servers formed a very solid foundation for information systems. While OOP languages such as C++ and Java are a quantum advance over procedural languages, many made the mistake of assuming OODBMS’s would leapfrog Relational DBMS - not so. As discussed earlier, the extra life gained by SQL Servers is largely to do with the best time and place to instantiate an object: sometimes it is client-side, other times it is server-side. So we’ve seen some SQL server vendors adding Object-Relational APIs to their wares, and there are numerous application developers adding their own Object-Relational API’s to SQL servers, as is the case with Melbourne IT Creator™.


    8.3: Application areas where SQL server technology has ongoing advantage


    Here are the most compelling ongoing reasons for storing certain information types within tables in an SQL server, now and for some considerable time to come:


    XML today and tomorrow


    XML has immediate and significant uses in importing and exporting complex data between applications, and in metadata definitions and rendering. Whether these applications use open standard or propriety XML DTD definitions, doesn’t affect the viability of XML as a major standard language for defining other languages and definitions – it is already safely home in this regard.

    Looking forward a little, if the mainstream browsers do become standard XML parsers (for information structure), as well as HTML/CSS/XSL parsers (for information presentation), as seems probable, then XML will take on a wider role including many of the areas where Relational DBMS are currently employed in web-based distributed systems, and in new areas such as data storage on handheld devices.



    1. Lagoze, C., Lynch C.A. and Daniel R., Editors (1998). HTML V4.0 Specification. W3C Recommendation, April 1998, URL
    2. IIS White Paper. Internet Information Server. Follow URL
    3. Goschnick, S., Smart, T., Bruno, A. and McMaster, T. (1998). Creator V1.0 Database Design Document. Melbourne IT Internal Report.
    4. Ahmed E.U. and Smart, T. (1998). Creator V1.0 Detailed Design - Functional Security System, Melbourne IT Internal Report.
    5. Goschnick, S.B., McMaster, T., Valentine and D., Bakal (1998). Creator V1.0 Detailed Design - Authoring Tools, Melbourne IT Internal Report.
    6. Bray T., Paoli J. and Sperberg-McQueen, C. M., Editors (1998). Extensible Markup Language (XML) 1.0, W3C Recommendation. URL
    7. Saengpetch, S. (1998). Creator V1.0 Detailed Design - Content Viewer System, Melbourne IT Internal Report.
    8. Melbourne IT Incubator Companies. Home page of Melbourne IT P/L, URL
    9. Ousterhout, J.K. (1998). Scripting: Higher-Level Programming for the 21st Century. Computer, March’98 issue, pp23-30.
    10. Cassin, A. (1998). Survey of XML Technology. URL University of Melbourne.
    11. Cassin, A. (1998). Survey of Metadata Technology. URL
    12. Cassin, A. and Goschnick, S.B. (1998). System Requirement Specification for Melbourne IT Creator Metadata Agent. Internal Report, pp.23, July’98.

    Some Melbourne IT CreatorTM Web-sites:

    1. Home Page of Melbourne IT Creator. URL
    2. An Introductory AI course is being developed and delivered using Melbourne IT Creator V1. Currently under-construction at: URL


    Steve Goschnick B.E. has 19 years experience as a software developer, software publisher and IT manager. He has written numerous conference, magazine and newspaper articles on software related issues. He wrote a weekly column called Cutting Code for the computer section of The Age Melbourne daily newspaper throughout 1993. He did the analysis and design for Melbourne IT Creator in January 1997. After the proof-of-concept proved successful, he signed on for one year with Melbourne IT P/L as Project Manager to build a team and develop Creator V1.0 - which was delivered in early March 1998, for testing and usability refinement. In June 1998, he began a deferred Masters by Research degree within the Computer Science Department at the University of Melbourne. He is the recipient of an Australian Research Council/DEETYA SPIRT research award, sponsored by industry partner Ericsson Australia Pty. Ltd., based on the merit of his research topic.