Max Mühlhäuser, Ralf Hauber, Theodorich Kopetzky
Telecooperation Group, Johannes Kepler University Linz, A-4040 Linz, Austria
e-mail: ( max | ralf | theo ) @ tk.uni-linz.ac.at

We use the term "(a) web" to denote a meaningful, coherent set of nodes and links; webs can be represented as graphs. They may contain other webs hierarchically as "meta-nodes" and comprise links to the "outside world". In the context o f the Workshop, we want to advocate typing concepts for webs which cover both structural and logical aspects. We believe that the re-use of Web Information can be sufficiently improved with such concepts, where re-use may refer to the issue of finding inf ormation by query or navigation or to the issue of incorporation of Web information into augmented hypermedia; by the latter we mean systems which are built on top of hypermedia-based structured information (such as, for instance, hypermedia-based learnin g systems, software engineering environments, decision support systems, and many more).

Typing for the atomic constituents of hypermedia (nodes, links, anchors) has been around for quite some time. Even in HTML, there is a primitive form of such typing in the sense that types of nodes are implicitly defined through the med ia and format (HTML, JPEG, GIF, Quicktime™ etc.), and types of links through the target type (local/remote document, "mailto:", etc.). More advanced hypermedia systems support user-defined types of nodes and links. Usually, this feature is used for modeling the application domain.

In addition to user-defined node and link types – which are present in many hypermedia systems, just not yet "really" in the standard Web – the following typing concepts are useful and can be considered as requirements for a re-use orie nted hypermedia system:

1. Multi-level typing for atoms. In reality, there is often not a single application domain, but several ones: in hypermedia-based learning, for instance, there is the pedagogical domain, the subject matter domain, the media and formats of actual contents, and others. Adequate hypermedia systems thus ought to support several levels of type systems, and the mapping of one on the other (e.g., "concept" – a node type of an instructional strategy - might be mapped onto "Newton’s law " – a node type from the subject matter domain - which in turn could be mapped onto "video" – a node type from the media domain).
2. Consistent types with semantics. For a given application domain, it should be possible to define a set of node/link types together with their (generic) semantics. E.g., for instructional theory, it should be possible to defin e "concept", "fact", "procedure" etc. as nodes, to specify relations among and between these nodes as links, to specify semantics of how these nodes and links are used in instructional design, and to use the entire type system in a variety of applications .
3. Web types emphasizing construction, restriction, element types, and hierarchy. A web type should obviously describe a family of coherent sets of nodes and links. We argue in favor of a constructive approach since it ca n be used for guiding a Web author through the process of creating and maintaining a web – a web type should thus describe how its elements are to be put together in order to create a web as an instance of the web type defined. Virtually all constructive approaches have shown that the "laws of construction" alone are not sufficient for specifying a type: restrictions in terms of boundaries and constraints are usually needed in addition. Last but not least, web types should refer to node and link types as described above. Moreover, successful models have typically supported hierarchies of abstractions – thus, it ought to be possible that a web contains other webs as elements, not only nodes and links.

The main benefits which might be drawn from the above-mentioned desired features of web types are listed below; since they are not automatically provided if the above requirements are fulfilled, the following list can regarded as furthe r requirements.

4. Software re-use through web types. Maybe the most important advantage of web types is their potential for re-use. In particular, web types may hold "code" (rules, procedures) which can be inherited to the instances i.e. concr ete webs. Taking the example of hypermedia-based learning, most of the available on-line hypermedia-based learning material today is in essence an exploratory hypermedia: nodes and links with little or no navigation support, adherence to an instructional strategy or user model, etc. The have been such advanced hypermedia-based learning systems, but the effort for creating the "intelligence" above the plain exploratory hypermedia has been enormous and could not be used further. With the advent of web types , such efforts could – at least in parts – be conserved by programming them in the context of (re-usable) web types.
5. Reduction of cognitive load. The re-use of web types and of the "intelligence" i.e. code put on top of exploratory hypermedia has an important side-effect: entire departments or organizations, even the "communities" which bel ong to an application domain may decide to share common web styles. By doing so, the users will encounter "similar" webs and get accustomed to the commonalties, e.g., in "look & feel". Many of the drawbacks of hypertext in comparison to paper-based do cuments come from the lack of "culture" and "common look & feel". Web types can be an important step forward here.
6. Improved information acquisition. The more type information is provided during the construction of a hypertext, the more such information can be used in the context of information retrieval. E.g., an author of instructional m aterial can only narrow down a search for material based on a rule like "instructional theory XYZ is required to have at least one example linked to any concept" if such rules become explicit in the corresponding web type.

Looking for type concepts for webs, one finds that the Web community has concentrated on augmenting the power of nodes and links rather than the power of webs. Many observations back this claim, some of which are listed below:

• HTML as a markup language has a large number of tag and element types which concern the internal structure of individual pages i.e. nodes, but only few which concern webs (URLs in essence).
• There is no standard on the Web for describing a web.
• Most Web authoring tools are not much more than word processors (which "happen to" use HTML as their output format), often just augmented with the notion of URLs; exceptions like NetObject Fusion™ support site management much more in the "physical" sense mentioned above than in the "logical" sense.
• Metadata, too, reflect logical characteristics of node contents (such as author, language, etc.) much more than characteristics of webs.

While the Web (considered as a particular kind of hypermedia system) is by far the most wide-spread such system, even a de-facto-standard, it is by far not the most advanced system. As a consequence, several of the most interesti ng contributions to the field have been made for other hypermedia systems than the Web. A short excerpt of such contributions – independent of whether they are Web-compliant (cf. [MM97]) or not – i s given below. These contributions relate to fields as diverse as hypermedia authoring/design support, generics and dynamics in hypermedia, database schema approaches, and structural queries.

• DeVise [GHM94] is a hypermedia system built at the University of Aarhus which complies with the so-called Dexter Model, an architecture which clearly separates (node) content s from (web) structure. DeVise supports "composites" as a higher-level abstraction for a set of nodes and links; as to typing support, composite types specify different variants of composites (as to what it is that the components have in common) and restr ict the types of components that are valid; they do not, however, specify in detail "how to put together" "how many" components "of what type" – we will call these aspects "construction", "restriction" and "element typing").
• Trellis [FS89] and [SF89] was an approach for mapping the navigational behavior of webs onto PetriNets. It was the first approach to addressin g the aspects "construction" and "element typing". However, since the approach was based on the so-called backus-naur-form BNF used to express programming language syntax, Trellis could only specify linear parts of web structures, not graphs.
• The object-oriented hypermedia design method OOHDM [SRB96] is an attempt to map nodes and links onto objects and relations; OOHDM emphasizes "element typing" in the above-mentioned terms: object-oriented design concepts are used for expressing types of objects (i.e. classes) and relations; the construction / restriction aspects mentioned above are rather neglected.
• All approaches mentioned above were centered around structured development of hypertext documents. As to structured information acquisition, one has to consider WWW query systems in particular. Systems such as [WebSQL] suffer from the lack of structural information available in webs. WebSQL and others can only offer nodes, links, and anchors as the principle constituents of a web: it cannot be expected that any typing information about nodes and links is av ailable on the Web in general, let alone that a common type system be used, let a alone that structural information about the corresponding web is available. While it is most likely too optimistic to expect the use of common web types throughout the Web, it is both desirable and imaginable that organizations and "communities" may adhere to such web types.
• The HyperTree approach [STH97] has many goals in common with the approach described here. HyperTree makes a distinction between the graph-like structure of an actual web and a tree-shaped conceptual level "above" this graph. We regard a single conceptual level as too limiting and believe that tree-like structures can only be regarded as a special case of hypermedia. In addition, HyperTree does not attempt to introduce common type systems t ogether with corresponding semantics for specific application domains.
• PreScripts [Richartz96] were developed with the same goals as the approach described here but were restricted to web types (i.e. did not support consistent types and semantics). The P reScript approach was only slightly related to the Web. The approach presented here takes over many ideas from PreScripts but adds Web compliance, many detailed enhancements, and the concept of ontologies as described further below.

In summary, there have been considerable achievements in the attempt to provide design support for hypermedia; the most promising ones are based on type concepts of what we call webs in this paper. Most such developments relate to hyper media systems other than WWW. Even worse, the considerable achievements made are contrasted by a rather moderate state of commercially available authoring tools for WWW (with a minor exception being the "site management" support given by systems li ke NetObject Fusion™. The most general and most adequate representation of webs has been found to be a "graph" of nodes and links.

The GUTS approach (generic unified typing system) described here leverages off multi-year research at the hypermedia learning group of the first author. It is based on two principle approaches which realize the abov e-mentioned requirements:

• WebStyles, a graphics-based approach to hyperweb typing, featuring generic nets for graphically depicting the node/link construction rules which apply to all instances, plus procedures and rules for further details (see below );
• Ontologies i.e. specific types of nodes and links plus their interrelation, augmented by type rules, for describing a specific aspect of an application domain.

Using learning systems again as an example, their lifecycle may be supported, e.g., via ontologies for instructional analysis, for instructional design, for domain analysis, and so on. As to alternative approaches, there are for instanc e ontologies that express rather traditional instructional concepts and rather advanced ones.

At this point of course, the reader will not easily grasp how the introduction of an ontology might lead to support for a certain lifecycle phase or instructional concept, nor how WebStyle typing actually works. To this end, the authors decided to introduce further details of their concept by way of example, rather than by describing rather abstract "architectures" or "models".

The key to understanding GUTS is its way of representing knowledge. In the teaching context, knowledge means content of courses together with information about the entities involved in the teach ing-learning situation, for example content, courses and learners. The latter kind of knowledge is called meta-information.

Principal mechanisms for knowledge representation and inference as used in GUTS were thoroughly studied the fields of semantic networks and graph grammars (see for example [Sowa91] and [Rozen97], respectively). As advocated earlier, the basic underlying data structure is the Graph. Our extended notion of a Graphs — called WebStyles — compris e a grammar for expressing static (syntactic, structural) and dynamic (semantic, navigational) aspects. The following table may motivate these categories.

WebStyles are based on a work about "generic and dynamic aspects of hypermedia" [Richartz96]. They consist of three parts: generic webs, procedures, and rules. These generic webs are in e ssence graph grammars (cf. [Rozen97]) and consist of nodes and links. A first overview of the symbols used with WebStyles is shown in figure 1.

Figure 1: WebStyle symbols

Transformations: The most notable transformations in WebStyles concern the instantiation of "sequence nodes" (transforming into "chains" of nodes-and-links) and "fan links" (transforming into "bunches" of links originating from the same "source" node); of course, there are more transformations like instantiating a node to a real node. The following figures help to grasp how nodes and links can be transformed.

In the left figure, two transformations have been applied to a sequence node. In figure b) a possible transformation of a fan link is shown. In figure c) a web consisting of two types of nodes and two types of links is presented. By app lying the transformations introduced in figures a) and b) to this web and mapping some generic nodes to instantiated nodes, the web shown in d) can be constructed.

To find out which nodes and links are affected by a transformation, the so-called track-algorithm is used. This algorithm defines which nodes and links belong to a track and marks them. In a second step all the marked objects are copied and connected to the original web.

Attributes, procedures, rules: Each WebStyle object has general attributes, like a name, and more specific attributes, like lower bound and upper bound. The bounds for example are used by the transformations and define how many nodes or links can be instantiated. Besides default procedures (like isTraversible which tells if an object may be traversed) user defined procedures and rules may be attached to nodes and links. These procedures and rules may influence the construction of a web even more (e.g. by constraining it) and may influence the navigation in such a web, too.

Further elements of generic nets: Two more types of objects are supported: alternatives and meta-nodes. Alternatives are used by the author of a web to offer a choice from different possibilities during construction. Meta-nodes help to model complex sub-webs and can be used e.g. to build tree-like structures. For more detailed descriptions cf. [Richartz96].

Knowledge representation involves classifying the ‘things’ to be represented, e.g. «Mars» is a «planet», «next» is an «order relation», «is a» is a «genus-species relation». Ideally the classes (concepts, types, the terms inside french quotes «…») are explicitly written down and put in relation with each other. This is called a theory, conceptualization, or, as is fashionable, an ontology. (Ontology as a part of philosophy is the study of being, or, the basic categories of existence. With the indefinite article, the term "an ontology" is often used as a synonym for a taxonomy that classifies the categories or concept types in a knowledge base. [Sowa91], p. 3)

There are ontologies for ‘everything’. For instance, in instructional design, if one wants to use Gagné’s events of instruction [GBW92], he could define an ontology containing «gain attention», «indicate goal», «recall prior knowledge», «present material», «provide learning guidance», etc. Or, to be able to talk in terms of Reigeluth’s elaboration theory [Reigel87], one needs «fact», «concept», «principle», and «procedure».

In these examples we did not consider any relations and formalization of semantics. If one tries to work out these aspects, it soon will be evident that something crucial is missing: How could such an ontology be defined? In which language? Answer: There is a particular ontology built in. GUTS’ representation ontology is rich enough to capture the computational content of new, user defined ontologies. It comprises objects («object», «theory», «abstraction», «type», «rule») and relations («relation», «genus-species», «instance», «composition», «equivalence», «order», «derivation», «functional», «context»).

WebStyles with its representation ontology (the "basic, built-in" ontology that is used to define other ontologies) is a specialized representation language, as is KIF [GF92] with the so-called "frame-ontology". Sowa mentions that "the structure of a knowledge representation language depends critically on its ultimate goal" ([Sowa91] p. 157), and since WebStyles and KIF differ in purpose, their flavor, appearance and computational properties are different. Although WebStyles could be easily mapped to KIF (and back).

The predecessor of WebStyles (called PreScripts) was developed in C/C++, a prototype of WebStyles in JavaScript. Java was chosen for the current implementaiton. The latter one features graphical editing of WebStyle webs (this includes m anipulation of the graph structure and the objects) and implements the complete track-algorithm which defines the semantics of web types.

In the workshop, we would like to demonstrate the WebStyle editor and discuss the value of ontologies and WebStyles for information and software modeling, for greatly increased WWW re-usability (for knowledge in expert domains, in parti cular), for sophisticated navigation support, for a hypertext "culture" and "common look & feel", for the seamless modeling and implementation of (static) information and (dynamic) software.