A Hypertextuality of Arbitrary Structure: A Writer’s Point of View

Position Paper for the First Structural Computing Workshop, Hypertext 99

Jim Rosenberg
R.D. #1 Box 236
Davidson Road
Grindstone, PA 15442

Aspects of external structure are delineated, including scope, valence, directionality, and behavior specificity. Locality of structure is discussed from several aspects; structures may be composable; composed structures may pose computational difficulties, raising the issue of incomplete structure in the case of interrupts. Structure locality must be semantically relevant. Structure locality may need to be specifically indicated, or to the contrary may need to be discovered by the reader without specific indication. Structure poses its own rendering problems. Scopes, valences, etc. need to be rendered; such rendering may have aesthetic or human factors consequences that conflict with other goals of the hypertext author. Behavior flexibility is required. Representation of structure includes such aspects as collapse/expand and structure filtering. Representation of location within structure must allow for a non-unitary concept of location. Parastructure has its own rendering requirements. Behavior itself is discussed from the standpoint of arbitrary structurality. Pure behavior must be a compatible guest, with behavior that is exportable (e.g. for transition effects.) Behavior associated with structure must allow for pure behavior. Navigation behavior includes such issues as transition effects, flying, zooming, etc. Interface behavior has implications for how one type of structure may be considered to emulate another. Parastructural behavior may be required.

Language is intensely structured. At a fine grain it is structured by syntax; at a still finer grain by phonology; at a coarse grain by such structures as argumentation and rhetoric; at a still coarser grain by plot, narration, etc. Hypertext brings something new to the table: explicit external structure, coupled with interactivity wherein that structure plays itself out. This paper takes as a given the premise that an artistically open hypertextuality must allow its concept of external structure to be as arbitrary as possible, notwithstanding the extent to which highly particular models of structure have become extremely popular. A number of issues will be analyzed from the point of view of openness to arbitrary structure; this analysis will be strictly from a writer’s point of view rather than from a system implementor’s point of view, though of course it is hoped this analysis will be useful to system implementors. In particular we will take no position at all concerning such issues as how structure is managed by a hypertext system (e.g. as an explicit “structure store” layer [16].) We begin with an analysis of what “structure” entails. (To some the idea of what constitutes structure may seem obvious, but it bears investigation.) We will be at great pains to avoid constructing Yet Another Formalism; not because any doubt is being cast on the worthiness of that activity, but because we fear the act of constructing a formalism risks prejudging the outcome of what will constitute structure. Although structure is the subject at hand, a great deal of emphasis in this paper will be placed on behavior, for a number of reasons. It is typically in the area of inflexible behaviors that off-the-shelf hypertext systems most disappoint artistically inclined authors. Moreover it is all too easy to allow behavior to slip still further from view in the rush to place emphasis on structure. From an artistic point of view, the key word is openness: as we explore how to make hypertext open to the widest variety of possible structure, it must also remain open to the widest variety of possible behavior — and the widest variety of relationships between the two. Authors will simply not put up with hypertext systems in which behavior is the poor handmaiden of structure.


Conceptual Overview
In saying that hypertext consists of words (or other media) with an external structure, “external” is meant with respect to the words themselves. While it would be possible to indicate hypertextual structure entirely with words (including numbers) contained in a text — and in fact exactly such analysis is done to situate historical antecedents of hypertext (e.g. [3], see also [14]), typically a hypertext uses means external to the text to contain the structure. This concept of external is not to be confused with an external concept of storage, e.g. an externally maintained linkbase vs. embedded links in the data sense. The most widely discussed structural model is the node-link model, e.g. as elucidated in the Dexter Hypertext Reference Model [7]. Many other modes of structure have been discussed including sets [17], relations [12], Petri Nets [22], simultaneities [18], and piles [13]. Articulation of how elements of the text participate in such a structure is part of The Rendering Problem, which is discussed below. With respect to such structural elements — as rendered — the user performs activities, which result in Behavior — also discussed below. In this section we discuss aspects of structure itself.

Aspects of Structure
Before proceeding to aspects of structure that may be more familiar to those from a systems point of view, it is important to emphasize a particular aspect of structure often important artistically but neglected by many hypertext systems: the Null Structure. In a null structure, elements are presented with no structural relation whatever except that they happen to be juxtaposed. Elements in a null structure are simply there; it may not be pertinent to raise further issues concerning their “thereness”. Similar to the concept of the null structure is Emergent Structure [13]: an informal structure perhaps constructed on a temporary basis which may serve as the basis of a more formal structure to be constructed later. VIKI spatial collections [13] are an example of such a structure.

Let us now look at some specific aspects of structure. While we eschew formalism, the discussion that follows is a kind of informal metalanguage for the type of framework in which a structural description would need to be constructed.

A structural element may have a specific scope, indicating what other elements in the structure it relates to. An example is a set where the scope indicates which elements are members of the set; another example is a bounded region in a spatial hypertext where the scope is whatever elements fall within the region. Hypertext anchors are often conceived of as such a bounded region.(A set might be indicated as a region, of course, or set membership might need to be specifically designated independent of any presentation issues.) Yet another example is the familiar Dexter concept of composite, whose scope is all the elements contained in the composite. All XML tags are either designated as “point markers” or they have a clearly designated scope.

Some structural elements may be deemed not to have an effective scope. What is the scope of a hypertext link? There is room for considerable divergence of opinion on this. Some may consider the scope of a link to be the lexia or anchors at the two endpoints. Others may conceive of the link as being more like a programming GOTO statement and thus scopeless [4]. Any concept of structure must designate some elements as atomic; these elements may be considered scopeless (or such an element might be considered as having a scope consisting only of itself.)

The term valence is here borrowed from chemistry. Valence is a schema which represents for a given kind of structural element what must be “plugged into it” to have a valid instance. In many systems the valence of a hypertext link may be described as an ordered pair consisting of a source anchor and a destination anchor; in other systems the link may be much more complicated including perhaps a type (e.g. [15]), a link name, and so on. There may be some overlap between the concepts of scope and valence.

Depending on the structural framework, a valence specification may or may not includetype specificity. E.g. a structural framework may require that only anchors may be attached to a link; a different framework might allow any structural object to be attached to a link. There might be severe restrictions on the type of object that is allowed to be plugged into a link name slot (e.g. practically no hypertext systems allow the name of a link to be a link.)

For some structural elements, such as a set, the concept of directionality does not apply; for others it may be extremely important, e.g. the typical unidirectional hypertext link. In other cases directionality may not be formally specified but may be “metaphorically present” — e.g. an Aquanet relation may be deemed to relate its elements “together”, implying an inward directionality toward some center. A structure such as a pile where the elements are so closely spaced that they overlap one another may have an implied outward directionality of all elements to spread themselves out.

Behavior Specificity
Behavior is a large topic, which will be discussed in more depth below. It is included here since a structural description may include behavior differences as the only way that structural elements are differentiated. E.g. in some literary hypertexts, “hot words” may not be graphically differentiated from those which do not serve as link anchors; the only way to tell is to click on the word and see what happens. (E.g. [9]).

The “dimensions” just given provide a kind of micro-language for describing structure; these aspects can be combined in arbitrary ways to describe a vast variety of structural possibilities. Openness to novel ways of combining such aspects is exactly what a hypertextuality of arbitrary structure is about.

Locality / Atomicity of Structure
Hypertext algorithms are typically localized [20]. Localization is also an issue that is important in discussions of structure. We spend much of our time in hypertext talking about highly localized structures, such as links. In fact, these structures are often referred to as if they were atomic, when that may or may not actually be the case [19]. What level of structural locality is really relevant? An example may help to clarify this issue. It is sometimes asserted that Aquanet relations can be expressed in a Dexter formalism as composites [Randy Trigg, personal communication]. Presumably this would work by defining an Aquanet relation as a composite of links. Putting aside the difficult question of whether the behavior would be correct in this “translation” of the relation concept (this question is discussed below), it is important to note that such a composite must function as a complete unit; the individual links in such a composite have no particular meaning with respect to the original abstraction, namely the relation. The “locality” that is significant is the entire composite. Likewise, consider a structure where a link name is associated with its link by a special kind of link. Does this link have any independent existence of its own?

While such questions might seem to be splitting hairs, the same type of issues are considerably more thorny when projected up to higher structural levels. Consider the structural concept of neighborhood. Let’s suppose that neighborhood is defined in graph-theoretical terms based on a node-link framework. E.g. the neighborhood of a node is defined as the set of nodes reachable via one link inbound to a given node. This may be very easy to define, yet difficult or impossible in practice to compute. Consider, for instance, the difficulty of computing neighborhoods where the hypertext system in question is the World Wide Web. In this case there is simply no hope of computing neighborhoods in any reasonable time.

While hypertext authors must be reasonable in the face of computational difficulty, it can be very frustrating for authors to be forced to work in a hypertext system where the system designer’s concept of structure is rigidly local, the author has requirements involving higher-level structural units, and the ability to manipulate such units should be doable but isn’t. Locality is a matter of context.

With this as a backdrop, we can consider some specific aspects of locality particularly as they relate to higher-level structure.

Structures may be composable
Higher level units may be constructed by iterating lower-level units. E.g. the concept of neighborhood above is constructed as iterations of the link. Networks may be composed by joining them with links. Such acts of composition, while they may in the general case produce an unacceptable computational load, may be in fact acceptable in the particular context of interest to a specific author or user. It is a difficult question whether authors need to be “protected from themselves” to be spared such computational minefields. In this author’s opinion, system designers must be prepared to include in their systems structural concepts of unknown computational load; determining whether a structural concept has “hit the limit” of what is computationally reasonable is part of the artistic process in the cyber-arts. In the case where a higher-level structural unit is computationally defined, e.g. by composition, of course the user must have the ability to interrupt the computation.

This results in an interesting question. What should be done with the partially computed structure when a computation is interrupted? There are two obvious possibilities: (1) the interruption should be considered an abort (perhaps a rollback in database transaction terminology) and the resulting structure delivered to the user (if at all) empty. (2) The structure should be delivered to the user in whatever degree of completion was achieved before the interrupt. Both choices pose difficult issues. One can imagine a concept like the neighborhood above where the user places an informal time constraint on the computation time, e.g. “let me see how much of a neighborhood I can construct for this node on the Web by letting this thing run overnight.” In this instance the user is not served by having the interrupt produce nothing, even when (say by consulting numerous search engines) the system did in fact produce a significant number of inbound links. On the other hand, if we accept alternative 2, we are forcing the system designer to include in the system provision for incomplete structures. This could cause significant difficulties if a structural concept has consistency constraints that are not met.

Structure locality must be semantically relevant
Regardless of how the primitive structural concepts of one hypertext system can in principle be represented in the primitives of another hypertext system, this representation must have real meaning. Consider the case dealt with above where Aquanet relations are represented as a composite of links. Does this unit function as a whole in the same way as the Aquanet relation? Does it have some identity distinct from other kinds of composites? Surely this would be required if the representation of relations as composites is more than a technical formalism: the relation concept has a semantic identity in the original hypertext system, and this identity must be preserved in the target hypertext system.

Or, consider an “index” constructed as a simple list of outbound anchors — say in HTML. How does one designate that this list functions as a unit? Such problems are quite easy to solve in XML: one simply invents (or better yet deploys some already agreed-upon convention for) a tag for this unit, and the scope of the tag designates the semantic locality of the structural concept.

Structure locality may need to be designated explicitly
Hypertext systems do not always provide the proper flexibility to do this. Consider a node-link hypertext that allows bi-directional links. What is the scope of a reverse link? Can we assume in all cases that the scope of the reverse link is identical to the anchor of the forward link? Perhaps not. Consider a simple citation link. The anchor for the forward link might be nothing more than the citation notation in the style sheet of the document, e.g. a string that might look like “[47]”. But depending on the circumstance, the scope of the reverse link might be an entire sentence, an entire paragraph, or possibly an entire section of a document. To make that scope identical to the anchor of the forward link might be extremely confusing for readers. In general, there may be no formal way to infer the scope of this reverse link; the author must simply designate it.

Structure locality may need to be discovered
This point is really the opposite of the point above. Discovery of structure by the reader may be an important part of an author’s concept; explicit designation of structure may in fact defeat this purpose, since an author may intend that a multiplicity of possible “derived structures” should be inferable from the author’s material. Structure locality might be defined not by the document author, but by a kind of annotative process by the reader. The hypertext literature is full of discussion of the reader acting as writer (e.g. [10]). Most often this is phrased in terms of the reader authoring hypertext structures, such as links or annotations. But there is no reason to assume the reader might not want to amend an author’s already-existing structures; for instance I might decide I as reader don’t like the scope of an author’s anchor and want to change it.

This raises an odd structural paradox. How is an author to indicate incomplete structure? E.g.: an author wishes to indicate that the scope of a reverse link is to be left to the reader, but within certain boundaries. How should this be notated? What are the interface requirements? Or, a similar example: the indeterminate link. Consider a case where an author wishes to indicate a link, where the target of the link will be determined in the future by some activity of the reader. (This could be based on a computation of which among many alternative lexia the reader visited for the longest time, some explicit action by the reader — say the first among alternative lexia to be bookmarked by the reader — or any number of other possibilities.) One method of handling such concepts of incomplete structure is to not indicate an incomplete structure at all until it is completed. This certainly simplifies the problem: we are now simply faced with a dynamically constructed hypertext. But surely this will not suffice for all authors. Returning to see whether the structure has been completed, and if so what it looks like may be part of an author’s intention; in this case there must be an explicit indication of the incomplete structure.

There is an obvious advantage in indicating incomplete structure to those systems where structure is achieved by some form of formal language, e.g. a markup language; in this case an incomplete structure can be indicated by means of e.g. markup where parameters are missing, or by variables which have not yet received values. This risks, of course, that a parser might return error messages for this incomplete markup. To avoid this problem, incomplete markup would have to be encapsulated in some way so that a parser would ignore it until it was completed. For instance, completions for structural properties might be indicated by a special kind of link; when the markup was completed the link would disappear and the completed structure would replace it.

By “the rendering problem” is not meant simply the issue of rendering e.g. text and graphics in the usual sense of say browser rendering engines. Here we are concerned with explicitly structural issues. In the following section we will give a taxonomy of some of those issues.

Participationin Structure
Every user of the Web is familiar with distinct rendering for link anchors (outbound, of course!) Typically an outbound link anchor is underlined. Rendering of structure participation indications for a hypertextuality of arbitrary structure is much more complex. The issues here are related to ones discussed above, e.g.:

Scopes, valences, behavior expectations, etc. need to be explicitly indicated
Aquanet allowed valence to be rendered via explicit diagram concepts; alas this extremely valuable insight has not been carried forward into many current hypertext systems. The idea currently popular in HTML that structure participation can be rendered solely by means of “in-line” text attributes seems particularly shaky. To accommodate arbitrary structure, it is hard to see how we can avoid rendering by some overtly external means.

Rendering of scope is a nasty problem. There are many intuitively straightforward ways of rendering scope — provided we all agree that scopes are nested and don’t overlap. Unfortunately that assumption is simply untenable if we are serious about the word ‘arbitrary’ in speaking of arbitrary structurality; the assumption that all scopes will be nested is just as outrageous as the assumption that all structures will be linear.

One approach to this problem is to have a generic method of rendering structure participation which is not explicit about the structural details. Consider the typical HTML rendering of an outbound link anchor as typographically distinct (in this case by underlining). A hypertext system could have a special typographical rendering that simply means: these words are structural participants. Obtaining the details might be achieved via behavior. For instance, an explicit structure indicator — perhaps an Aquanet-style diagrammatic rendering — might pop up as the cursor is moved over the structure participant, somewhat in the fashion of Zellweger’s fluid links [23]. Scope could be indicated by a simple marker that denotes a scope boundary; the actual extent of the scope could be indicated by behavior.

Rendering behavior has consequences — aesthetic, human factors, etc.
This is a very difficult issue. Regardless of the advances in computing technology of recent decades, certain aspects of the computing environment are still scarce resources, e.g. screen real estate. It is inherent in the nature of hypertext that it allows structures of vastly greater complexity than are easily represented by the geometry of the words themselves; the rendering of this structure has to fit somewhere. There are many conflicting demands upon screen real estate. Among them are:

How does a hypertext system allow rendering of structure participation without foreclosing an author’s options in the face of these competing demands?

There are similar issues concerning time as well as space. One method of solving rendering problems is to use animation. (E.g. [23].) However, animation has time consequences: it structures time in a particular way. Depending on the multimedia contents of a hypertext, the time requirements of animations used to render structure participation could conflict with time requirements the author has regarding other issues.

One approach to solving these problems is “pluggable” behaviors: the hypertext system could provide a “construction kit” whereby an author could build rendering behavior from a palette of tools sufficiently rich that conflicts like the ones discussed above could be avoided. This is apparently the suggestion made in the Structural Computing framework of [16]; however that framework leaves a bit vague the relationship between structures and behaviors.

In fact, it has been typical of most hypertext systems that they “hard-wire” many forms of behavior, specifically including the rendering of participation in structure. Hard-wiring behavior is just as restrictive as hard-wiring structure itself; a hypertextuality which is open to arbitrary structure must be open behaviorally as well. Of course this raises the issue of “arbitrary programmability”; for a full discussion of this issue see [20].

Representationof Structure
It goes without saying that a hypertextuality of arbitrary structure must have some way of rendering that structure. Hypertext lends itself quite naturally to very complex structures; it stands to reason that hypertext authors will want the best available techniques for representing complex structures. Ideally, as new techniques evolve, there should be some method of retrofitting them onto existing hypertext systems. [21] describes how multi-focus fisheye views were retrofitted onto VIKI. That experience is, alas, not entirely encouraging for hypertext authors, in that it required the system implementors to do the work that would allow including fisheye views. Ideally such work should be doable by document authors. To allow for this, hypertext systems will have to provide much more open APIs than is customary at present.

Representationof structure has most of the same issues discussed above under participation in structure; there are a few other new issues at this level.

Subsuming (collapse/expand) structural elements
Participants in a structure might be structures themselves; a rendering should allow the reader to subsume such a structure to a single entity and collapse it. Note that this is entirely separate from the kind of rendering behavior that might occur as a result of navigation. (Navigation is discussed below.) Consider a node-link hypertext which is tree structured in the vicinity of a particular node; let’s assume the user is “located” at that node. Without moving from the node, the user might wish to collapse all “child nodes” to a single graphic entity each, regardless of how many “grandchild” nodes (and further generations down) extend from a given child.

More generically:

Rendering of structures may need to include filters
The fisheye view concept [5] may be thought of as a kind of visual filter; others have been proposed. Such filters might have options that govern how distortions are handled. (See [21] for a discussion of of how proximity distortion vs. alignment distortion was handled in fitting fisheye views to VIKI.)

Representation of location within structure
This is, of course, the celebrated navigation problem. A full treatment of this problem is beyond the scope of this paper. Suffice it to say that the level of generality required to support arbitrary structure will require an interdependent methodology for representing location in structure. Beyond the usual issues of navigation, a hypertextuality of arbitrary structure has some special issues pertaining to location:

Location need not be a unitary concept
Most hypertext systems have some kind of concept of “current location”; typically this concept is unitary. I.e. there is just one “current location”. Consider, however, a structure such as a “symmetric” ternary relation. I.e. the structure is a triple, where all three slots are equivalent. One concept of location in this structure would assume that the reader will read the items occupying the three slots in some order, each one in turn; current location is a straightforward concept in this case, designating which of the three slots the user is reading. However, perhaps the author’s concept is that the three elements occupying the relation slots should “play simultaneously”. The concept of current location is now much more complex. Perhaps now all three slots are simultaneously open, and the user is located in all of them: a non-unitary concept of current location.

Many familiar user interfaces open a multi-paned window, or perhaps several windows simultaneously. Today’s user interface may have a unitary bias driven by the fact that there is only a single mouse cursor, but this unitary bias is certainly not logically necessary.

Non-unitary location means rendered objects have dependencies
If the user is “located in” multiple simultaneously open rendered objects (e.g. Windows), it is quite likely that those objects will contain informational dependencies. Thus the hypertext system will have to provide the document author with a method for managing these dependencies. Unfortunately, this is a complex subject. Prior experience with frameworks for dependencies among multiple open objects includes such celebrated cases as the well-known Model View Controller paradigm (MVC) [11]. Experience with MVC is best described as mixed; Smalltalk environments with off-the-shelf classes for MVC have proved a rich ground for experimentation, but MVC has not been popular in commercial systems, to the point that it is probably not an exaggeration to describe MVC as obscure among today’s software developers (never mind users!) Unfortunately, it has not been replaced by a comparable framework. To place the burden of inventing such a framework on today’s system implementors is asking a lot; but it is asking even more to place this burden upon the document author!

As discussed above, arbitrary structure must include informal and emergent structure; among the devices used to represent such structures are proximity, alignment, typographical conventions, and so on. As discussed above, parastructure may act as a constraint on other aspects of a hypertext system, in that structure rendering may need to preserve the parastructure.

Behavioral issues have already figured prominently in this discussion; we now discuss behavior directly. The relationship between structure and behavior as it affects hypertext programmability has been discussed in [20]. This discussion will adopt that framework, with a particular emphasis on openness to arbitrary structure.

“Pure Behavior”
Analogous to the null structure discussed above is behavior with no structure at all. (See [20] for references to examples.) Pure behavior is simply “there”; it unfolds like a cinema and has no internal structure that the user can access. An example is an internally undifferentiated multimedia object which simply plays; perhaps it functions as a plug-in, or a guest algorithm in the terminology of [20]. Even though such an object may exist as a node in a larger structural framework, from a structure point of view it exists as an atomic object. Nevertheless, there may be some subtle interactions between such an object and other components that are specifically tied to points in a structure.

A pure behavior player must be a compatible guest
As noted above, arbitrary structure may require a dependency mechanism among “parallel” pieces. A pure behavior piece must be compatible with such a scheme. If it is controlled by a multimedia player object, perhaps that object is sent parameters or signals from other components in the structure. There must be a framework for how this takes place.

Pure behavior must be properly exportable
One of the obligations of a hypertext system is to properly save its state at points where this makes sense — both for reader and writer. A pure behavior object must participate in this. Of course it might be an aesthetic decision on the part of the author that a pure behavior object should replay from the beginning whenever its state is restored, but another author might include behavior objects which take so long to play out that (intentionally) the entirety of the play sequence cannot possibly be completed in a single session; in this case it may be aesthetically important to the author for the object to resume where it left off.

Similarly, a pure behavior object must be able to participate in transitions. Transition behavior will be discussed below; in that context pure behavior is simply a special case.

Structure behavior” must allow for pure behavior
Many hypertext systems assume that their own “built-in” behavior is the only kind of behavior which will occur. This can pose conflicts if a pure behavior object is inserted into the space. Consider, for instance, a user interface — perhaps one to assist the blind — which relies on sound. A player object has a sound track. What should be the relation between these? Should they play simultaneously? Should the user interface sound interrupt the “pure behavior sound”? Perhaps the user interface sound might behave differently if it knew that a “pure behavior” player object with sound was playing.

Navigation Behavior
Navigation behavior is arguably among the most important kinds of behavior in hypertext. The expectation when a user e.g. clicks on a link is that something will happen. It is typical for hypertext systems to make assumptions about navigation behavior — assumptions with which the document author may not agree. An important issue in a hypertextuality of arbitrary structure is how the document author may create her own effects in navigation behavior. In the literary world we care a very great deal about these matters.

Transition effects
Consider the simple act of following a link in HTML. It is customary for the browser to repaint the screen completely to render the target page. This can cause a noticeable blink if the replacement page is substantially the same — even at a high bandwidth. Environments such as HyperCard [6] allow for explicit transition effects that delineate how the screen will change from one “card” to another. Perhaps the user wants a smooth fade from one screen to another. Note this interacts with the issue of exportable behavior just discussed. If there is to be a smooth transition from a static “structure object” to a dynamic “pure behavior” object, enough of that pure behavior must be exportable to the system to accomplish this. This is a difficult problem if not explicitly designed in to a framework; it is hard to imagine how an arbitrary guest algorithm exports enough of this behavior to allow for transition effects.

Other kinds of transition effects include flying (e.g. Web Squirrel [2]) — navigation in Web Squirrel causes the reader to “fly” over the space to the target object — and zooming (e.g. Pad++ [1]). It took considerable effort to implement the zooming behavior in Pad++. What is the poor author to do if both the kind of zooming behavior implemented in Pad++ and structural concepts not implemented in Pad++ are desired?

Interface behavior
Interface behavior has an intimate relationship to structurality. Consider a structure such as a ternary relation. Such a structure is known in advance to have 3 slots; an authoring system might use this information behaviorally in the case where, for instance, not all of the slots have been completed. E.g. when composing the relation, if the author attempts to “close” the relation in an authoring mode and not all slots have been completed, perhaps a warning dialog should be displayed. A reader would expect such behaviors as: open all slots simultaneously, close all slots simultaneously, display a list of the slots, etc. Some of these behaviors may raise difficult implementation issues in which the author may want to participate. Consider the case of opening all slots of a relation simultaneously. Screen real estate is always in short supply. Something will have to be hidden to open new objects. What should the “hiding policy” be? How can a document author participate in this policy? How can the reader? Let’s suppose further that our ternary relation brings together elements from “distant” places in the hypertext. What should the behavior be when these places are opened? It is exactly issues such as this that raise serious difficulties for the kind of formal “emulation” exemplified by the belief that e.g. Aquanet relations can be modeled as composites of links. If a relation is simply a composite of links, the assumption must be that “opening a relation slot” consists of following one of these links — with whatever behavior is entailed by following a link in the system in question. The idea of opening all the slots simultaneously — in some form of coherent display — is not available. Thus the interface behavior of a relation may not be correctly modeled by the interface behavior of a composite of links.

Parastructural Behavior
Parastructure was discussed above; while parastructure is often associated with issues of spatiality, there are behavioral issues here as well. A simple hypertext link may be thought of as (in some cases at least) an attraction between the linked elements; the opposite concept is also possible, namely a repulsion between elements. An author might want to indicate this parastructure behaviorally, e.g. repelling elements might be actually seen to “fly apart”. Such parastructural behavior is currently rather uncommon, but a framework for arbitrary structurality should provide for it. (For a discussion on the subject of “anti-links” see [8].)

1. Bederson, Benjamin B. and Hollan, James D., “Pad++: A Zooming Graphical Interface for Exploring Alternative Interface Phsyics”, Proc. ACM UIST’94, ACM, New York, 1994.

2. Bernstein, Mark, “Neighborhoods in Spatial Hypertext”, SIGLINK Bulletin, 1998, to appear.

3. Cortázar, Julio, Hopscotch, trans. Gregory Rabassa, Avon, 1966.

4. DeYoung, Laura, “Linking Considered Harmful”, Proceeds from the European Conference on Hypertext, Versailles, France, 1990, Cambridge University Press, Cambridge, 1990.

5. Furnas, G. W., “Generalized Fisheye Views”, Proceedings of CHI’86, ACM, New York, 1986, pp. 16-23.

6. Goodman, Danny, The Complete HyperCard Handbook, Bantam Books, New York, 1987.

7. Halasz, Frank G., and Schwartz, Mayer, “The Dexter Hypertext Reference Model”, Hypertext Standardization Workshop, NIST, 1990.

8.Thread "Anti-Links?", ht_lit Mailing List, September, 1979, ftp://consecol.org/pub/ht_lit/ht_lit.9709.

9. Joyce, Michael, Afternoon, Eastgate Systems, Watertown, MA, 1990.

10. Joyce, Michael, Of Two Minds: Hypertext Pedagogy and Poetics, The University of Michigan Press, Ann Arbor, 1995.

11. Krasner, G. E., and Pope, S. T., “A Cookbook for Using the Model-View-Controller User Interface Paradigm in Smalltalk-80”, Journal of Object Oriented Programming, August/September, 1988, 26-49.

12. Marshall, Catherine C., Halasz, Frank G., Rogers, Russell A. and Janssen, William C. Jr., “Aquanet: a hypertext tool to hold your knowledge in place”, Proceedings of Hypertext ‘91, ACM, New York, 1991, pp. 261-275.

13. Marshall, Catherine C., Shipman, Frank M. III, and Coombs, James H., “VIKI: Spatial Hypertext Supporting Emergent Structure”, European Conference on Hypermedia Technology 1994 Proceedings, ACM, New York, 1994, pp. 13-23.

14. Moulthrop, Stuart, “Shadow of the Informand: A Rhetorical Experiment in Hypertext”, Perforations 3, Public Domain, Atlanta, GA, 1992.

15. Nanard, Jocelyne, and Nanard, Marc, “Using Structured Types to Incorporate Knowledge in Hypertext”, Proceedings of Hypertext ‘91, ACM, New York, 1991, pp. 329-343.

16. Nürnberg, Peter J., Legget, John J., and Schneider, Erich R., “As We Should Have Thought”, Hypertext 97, ACM, New York, 1997, pp. 96-101.

17. Parunak, H. Van Dyke, “Don’t Link Me In: Set Based Hypermedia for Taxonomic Reasoning”, Proceedings of Hypertext ‘91, ACM, New York, 1991, pp. 233-242.

18. Rosenberg, Jim, “Navigating Nowhere / Hypertext Infrawhere”, SIGLINK Newsletter 3, 3, December 1994, pp. 16-19, http://www.well.com/user/jer/NNHI.html

19. Rosenberg, Jim, “The Structure of Hypertext Activity”, Hypertext ‘96, ACM, New York, 1996, pp. 22-30, http://www.cs.unc.edu/~barman/HT96/P17/SHA_out.html.

20. Rosenberg, Jim, “Locus Looks at the Turing Play: Hypertextuality vs. Full Programmability”, Hypertext 98: The Proceedings of the Ninth ACM Conference on Hypertext and Hypermedia, ACM, New York, 1998, pp. 152-160.

21. Shipman, Frank M., Marshall, Catherine C., and LeMere, Mark, “Beyond Location: Hypertext Workspaces and Non-Linear Views”, Hypertext 99: The Proceedings of the Tenth ACM Conference on Hypertext and Hypermedia, ACM, New York, to appear.

22. Stotts, P. David and Furuta, Richard, “Petri-net based hypertext: Document structure with browsing semantics”, ACM Trans. Off. Inf.Syst., 7, 1, (January), 1989.

23.Zellweger, Polle T., Chang, Bay-Wei, and Mackinlay, Jock D., “Fluid Links for Informed and Incremental Link Transitions”, Hypertext 98: The Proceedings of the Ninth ACM Conference on Hypertext and Hypermedia, ACM, New York, 1998, pp. 50-57.