Brad T. Vander Zanden

Automatic, look-and-feel independent dialog creation for graphical user interfaces

Jade is a new interactive tool that automatically creates graphical input dialogs such as dialog boxes and menus. Application programmers write a textual specification of a dialogs contents. This specification contains absolutely no graphical information and thus is look-and-feel independent. The graphic artist uses a direct manipulation graphical editor to define the rules, graphical objects, interaction techniques, and decorations that will govern the dialogs look-and-feel, and stores the results in a look and feel database. Jade combines the application programmers specification with the look-and-feel database to automatically generate a graphical dialog. If necessary, the graphic artist can then edit the resulting dialog using a graphical editor and these edits will be remembered by Jade, even if the original textual specification is modified. By eliminating all graphical references from the dialogs content specification, Jade requires only the absolutely minimum specification from the application programmer. This also allows a dialog box or menus look and feel to be rapidly and effortlessly changed by simply switching look and feel databases. Finally, Jade permits complex inter-field relationships to be specified in a simple manner.

An incremental algorithm for satisfying hierarchies of multiway dataflow constraints

One-way dataflow constraints have gained popularity in many types of interactive systems because of their simplicity, efficiency, and manageability. Although it is widely acknowledged that multiway dataflow constraint could make it easier to specify certain relationships in these applications, concerns about their predictability and efficiency have impeded their acceptance. Constraint hierarchies have been developed to address the predictability problem, and incremental algorithms have been developed to address the efficiency problem. However, existing incremental alogrithms for satisfying constraint hierarchies encounter two difficulties : (1) they are incapable of guaranteeing an acylic solution if a constraint hierarchy has one or more cyclic solutions and (2) they require worst-case exponential time to satisfy systems of multioutput constriants. This article surmounts these difficulties by presenting an incremental algorithm called QuickPlan that satisfies in worst-case O(N2) time any hierarchy of multiway, multiout-put dataflow constraint that has at least one acyclic solution, where N is the number of constraints. With benchmarks and real problems that can be solved efficiently using exisitng algorithms, its performance is competitive or superior. With benchmarks and real problems that cannot be solved using exisitng algorithms or that cannot be solved efficiently, QuickPlan finds solutions and does so efficiently, typically in O(N) time or less. QuickPlan is based on the strategy of propagation of degrees of freedom. The only restriction it imposes is that every constraint method must use all of the variables in the constraint as either an input or an output variable. This requirement is met in every constraint-based, interactive application that we have developed or seen.

Creating graphical interactive application objects by demonstration

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.

Integrating pointer variables into one-way constraint models

Pointer variables have long been considered useful for constructing and manipulating data structures in traditional programming languages. This article discusses how pointer variables can be integrated into one-way constraint models and indicates how these constraints can be usefully employed in user interfaces. Pointer variables allow constraints to model a wide array of dynamic application behavior, simplify the implementation of structured objects and demonstrational systems, and improve the storage and efficiency of constraint-based applications. This article presents two incremental algorithms—one lazy and one eager— for solving constraints with pointer variables. Both algorithms are capable of handling (1) arbitrary systems of one-way constraints, including constraints that involve cycles, and (2) editing models that allow multiple changes between calls to the constraint solver. These algorithms are fault tolerant in that they can handle and recover gracefully from formulas that crash due to programmer error. Constraints that use pointer variables have been implemented in a comprehensive user interface toolkit, Garnet, and our experience with applications written in Garnet have proven the usefulness of pointer variable constraints. Many large-scale applications have been implemented using these constraints.

Demonstrational and constraint-based techniques for pictorially specifying application objects and behaviors

The Lapidary interface design tool is a demonstrational system that allows the graphics and run-time behaviors that go inside an application window to be specified pictorially. In particular, Lapidary allows the designer to draw example pictures of application-specific graphical objects that the end user will manipulate (such as boxes, arrows, or elements of a list), 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 hairline boxes to show where an object is being dragged). The run-time behavior of all these objects can be specified ina straightforward way using constraints, demonstration, and dialog boxes that allow the designer to provide abstract descriptions of the interactive response to the input devices. Lapidary generalizes from these specific example pictures and behaviors to create prototype objects and behaviors from which instances can be made at run-time. A novel feature of Lapidarys implementation is its use of constraints that have been explicitly specified by the designer to help it generalize example objects and behaviors and to guide it in making inferences.

Environment for rapidly creating interactive design tools

The Garnet toolkit was specifically designed to make highly interactive graphical programs easier to design and implement. Visual, interactive, user-interface design tools clearly fall into this category. At this point, we have used the Garnet toolkit to create three different interactive design tools: Gilt, a simple interface builder for laying out widgets; Lapidary, a sophisticated design tool for constructing application-specific graphics and custom widgets; and C32, a spreadsheet interface to constraints. The features of the Garnet toolkit that made these easier to create include use of a prototype-instance object system instead of the usual class-instance model, integration of constraints with the object system, graphics model that supports automatic graphical update and saving to disk of on-screen objects, separation of specifying the graphics of objects from their behavior, automatic layout of graphical objects in a variety of styles, and a widget set that supports such commonly used operations as selection, moving and growing objects, and displaying and setting their properties.

The Lapidary graphical interface design tool

The Lapidary interface design tool allows the graphics and run-time behaviors that go inside an application window, as well as the graphics and behaviors that go around the application window, such as menus and scroll bars, to be specified pictorially. In particular, Lapidary allows the designer to draw pictures of application-specific graphical objects that the end user will manipulate (such as boxes and arrows, or elements of a list), 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). The run-time behavior of all these objects can be specified in a straightforward way using constraints and dialog boxes that allow the designer to provide abstract descriptions of the interactive response to the input devices. Lapidary also generalizes from the specific example pictures to allow the graphics and behaviors to be specified by demonstration. Finally, Lapidary supports the construction and use of ‘‘widgets’’ (sometimes called interaction techniques or gadgets) such as menus, scroll bars, buttons and icons. Thus Lapidary allows all pictorial aspects of an application to be specified graphically. CR

The whiteboard environment: an electronic sketchpad for data structure design and algorithm description

Most instructors describe algorithms and data structures to students using a physical blackboard or a whiteboard and chalk or markers. This paper describes two tools, Data Structure Designer and Whiteboard, that provide an instructor with the functionality of a whiteboard. The environment provided by these tools improve upon a whiteboard by providing interactivity and dynamic capabilities that whiteboards lack. Data Structure Designer provides a direct manipulation, graphical editor, similar to a widget-editor, that allows users to create attractive, customized data structure objects that very closely resemble the pictures of data structures that appear in textbooks. The Whiteboard environment provides a drawing area where data structures created in the Data Structure Designer can be interactively drawn, populated with example data, and then used in the demonstration of algorithms. Built-in semantics facilitate common operations. For example, assignment is accomplished by dragging and dropping a variable onto another variable. These two tools make the interactive design of data structures and demonstration of algorithms fast and easy.

Dexter as a phd advisor

Dexter and I work in very different areas in Computer Science, so I cannot attest to his successes in Computer Science as I am sure others so eloquently will. However, I was Dexters first PhD graduate, and I can certainly attest to his skills as a PhD advisor. Dexter actually arrived at Cornell after I started my PhD program. He had a buzz of electricity about him and that quality above all others initially attracted my interest. At that time Dexter was already an accomplished theoretician. I know that he has considerably burnished that already formidable reputation in the intervening decades. My story is a different one though, and it winds through the area of graphical user interfaces.