Proceedings of the 2nd annual ACM SIGGRAPH symposium on User interface software and technology


 
Time and place:
Williamsburg, Virginia, United States
November 13 - 15, 1989
Editors:
Sibert, John L.
Conf. description:
UIST is the premier forum for innovations in developing human-computer interfaces. The symposium brings together user-interface researchers and practitioners with an interest in techniques, tools, and technology for constructing high-quality, innovative user interfaces.
Help us!
Do you know when the next conference is? If yes, please add it to the calendar!
Series:
This is a preferred venue for people like Scott E. Hudson, Ravin Balakrishnan, Brad A. Myers, Steven K. Feiner, and Takeo Igarashi. Part of the UIST - Symposium on User Interface Software and Technology conference series.
Other years:
ISBN:
0897913353
Publisher:
ACM Press
EDIT

References from this conference (1989)

The following articles are from "Proceedings of the 2nd annual ACM SIGGRAPH symposium on User interface software and technology":

 what's this?

Articles

p. 1-9

Seligmann, Doree Duncan and Feiner, Steven K. (1989): Specifying Composite Illustrations with Communicative Goals. In: Sibert, John L. (ed.) Proceedings of the 2nd annual ACM SIGGRAPH symposium on User interface software and technology November 13 - 15, 1989, Williamsburg, Virginia, United States. pp. 1-9.

IBIS (Intent-Based Illustration System) generates illustrations automatically, guided by communicative goals. Communicative goals specify that particular properties of objects, such as their color, size, or location are to be conveyed in the illustration. IBIS is intended to be part of an interactive multimedia explanation generation system. It has access to a knowledge base that contains a collection of objects, including information about their geometric properties, material, and location. As the goals are interpreted by a rule-based control component, the system generates a precise definition of the final illustration. If IBIS determines that a set of goals cannot be satisfied in a single picture, then it attempts to create a composite illustration that has multiple viewports. For example, a composite illustration may contain a nested inset illustration showing an object in greater detail than is possible in the parent picture. Each component illustration is defined by its placement, size, viewing specification, lighting specification, and list of objects to be displayed and their graphical style.

© All rights reserved Seligmann and Feiner and/or ACM Press

p. 10-18

Robertson, George G., Card, Stuart K. and Mackinlay, Jock D. (1989): The Cognitive Coprocessor Architecture for Interactive User Interfaces. In: Sibert, John L. (ed.) Proceedings of the 2nd annual ACM SIGGRAPH symposium on User interface software and technology November 13 - 15, 1989, Williamsburg, Virginia, United States. pp. 10-18.

The graphics capabilities and speed of current hardware systems allow the exploration of 3D and animation in user interfaces, while improving the degree of interaction as well. In order to fully utilize these capabilities, new software architectures must support multiple, asynchronous, interacting agents (the Multiple Agent Problem), and support smooth interactive animation (the Animation Problem). The Cognitive Coprocessor is a new user interface architecture designed to solve these two problems, while supporting highly interactive user interfaces that have 2D and 3D animations. This architecture includes 3D Rooms, a 3D analogy to the Rooms system with Rooms Buttons extended to Interactive Objects that deal with 3D, animation, and gestures. This research is being tested in the domain of Information Visualization, which uses 2D and 3D animated artifacts to represent the structure of information. A prototype, called the Information Visualizer, has been built.

© All rights reserved Robertson et al. and/or ACM Press

p. 105-114

Hudson, Scott E. (1989): Graphical Specification of Flexible User Interface Displays. In: Sibert, John L. (ed.) Proceedings of the 2nd annual ACM SIGGRAPH symposium on User interface software and technology November 13 - 15, 1989, Williamsburg, Virginia, United States. pp. 105-114.

This paper describes the implementation concepts behind the user interface editor of the Apogee UIMS. This editor allows many aspects of a user interface to be specified graphically without a conventional textual specification. The system supports the specification of flexible user interfaces -- ones that can adapt automatically to changes in the size of objects they present and that can adapt to specific user needs in a dynamic and responsive fashion. To serve as an implementation base for this editor, the Apogee UIMS supports an active data model based on one-way constraints. This model is implemented by a small object-oriented programming language embedded within the system.

© All rights reserved Hudson and/or ACM Press

p. 115-123

Mao, Qijing and Tai, Juwei (1989): Defining the Presentation of Application Data by a Graphical Language. In: Sibert, John L. (ed.) Proceedings of the 2nd annual ACM SIGGRAPH symposium on User interface software and technology November 13 - 15, 1989, Williamsburg, Virginia, United States. pp. 115-123.

On the basis of a graphical language for defining a dynamic picture and the control actions applied to it, a system is built for developing the presentation of application data for user interfaces. This system provides user interface developers a friendly and high efficient programming environment.

© All rights reserved Mao and Tai and/or ACM Press

p. 124-126

Wiecha, Charles (1989): Direct Manipulation or Programming: How Should We Design Interfaces?. In: Sibert, John L. (ed.) Proceedings of the 2nd annual ACM SIGGRAPH symposium on User interface software and technology November 13 - 15, 1989, Williamsburg, Virginia, United States. pp. 124-126.

p. 127-132

Dannenberg, Roger and Amon, Dale (1989): A Gesture Based User Interface Prototyping System. In: Sibert, John L. (ed.) Proceedings of the 2nd annual ACM SIGGRAPH symposium on User interface software and technology November 13 - 15, 1989, Williamsburg, Virginia, United States. pp. 127-132.

GID, for Gestural Interface Designer, is an experimental system for prototyping gesture-based user interfaces. GID structures an interface as a collection of "controls": objects that maintain an image on the display and respond to input from pointing and gesture-sensing devices. GID includes an editor for arranging controls on the screen and saving screen layouts to a file. Once an interface is created, GID provides mechanisms for routing input to the appropriate destination objects even when input arrives in parallel from several devices. GID also provides low level feature extraction and gesture representation primitives to assist in parsing gestures.

© All rights reserved Dannenberg and and/or ACM Press

p. 133-140

Carlsen, Niels Vejrup, Christensen, Niels Jrgen and Tucker, Hugh A. (1989): An Event Language for Building User Interface Frameworks. In: Sibert, John L. (ed.) Proceedings of the 2nd annual ACM SIGGRAPH symposium on User interface software and technology November 13 - 15, 1989, Williamsburg, Virginia, United States. pp. 133-140.

Languages based on the event model are widely regarded as expressive and flexible notations for the specification of interactive graphical user interfaces. However, until now, they have only been used to specify and implement the dialogue control component of user interfaces. This paper presents an extension of the event model. A computable notation, the event language, based on this is used to construct a complete user interface framework. The framework forms the run-time component of a UIMS. The event language allows the modular construction of complex event systems. This is supported by the addition of a tagged addressing mode. Furthermore, the control structure of event handlers is extended with exception management, permitting unspecified events and thereby facilitating the use of predefined building blocks. A general purpose run-time framework for user interfaces has been constructed using the event language. We present the architecture of the presentation component of this framework including the window manager and the I/O model.

© All rights reserved Carlsen et al. and/or ACM Press

p. 141-148

McKay, Scott, York, William and McMahon, Michael (1989): A Presentation Manager Based on Application Semantics. In: Sibert, John L. (ed.) Proceedings of the 2nd annual ACM SIGGRAPH symposium on User interface software and technology November 13 - 15, 1989, Williamsburg, Virginia, United States. pp. 141-148.

We describe a system for associating the user interface entities of an application with their underlying semantic objects. The associations are classified by arranging the user interface entities in a type lattice in an object-oriented fashion. The interactive behavior of the application is described by defining application operations in terms of methods on the types in the type lattice. This scheme replaces the usual "active region" interaction model, and allows application interfaces to be specified directly in terms of the objects of the application itself. We discuss the benefits of this system and some of the difficulties we encountered.

© All rights reserved McKay et al. and/or ACM Press

p. 149-157

Reiss, Steven P., Meyers, Scott and Duby, Carolyn (1989): Using GELO to Visualize Software Systems. In: Sibert, John L. (ed.) Proceedings of the 2nd annual ACM SIGGRAPH symposium on User interface software and technology November 13 - 15, 1989, Williamsburg, Virginia, United States. pp. 149-157.

GELO is a package that supports the interactive graphical display of software systems. Its features include built-in panning and zooming, abstraction of objects too small to see, pick correlation, windowing, and scroll bars. GELO creates a hierarchy of graphical objects that correspond to the components of the structure being displayed. Five flavors of graphical objects are supported, including those for simple structures, tiled layouts, and graph-based layouts. This framework is powerful enough to handle a wide variety of graphical visualizations, and it is general enough that new object flavors can be smoothly integrated in the future. GELO is easy to learn and to use, and is presently employed in two software development environments. Among its current applications are a variety of visual languages, an interactive display of call graphs, an interactive display of data structures, and a graphical representation of module dependencies.

© All rights reserved Reiss et al. and/or ACM Press

p. 158-167

Vlissides, John and Linton, Mark A. (1989): Unidraw: A Framework for Building Domain-Specific Graphical Editors. In: Sibert, John L. (ed.) Proceedings of the 2nd annual ACM SIGGRAPH symposium on User interface software and technology November 13 - 15, 1989, Williamsburg, Virginia, United States. pp. 158-167.

Unidraw is a framework for creating object-oriented graphical editors in domains such as technical and artistic drawing, music composition, and CAD. The Unidraw architecture simplifies the construction of these editors by providing programming abstractions that are common across domains. Unidraw defines four basic abstractions: components encapsulate the appearance and behavior of objects, tools support direct manipulation of components, commands define operations on components, and external representations define the mapping between components and a file or database. Unidraw also supports multiple views, graphical connectivity, and dataflow between components. This paper presents Unidraw and three prototype domain-specific editors we have developed with it: a schematic capture system, a user interface builder, and a drawing editor. Experience indicates a substantial reduction in implementation time and effort compared with existing tools.

© All rights reserved Vlissides and and/or ACM Press

p. 168-179

Powers, Michael K. (1989): Ensemble: A Graphical User Interface Development System for the Design and Use of Interactive Toolkits. In: Sibert, John L. (ed.) Proceedings of the 2nd annual ACM SIGGRAPH symposium on User interface software and technology November 13 - 15, 1989, Williamsburg, Virginia, United States. pp. 168-179.

User Interface Development Systems (UIDS), as opposed to User Interface Management Systems or UI Toolkits focus on supporting the design and implementation of the user interface. This paper describes Ensemble, an experimental UIDS that begins to explore the electronic creation of interaction techniques as well as the corresponding design processes. Issues related to the impact on the components of the development system are discussed. Finally, problems with the current implementation and future directions are presented.

© All rights reserved Powers and/or ACM Press

p. 19-24

Sturman, David, Zeltzer, David and Pieper, Steve (1989): Hands-on Interaction with Virtual Environments. In: Sibert, John L. (ed.) Proceedings of the 2nd annual ACM SIGGRAPH symposium on User interface software and technology November 13 - 15, 1989, Williamsburg, Virginia, United States. pp. 19-24.

In this paper we describe the evolution of a whole-hand interface to our virtual-environment graphical system. We present a set of abstractions that can be used to implement device-independent interfaces for hand measurement devices. Some of these abstractions correspond to known logical device abstractions, while others take further advantage of the richness of expression in the human hand. We describe these abstractions in the context of their use in our development of virtual environments.

© All rights reserved Sturman et al. and/or ACM Press

p. 25-33

Wielemaker, Jan and Anjewierden, Anjo (1989): Separating User Interface and Functionality Using a Frame Based Data Model. In: Sibert, John L. (ed.) Proceedings of the 2nd annual ACM SIGGRAPH symposium on User interface software and technology November 13 - 15, 1989, Williamsburg, Virginia, United States. pp. 25-33.

The separation between user interface and functionality found in many screen editors is generalised to handle a data model based on frames and binary relations. This paper describes a User Interface Management System (UIMS) based on the data model. The UIMS is capable of maintaining different and simultaneous representations of the same application data objects. The functionality and user interface are implemented on top of a small object oriented programming system. This allows the UIMS to be simple and independent of the graphics software and hardware as well as the data representation used by the application programs.

© All rights reserved Wielemaker and Anjewierden and/or ACM Press

p. 34-42

Szekely, Pedro (1989): Standardizing the Interface Between Applications and UIMSs. In: Sibert, John L. (ed.) Proceedings of the 2nd annual ACM SIGGRAPH symposium on User interface software and technology November 13 - 15, 1989, Williamsburg, Virginia, United States. pp. 34-42.

The user interface building blocks of any User Interface Management System (UIMS) have built-in assumptions about what information about application programs they need, and assumptions about how to get that information. The lack of a standard to represent this information leads to a proliferation of different assumptions by different building blocks, hampering changeability of the user interface and portability of applications to different sets of building blocks. This paper describes a formalism for specifying the information about applications needed by the user interface building blocks (i.e. the UIMS/Application interface) so that all building blocks share a common set of assumptions. The paper also describes a set of user interface building blocks specifically designed for these standard UIMS/Application interfaces. These building blocks can be used to produce a wide variety of user interfaces, and the interfaces can be changed without having to change the application program.

© All rights reserved Szekely and/or ACM Press

p. 43-52

Lowgren, Jonas (1989): An Architecture for Expert System User Interface Design and Management. In: Sibert, John L. (ed.) Proceedings of the 2nd annual ACM SIGGRAPH symposium on User interface software and technology November 13 - 15, 1989, Williamsburg, Virginia, United States. pp. 43-52.

From a user interface point of view, expert systems are different from applications in general in that the reasoning process of the system often defines the dialogue structure. This has several advantages, but there may also be problems due to the lack of separation between functionality and user interface. This paper investigates the possibility of treating an expert system user interface as separate from the reasoning process of the system, and the consequences thereof. We propose that an expert system user interface can be seen as a combination of two different structures; the surface dialogue, comprising mainly lexical and syntactical aspects, and the session discourse which represents the interaction between user and system on a discourse level. A proposed architecture for a software tool managing these two structures is presented and discussed, with particular emphasis on the session discourse manager.

© All rights reserved Lowgren and/or ACM Press

p. 53-61

Hix, Deborah (1989): A Procedure for Evaluating Human-Computer Interface Development Tools. In: Sibert, John L. (ed.) Proceedings of the 2nd annual ACM SIGGRAPH symposium on User interface software and technology November 13 - 15, 1989, Williamsburg, Virginia, United States. pp. 53-61.

p. 62-66

Coble, Michael D., Hetzler, Elizabeth G. and Totten, Steven W. (1989): Improving Usability by Sharing Knowledge. In: Sibert, John L. (ed.) Proceedings of the 2nd annual ACM SIGGRAPH symposium on User interface software and technology November 13 - 15, 1989, Williamsburg, Virginia, United States. pp. 62-66.

There has been great progress in the technology of improving the usability of computer tools. However, the state of the art in the user interface field is far outdistancing the state of affairs at many corporations. One reason is that the knowledge is not effectively communicated, especially in large, complex organizations. At McDonnell Douglas Corporation we have formed the User Interface Share Group to enhance information exchange on user interface technology. This paper discusses the motivation for the group, its formation, its value to the corporation, and some specific lessons learned.

© All rights reserved Coble et al. and/or ACM Press

p. 67-75

Bennett, William, Boies, Stephen J., Gould, John D., Greene, Sharon L. and Wiecha, Charles (1989): Transformations on a Dialog Tree: Rule-Based Mapping of Content to Style. In: Sibert, John L. (ed.) Proceedings of the 2nd annual ACM SIGGRAPH symposium on User interface software and technology November 13 - 15, 1989, Williamsburg, Virginia, United States. pp. 67-75.

p. 76-85

Beshers, Clifford and Feiner, Steven K. (1989): Scope: Automated Generation of Graphical Interfaces. In: Sibert, John L. (ed.) Proceedings of the 2nd annual ACM SIGGRAPH symposium on User interface software and technology November 13 - 15, 1989, Williamsburg, Virginia, United States. pp. 76-85.

We describe the design and prototype implementation of Scope, a system that generates graphical user interfaces for applications programmed in C++. The programmer chooses application data objects and functions that define the capabilities of the interface. At runtime, an interface design component, implemented as a set of production system rules, transforms this semantic specification into an interface built using a window system, an associated user interface toolkit, and the hardware input devices available on the system. The rules match application requirements against a semantic description of the toolkit, selecting virtual devices for input, output, and layout. Thus, Scope uses design rules to create interfaces from high-level programming semantics that are customized both for the application and the run-time environment.

© All rights reserved Beshers and and/or ACM Press

p. 86-94

Singh, Gurminder and Green, Mark (1989): Chisel: A System for Creating Highly Interactive Screen Layouts. In: Sibert, John L. (ed.) Proceedings of the 2nd annual ACM SIGGRAPH symposium on User interface software and technology November 13 - 15, 1989, Williamsburg, Virginia, United States. pp. 86-94.

The UofA User Interface Management System (UIMS) generates graphical user interfaces based on a high-level description of semantic commands supported by the application. A main part of the UIMS, called Chisel, generates the presentation component of interfaces. Chisel selects interaction techniques, determines their attributes, and places them on the screen of the display device. While doing so it is capable of considering device properties, end user's preferences, and interface designer's guidelines. The aim of this paper is to discuss in detail the design and implementation of Chisel.

© All rights reserved Singh and Green and/or ACM Press

p. 95-104

Myers, Brad A., Zanden, Brad Vander and Dannenberg, Roger (1989): Creating Graphical Interactive Application Objects by Demonstration. In: Sibert, John L. (ed.) Proceedings of the 2nd annual ACM SIGGRAPH symposium on User interface software and technology November 13 - 15, 1989, Williamsburg, Virginia, United States. pp. 95-104.

The Lapidary user interface tool allows all pictorial aspects of programs to be specified graphically. In addition, the behavior of these objects at run-time can be specified using dialogue boxes and by demonstration. In particular, Lapidary allows the designer to draw pictures of application-specific graphical objects which will be created and maintained at run-time by the application. This includes the graphical entities that the end user will manipulate (such as the components of the picture), the feedback that shows which objects are selected (such as small boxes on the sides and corners of an object), and the dynamic feedback objects (such as hair-line boxes to show where an object is being dragged). In addition, Lapidary supports the construction and use of "widgets" (sometimes called interaction techniques or gadgets) such as menus, scroll bars, buttons and icons. Lapidary therefore supports using a pre-defined library of widgets, and defining a new library with a unique "look and feel." The run-time behavior of all these objects can be specified in a straightforward way using constraints and abstract descriptions of the interactive response to the input devices. Lapidary generalizes from the specific example pictures to allow the graphics and behaviors to be specified by demonstration.

© All rights reserved Myers et al. and/or ACM Press




User-contributed notes

Give us your opinion! Do you have any comments/additions
that you would like other visitors to see?

 
comment You (your email) say: Aug 26th, 2014
#1
Aug 26
Add a thoughtful commentary or note to this page ! 
 

your homepage, facebook profile, twitter, or the like
will be spam-protected
How many?
= e.g. "6"
User ExperienceBy submitting you agree to the Site Terms
 
 
 
 

Changes to this page (conference)

28 May 2003: Added

Page Information

Page maintainer:
This is a tablet-optimized version of http://www.interaction-design.org/references/conferences/proceedings_of_the_2nd_annual_acm_siggraph_symposium_on_user_interface_software_and_technology.html

Upcoming Courses

go to course
Quality Web Communication: The Beginner's Guide
Starts tomorrow LAST CALL!
go to course
User-Centred Design - Module 2
88% booked. Starts in 7 days
 
 

Featured chapter

Marc Hassenzahl explains the fascinating concept of User Experience and Experience Design. Commentaries by Don Norman, Eric Reiss, Mark Blythe, and Whitney Hess

User Experience and Experience Design !

 
 

Our Latest Books

 
 
Gamification at Work: Designing Engaging Business Software
by Janaki Mythily Kumar and Mario Herger
start reading
 
 
 
 
The Social Design of Technical Systems: Building technologies for communities
by Brian Whitworth and Adnan Ahmad
start reading
 
 
 
 
The Encyclopedia of Human-Computer Interaction, 2nd Ed.
by Mads Soegaard and Rikke Friis Dam
start reading
 
 

Upcoming Courses

go to course
Quality Web Communication: The Beginner's Guide
Starts tomorrow LAST CALL!
go to course
User-Centred Design - Module 2
88% booked. Starts in 7 days