Many end-users wish to customize their applications, automating common tasks and routines. Unfortunately, this automation is difficult today — users must choose between brittle macros and complex scripting languages. Programming by demonstration (PBD) offers a middle ground, allowing users to demonstrate a procedure multiple times and generalizing the requisite behavior with machine learning. Unfortunately, many PBD systems are almost as brittle as macro recorders, offering few ways for a user to control the learning process or correct the demonstrations used as training examples. This paper presents CHINLE, a system which automatically constructs PBD systems for applications based on their interface specification. The resulting PBD systems have novel interaction and visualization methods, which allow the user to easily monitor and guide the learning process, facilitating error recovery during training. CHINLE-constructed PBD systems learn procedures with conditionals and perform partial learning if the procedure is too complex to learn completely. ACM Classification D.2.2 [Design Tools and Techniques]: User Interfaces, H1.2. [Models and principles]: User/Machine

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 inferencing 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 ...

this paper, we present an efficient method for automatically generalizing programs written in spreadsheet languages. The strategy is to do generalization through incremental analysis of logical relationships among concrete program entities from the perspective of a particular computational goal. The method uses deductive dataflow analysis with algebraic back-substitution rather than inference with heuristics, and there is no need for generalization-related dialog with the user. We present the algorithms and their time complexities and show that, because the algorithms perform their analyses incrementally, on only the on-screen program elements rather than on the entire program, the method is scalable. Performance data is presented to help demonstrate the scalability. Categories and Subject Descriptors: D.3.3 [Programming Languages]: Language Constructs and Features---procedures, functions, and subroutines; H.4.1 [Information Systems Applications]: Office Automation---spreadsheets; D.1.7 [Programming Techniques]: Visual Programming General Terms: Human Factors, Languages Additional Key Words and Phrases: Human-computer interaction, concrete programming, graphical programming, Forms/3, spreadsheet languages, generalization 1.

Pavlov is a Programming By Demonstration (PBD) system that allows animated interfaces to be created without programming. Using a drawing editor and a clock, designers specify the behavior of a target interface by demonstrating stimuli (end-user actions or time) and the (time-stamped) graphical transformations that should be executed in response. This stimulus-response model allows interaction and animation to be defined in a uniform manner, and it allows for the demonstration of interactive animation, i.e., game-like behaviors in which the end-user (player) controls the speed and direction of object movement.

This paper consists of two parts. The first section makes a case for spending some time at the symposium designing a common representation for user tasks and their automation. The second section briefly presents Grizzly Bear, a demonstrational tool that I have built over the last three years (and which taught me the importance of a well-defined underlying representation the hard way).

this document are those of the authors and should not be interpreted as representing the official policies, either expressed or implied, of the U.S. government