Martin R. Frank

Adaptive and Automated Index Selection in RDBMS

We present a novel approach for a tool that assists the database administrator in designing an index configuration for a relational database system. A new methodology for collecting usage statistics at run time is developed which lets the optimizer estimate query execution costs for alternative index configurations. Defining the workload specification required by existing index design tools may be very complex for a large integrated database system. Our tool automatically derives the workload statistics. These statistics are then used to efficiently compute an index configuration. Execution of a prototype of the tool against a sample database demonstrates that the proposed index configuration is reasonably close to the optimum for test query sets.

A pure reasoning engine for programming by demonstration

We present an inference engine that can be used for creating Programming By Demonstration systems. The class of systems addressed are those which infer a state change description from examples of state [9, 11]. The engine can easily be incorporated into an existing design environment that provides an interactive object editor. The main design goals of the inference engine are responsiveness and generality. All demonstrational systems must respond quickly because of their interactive use. They should also be general—they should be able to make inferences for any attribute that the user may want to define by demonstration, and they should be able to treat any other attributes as parameters of this definition. The first goal, responsiveness, is best accommodated by limiting the number of attributes that the inference engine takes into consideration. This, however, is in obvious conflict with the second goal, generality. This conflict is intrinsic to the class of demonstrational system described above. The challenge is to find an algorithm which responds quickly but does not heuristically limit the number of attributes it looks at. We present such an algorithm in this paper. A companion paper describes Inference Bear [4], an actual demonstrational system that we have built using this inference engine and an existing user interface builder [5].

Model-based user interface design by example and by interview

Model-based user interface design is centered around a description of application objects and operations at a level of abstraction higher than that of code. A good model can be used to support multiple interfaces, help separate interface and application, describe input sequencing in a simple way, check consistency and completeness of the interface, evaluate the interface’s speed-of-use, generate context-specific help and assist in designing the interface. However, designers rarely use computer-supported application modelling today and prefer less formal approaches such as story boards of user interface prototypes. One reason is that available tools often use cryptic languages for the model specification. Another reason is that these tools force the designers to specify the application model before they can start working on the visual interface, which is their main area of expertise. We present the Interactive User Interface Design Environment (Interactive UIDE), a novel framework for concurrent development of the application model and the user interface which combines story-boarding and model-based interface design. We also present Albert, an intelligent component within this framework, which is able to infer an application model from a user interface and from an interview process with the designer.

Inference bear: designing interactive interfaces through before and after snapshots

We present Inference Bear (“An I ference Creature based on Before andAfter Snapshots”) which lets users build functional graphical user interfaces by demonstration. Inference Bear is unique in its use of a domain-independent reasoning engine. This approach has several advantages over systems that are closely tied to their domains. Most notably, Inference Bear reasons about a class of relationships that is defined by their computational complexity while rule-based systems are limited to reasoning about the class of relationships that the designer foresaw when building the system. However, it is also more difficult to design domain-independent demonstrational systems that are as easy to use as their domain-specific counterparts. The paper addresses this issue, and other issues relating to domain-independence.

Grizzly Bear: a demonstrational learning tool for a user interface specification language

Grizzly Bear is a new demonstrational tool for specifying user interface behavior. It can handle multiple application windows, dynamic object instantiation and deletion, changes to any object attribute, and operations on sets of objects. It enables designers to experiment with rubber-banding, deletion by dragging to a trashcan and many other interactive techniques. To the author’s best knowledge it is currently the most complete demonstrational user interface design tool that does not base its in ferencing on rule-based guessing. There are inherent limitations to the range of user interfaces that can ever be built by demonstration alone. Grizzly Bear is therefore designed to work hand-in-hand with a user interface specification language called the Elements, Events & Transitions model. As designers demonstrate behavior, they can watch Grizzly Bear incrementally build the corresponding textual specification, letting them learn the language on the fly. They can then apply their knowledge by modifying Grizzly Bear’s textual inferences, which reduces the need for repetitive demonstrations and provides an escape mechanism for behavior that cannot be demonstrated.

A Model-Based User Interface Architecture: Enhancing a Runtime Environment with Declarative Knowledge

A model-based user interface environment refers to an interface design and execution environment which utilizes declarative semantic knowledge about application interfaces. We capture in the application model tasks which will be performed by users, their operational constraints, and objects on which these tasks operate. We capture in the interface model interface components, application-independent interface tasks, and operational constraints on these tasks. Mapping from the application to the interface model serves as a means to construct an interface to an application. Modeling components in the interface model are coupled with executable components, thereby forming working interfaces. They also support intelligent behavior such as partially automatic control sequencing, automatic generation of textual and animated help, and recordings of statistical and chronological command usage history. The modeling components in UIDE are task-oriented. Specifying an interface through these components not only eliminates the low-level programming from the interface creation process, but also makes the design process centered around user tasks.

Building user interfaces interactively using pre- and postconditions

A tool is presented which allows graphic layout of a user interface integrated with specification of behavior using pre- and postconditions.

Model-base user interface design by example and by answering questions

Model-based user interface design is based on a description of application objects and operations at a level of abstraction higher than that of code. A good model can be used to assist in designing the user interface, support multiple interfaces, help separate interface and application, describe input sequencing in a simple way, check consistency and completeness of the interfaee, evaluate its speed-of-use and generate context-specific textual and animated help. However, designers rarely use computer-supported application modelling today and prefer less formal approaches such as using a story board of interface prototypes. One reason is that available tools use special-purpose languages for the model spw ification. Another reason is that these tools force the designers to specify the application model before they can start working on the visual interface, which is their main area of expertise. We present a novel methodology for concurrent development of the user interface and the application model which overcomes both problems by combining story-boarding and model-based interface design.