A Visual Language for Non-WIMP User Interfaces Robert J.K
Total Page:16
File Type:pdf, Size:1020Kb
A Visual Language for Non-WIMP User Interfaces Robert J.K. Jacob Department of Electrical Engineering and Computer Science Tufts University Medford, Mass. 02155 Abstract single input/output stream. Even where there are several devices, the input is treated conceptually as a single Unlike current GUI or WIMP style interfaces, non- multiplexed stream, and interaction proceeds in half- WIMP user interfaces, such as virtual environments, involve duplex, alternating between user and computer. Users do parallel, continuous interactions with the user. However, not, for example, meaningfully move a mouse while typing most current visual (and non-visual) languages for describing human-computer interaction are based on characters; they do one at a time. Non-WIMP interfaces are serial, discrete, token-based models. This paper introduces instead characterized by continuous interaction between a visual language for describing and programming the fine- user and computer via several parallel, asynchronous grained aspects of non-WIMP interaction. It is based on the channels or devices. notion that the essence of a non-WIMP dialogue is a set of Because interaction with such systems can draw on the continuous relationships, most of which are temporary. The user’s existing skills for interacting with the real world, they underlying model combines a data-flow or constraint-like offer the promise of interfaces that are easier to learn and to component for the continuous relationships with an event- use. However, they are currently making interfaces more based component for discrete interactions, which can difficult to build. Advances in user interface design and enable or disable individual continuous relationships. The technology have outpaced the advances in languages and language thus separates non-WIMP interaction into two user interface management systems and tools. The result is components, each based on existing visual language that, today, previous generation command language approaches, and then provides a framework for connecting interfaces can now be specified and implemented very the two. effectively; current generation direct manipulation or Introduction WIMP interfaces are now moderately well served by user interface software tools; and the emerging concurrent, “Non-WIMP” user interfaces provide “non-command,” continuous, multi-mode non-WIMP interfaces are hardly parallel, continuous, multi-mode interaction—in contrast to handled at all. Most of today’s examples of non-WIMP current GUI or WIMP (Window, Icon, Menu, Pointer) style interfaces, such as virtual reality systems, have required interfaces [11]. This interaction style can be seen most considerable ad-hoc, low-level programming approaches, clearly in virtual reality interfaces, but its fundamental which, while very inventive, make these interfaces difficult characteristics are common to a more general class of to develop, share, and reuse. emerging user-computer environments, including new types of games, musical accompaniment systems, What is needed are languages for describing and intelligent agent interfaces, interactive entertainment implementing these interfaces at a higher level, closer to the media, pen-based interfaces, eye movement-based point of view of the user and the dialogue, rather than to the interfaces, and ubiquitous computing [18,24]. They share a exigencies of the implementation. This paper outlines a higher degree of interactivity than previous interfaces: visual language for describing and programming the fine- continuous input/output exchanges occurring in parallel, grained aspects of non-WIMP interaction. It is based on the rather than one single-thread dialogue. notion that the essence of a non-WIMP dialogue is a set of continuous relationships, most of which are temporary. Its Most current (WIMP) user interfaces are inherently underlying model combines a data-flow or constraint-like serial, turn-taking (“ping-pong style”) dialogues with a component for the continuous relationships with an event- based component for discrete interactions, which can enable or disable individual continuous relationships. It This work was supported in part by Grant No. N00014-95-1-G014 from the Naval Research Laboratory to Tufts and by Grant No. separates non-WIMP interaction into two components, each N00014-95-1-1099 from the Office of Naval Research to Tufts. We of which can exploit existing visual language approaches, gratefully acknowledge their support. and provides a framework for connecting the two. Background A question that arises is: Why can’t the problem of user interface design be solved directly by visual programming The main contribution of this approach will thus be its techniques? For example, why is an interactive interface separation of non-WIMP interaction into two components, builder, such as the NeXT Interface Builder or Visual Basic continuous and discrete, and its framework for not sufficient? Such a solution would handle the visual communication between the two spheres, rather than the layout of the objects in the next-generation user interface, languages for describing the internals of the two but it would not address the problem of describing new components themselves. The discrete component can use a interactive behaviors. variety of existing techniques for describing discrete event handlers. The continuous component is similar to a data- Languages for visual programming can be divided into flow graph or a set of one-way constraints between actual two categories. In the first, the object being designed is itself inputs and outputs. The model provides the ability to “re- a static graphical object—a menu, a screen layout, an wire” the graph from within the dialogue. Another goal is to engineering drawing, a typeset report, a font of type. While keep the model simple enough to allow very fast run-time such objects are frequently programmed in symbolic performance, with the ultimate purpose of supporting virtual languages (for example, a picture might be programmed as reality interfaces directly. a sequence of calls to Xlib graphics subroutines), they are obvious candidates for a “what you see is what you get” A variety of specification languages for describing WIMP mode of visual programming. A programming environment and other previous generations of user interfaces has been for such a visual programming language need only simulate developed, and user interface management systems have the appearance of the final object and provide direct been built based up on them [22], using approaches such as graphical commands for manipulating it. When the designer BNF or other grammar-based specifications [25], state is satisfied with its appearance, he or she saves it and has transition diagrams [23], event handlers [12], declarative thereby written a visual program. Such systems can combine specifications [25], constraints [13], and others [10,26], great power with ease of use, because the visual including visual languages [16]. programming language employed is a natural way to Several researchers are using constraints for describing describe the graphical object. It is so natural that the system the continuous aspect of graphical interfaces [8,9,19], and is often not considered a programming language other recent work in 3D interfaces uses similar continuous environment at all, but simply a “what you see is what you approaches [3,27]. Also addressing the description of get” style of editor. Unfortunately, this approach is only interfaces by continuous models, Mackinlay, Card, and possible where there can be a one-to-one correspondence Robertson allude to expressing interface syntax as between a visual programming language and the static connections between the ranges and domains of input visual object being programmed. devices and intermediate devices [21]. Lewis, Koved, and A more difficult problem arises with the second category Ling have addressed non-WIMP interfaces with an elegant of visual programming language. Here, visual programming UIMS for virtual reality, using concurrent event-based is used to represent something abstract, which does not have dialogues [20]. a direct graphical image—time sequence, hierarchy, While their focus is on widgets found in current WIMP conditional statements, frame-based knowledge. To provide interfaces, Abowd [1] and Carr [4,5] both present visual programming languages for these objects, it is specification languages that separate the discrete and necessary first to devise suitable graphical representations or continuous spheres along the same lines as this model. Both visual metaphors for them. The powerful principle of “what approaches support the separation of interaction into you see is what you get” is not much help, since the objects continuous and discrete as a natural and desirable model for are abstract. Applying the visual programming language specifying modern interactive interfaces. Carr provides an paradigm to these situations depends critically on choosing expressive visual language for specifying this type of good representations. behavior, with different types of connections for Sequence or interactive behavior of a user interface—as transmitting events or value changes. Abowd provides an opposed to layout—is just such a problem; we need to invent elegant formal specification language for describing this appropriate visual representations for it in order to use visual type of behavior, and uses the specification of a slider as a programming. Current interface builders usually handle key example. He strongly emphasizes