David S. Kosbie

Reusable hierarchical command objects

The Amulet user interface development environment uses hierarchical command objects to support the creation of highly-interactive graphical user interfaces. When input arrives or a widget is operated by the user, instead of invoking a call-back procedure as in most other toolkits, Amulet allocates a command object and calls its DO method. Unlike previous uses of command objects, Amulet organizes the commands into a hierarchy, so that low-level operations like dragging or selection invoke low-level commands, which in turn might invoke widget-level commands, which invoke high-level, application-specific commands, and so on. The top-level commands correspond to semantic actions of the program. The result is better modularization because different levels of the user interface are independent, and better code reuse because the lower-level commands, and even many high-level commands such as cut, copy, paste, text edit, and change-color, can be reused from the library. Furthermore, the commands in Amulet support a new form of Undo, where the user can select any previous operation and selectively undo it, repeat it on the same objects, or repeat it on new objects. In addition, operations like scrolling and selections can be undone or repeated, which can be very useful. Thus, the command objects in Amulet make it easier for developers by providing more reusable components, while at the same time providing new capabilities for users.

Marquise: creating complete user interfaces by demonstration

Marquise is a new interactive tool that allows virtually all of the user interfaces of graphical editors to be created by demonstration without programming. A “graphical editor” allows the user to create and manipulate graphical objects with a mouse. This is a very large class of programs and includes drawing programs like MacDraw, graph layout editors like MacProject, visual language editors, and many CAD/CAM programs. The primary innovation in Marquise is to allow the designer to demonstrate the overall behavior of the interface. To implement this, the Marquise framework contains knowledge about palettes for creating and specifying properties of objects, and about operations such as selecting, moving, and deleting objects. The interactive tool uses the framework to allow the designer to demonstrate most of the end users actions without programming, which means that Marquise can be used by non-programmers.

Lessons learned about one-way, dataflow constraints in the Garnet and Amulet graphical toolkits

One-way, dataflow constraints are commonly used in graphical interface toolkits, programming environments, and circuit applications. Previous papers on dataflow constraints have focused on the design and implementation of individual algorithms. In contrast, this article focuses on the lessons we have learned from a decade of implementing competing algorithms in the Garnet and Amulet graphical interface toolkits. These lessons reveal the design and implementation tradeoffs for different one-way, constraint satisfaction algorithms. The most important lessons we have learned are that (1) mark-sweep algorithms are more efficient than topological ordering algorithms; (2) lazy and eager evaluators deliver roughly comparable performance for most applications; and (3) constraint satisfaction algorithms have more than adequate speed, except that the storage required by these algorithms can be problematic.

Automating Tasks for Groups of Users: A System-Wide Epiphyte Approach

End-users have to use macro-recorders when they want to automate tedious tasks. Their tasks often include actions from multiple applications. While some application-specific macro facilities or PBD systems have proved efficient to automate single-application tasks, system-wide — and hence application-independent — systems are few. Most system-wide recorders operate on low-level events whereas most repetitive activities are repetitive at a somewhat higher level of abstraction. We present a so-called “epiphyte” approach allowing automation of some of the repetitive tasks only, but working with unmodified applications. It uses external and partial application models to allow recording of hierarchical event histories which in turn facilitate the detection, generalization, anticipation and completion of repetitive sequences of actions. In this approach, experts are in charge of building external application models. We present some features which facilitate and quicken their work particularly in the context of a group of users.

Lessons learned from programmers' experiences with one-way constraints: Research Articles

The effect of multiple reference characters and the condition types on the performance of exact string-searching algorithms is tested. In order to perform such a test a new algorithm called the Multiple Reference Characters Algorithm (MRCA) is developed. An experiment is performed using English text; the results are compared with the known string-matching algorithms called Boyer–Moore–Horspool (BMH) and Straight Forward (Naive). With the MRCA algorithm, the shift distance is increased up to 3m + 1 positions in comparison with exactly one position in the Naive algorithm and up to m positions in BMH. Furthermore, by using the new algorithm MRCA, the results suggest that the evaluation criteria of the average number of comparisons, the average number of shifts, and the clock time required by BMH are improved up to 73.1p, 64.7p, and 49.6p, respectively. The same evaluation criteria required by Naive are improved by MRCA up to 98.1p, 98p, and 94.7p, respectively. Copyright

Hierarchical events in graphical user interfaces

This poster describes part of the Ph.D. thesis work presented by the author in the 1994 CHI Doctoral Consortium. There are many uses of history mechanisms in modern graphical user interfaces, including Undo, Help, and Programming by Demonstration. Virtually all research into history mechanisms, however, presumes that the history is simply a linear sequence of unstructured events. People, however, use computers to perform richly-structured tasks. The basic premise of this thesis is that including the task structure in the event history will allow Undo, PBD, and other history mechanisms to operate more correctly and in more situations. A second premise is that hierarchical event histories can be presented to end users in an understandable and useful manner. This poster describes Katie, an application environment which demonstrates the viability of these premises.