1 Abstraction as a Means for End-User Computing in Creative Applications Mira Balaban (mira@cs.bgu.ac.il) Eli Barzilay (eli@cs.cornell.edu) Michael Elhadad (elhadad@cs.bgu.ac.il) Abstract— End-User computing is needed in creative artistic applications or integrated editing environments, where the ac- tivity cannot be planned in advance. Following [1], Concrete abstractions (abstractions from examples), are suggested as a new mode for function definition, appropriate for end-user editor programmability. For certain applications, the direct, associative, not planned in advance character of concrete abstraction plays a qualitative role in the mere ability to specify abstractions. In this paper we propose to use concrete abstraction as a general tool for end-user programmability in editors. We distinguish two kinds of abstractions: value abstraction and structure abstraction, and explain how they can be combined. We describe a framework of historical editing that is based on a double view, in which the two abstraction kinds are combined. Finally, BOOMS [2], an implemented prototype for such an editing framework is described. BOOMS is a domain independent toolkit, with three sample instantiations. We believe that the proposed framework captures the conceptualization operation that characterizes creative, associative work types, and addresses the needs for end-user computing in integrated environments. Index Terms— Concrete abstraction, creative applications, mu- sic composition, end-user computing, historical editing, inte- grated environments. I. I NTRODUCTION E ND-USER computing is needed in domains or applica- tions where the activity cannot be planned in advance. For example, in artistic applications, an experimental mode of operation is common. In that mode the artist “plays with the material” until the “right” intentions are formed. In music composition a composer might wish to abstract away some parameters from a concrete piece, generalize the structure of a piece, apply these patterns on a different material, combine and repeat patterns, etc. These methods have the quality of programming processes, even if they are not usually termed as such. Smart editors also provide capabilities for end-user comput- ing, since the designer of the editor cannot foresee and prepare procedures for the desired patterns of editing and of user behavior. Modern editors function as general computer envi- ronments that control the overall range of activities involved in a human-computer interaction. The editor is the management system that supports generation, update, modification, testing, running applications, providing feedback, system integration, etc. As such, modern editors need to provide services that This work was supported in part by the Paul Ivanir Center for Robotics and Production Management at Ben-Gurion University of the Negev. go beyond the immediate command-reaction character of traditional editors. These objectives are achieved by enhancing editors with end-user programming capabilities. Editor programmability can help in avoiding repetitive operations, and ensure consistency by abstracting complex operations. In a text editor, for example, a user might wish to make all emphasized text use a bold font instead of italic font. In a graphical editor, a user might wish to change the background color of all square windows to blue. These are examples for simple operations that should be applied to many objects. An example for a complex operation that should be applied to multiple objects is: “make all grids that represent numerical tables use double lines.” Although this operation might involve only few objects, a uniform application via abstraction can help in preventing user errors that can be expected when complex operations are repeated. Some editors are further strengthened to include full pro- gramming capabilities. These include the ability to combine primitive editor operations to form compound structures of editor operations, create editor functions (abstractions) that apply editor operations to document arguments, and enable naming. For example, Emacs uses a full programming lan- guage (Emacs Lisp), enhanced with document data structures and primitive editor operations, that are integrated within a user interface; Word enables users to define macro operations, and write programs in Word Basic which is a variant of Visual Basic; and graphic tools such as Photoshop can create HTML widgets. Nevertheless, standard end-user computing requires pro- gramming capabilities on the part of the user. In artistic appli- cations, like music composition, as described above, planned end-user programming is not relevant, since the activity is not planned and the users are not programmers. In powerful editors planned end-user programming is also unsatisfactory, even for users that have programming capabilities. The reason is that most users are occupied with the subject matter of their application, and are not willing to devote the time needed for programming their editing environment. Some Lisp programmers, indeed, bother to program and personalize their Emacs environments, but most naive users simply repeat their operations, and sometimes even do not notice the possibility of abstraction. The conclusion is that good end-user computing should have the flavor of “on-the-fly” computing, i.e., should emerge during the activity itself, when the user desires to create a combination/repetition/abstraction/naming construct, based