Cultures deal with their environments by adapting to them and simultaneously changing them. This is particularly true for technological cultures, such as the dynamic culture of computer users. To date, the ability to change computing environments in non-trivial ways has been dependent upon the skill of programming. Because this skill has been hard to acquire, most computer users must adapt to computing environments created by a small number of programmers. In response to the scarcity of programming ability, the computer science community has concentrated on producing general-purpose tools that cover wide spectrums of applications. As a result, contemporary programming languages largely ignore the intricacies arising from complex interactions between different people solving concrete problems in specific domains. This dissertation describes Agentsheets, a substrate for building domain-oriented, visual, dynamic programming environments that do not require traditional programming skills. It discusses how Agentsheets supports the relationship among people, tools, and problems in the context of four central themes: (1) Agentsheets features a versatile construction paradigm to build dynamic, visual environments for a wide range of problem domains such as art, artificial life, distributed artificial intelligence, education, environmental design, and

Many editors use the graphics capabilities of personal workstations to provide a visual editing environment. Such editors present graphical representations of familiar objects and allow the user to manipulate the representations directly. This style of interaction is usually more intuitive to the user than typing statements in a command language. However, implementing a graphical object editor has been a difficult undertaking. Though many packages exist that aid in the construction of graphical user interfaces, none are designed specifically for building graphical object editors. This is significant because there is a substantial semantic gap between general user interfaces and the functionality of graphical object editors. For example, user interface packages usually provide buttons, scroll bars, and ways to assemble them, but they do not offer primitives for building drawing systems that produce PostScript or schematic capture systems that produce netlists. Higher-level abstractions are needed to make such editors easier to build. Unidraw is a framework for creating object-oriented graphical editors in domains such as technical and artistic drawing, music composition, and circuit design. The Unidraw architecture simplifies the construction of these editors by providing programming abstractions that are common across domains. Unidraw defines four basic abstractions: components encapsulate the appearance and semantics of objects in a domain, tools support direct manipulation of components, commands define operations on components and other objects, and external representations define the mapping between components and the file format generated by the editor. Unidraw also supports multiple views, graphical connectivity and confinement, and dataflow between components. This thesis describes the Unidraw design, implementation issues, and three experimental domain-specific editors we have developed with Unidraw: a drawing editor, a user interface builder, and a schematic capture system. Experience indicates a substantial reduction in implementation time and effort compared with existing tools.

Abstract not found

Leogo is a novel programming environment supporting an "equal opportunity" user interface which allows users to express their programming tasks through any mixture of three concurrently active programming paradigms: by direct-manipulation using `programming by demonstration'; by clicking buttons and dragging sliders in an iconic language; and by typing commands in a normal text-based language. Equal opportunity ensures that the e#ects of any interface action are simultaneously displayed across each of the three paradigms---input expressions in one paradigm cause output of equivalent expressions in the other two paradigms. Leogo is designed to promote programming skills in primary and junior schools, but the interface properties it demonstrates are applicable to a wide range of novel programming environments. Leogo's motivation, design, development, and preliminary usability study are described. 2 1 Introduction Programming skills are becoming increasingly important at work...

This paper will appear in the Proceedings of the National Educational Computing Conference 1999 Keywords: learning computer programming, interactive tutorials, animated programming ######### ToonTalk is an animated interactive world inside of which one can construct a very large range of computer programs. These programs are not constructed by typing text or arranging icons but by taking actions in this world. Robots can be trained, birds can be given messages to deliver, and so on. ToonTalk has been described at NECC95 [Kah95] as well as [Kah96a and Kah96b]. This paper describes the design and preliminary testing of an interactive puzzle game that functions as a ToonTalk tutorial. Children are presented with a series of interactive puzzles in a game-like narrative context. The puzzles gradually introduce programming constructs and techniques. Each puzzle presents the player with a very limited selection of ToonTalk objects. Even some very young children

Practically since graphic displays were first hooked to computers, the idea of representing computer programs by pictures has attracted researchers. However, to date, most proposals for visual programming languages have adhered to a set pattern: fixed pictures symbolizing program components, connected by lines or arrows symbolizing relationships between the program components. This "icons on strings" approach, while it can be useful, is not the only way of visualizing programs. In this paper, I explore one alternative: representing a program through visual examples of the state of its execution. I present two related techniques: dominoes, which replace the traditional icons as representations of operations; and storyboards, which replace iconic circuitry as the representation of program code. These have been implemented in Mondrian, a graphic editor extensible through programming by example. Most proposed visual programming languages are "icons on strings" The dream of visual programmi...

This paper examines the usage and effects of customized

Abstract. This paper presents an overview of the Redwood programming environment and details one of its key features, snippets. Through snippets, developers can both make use of a variety of predefined programming constructs and build their own reusable program components. Languageindependent, snippets are descriptions of program parts that can be as simple as an assignment statement or as complex as a sophisticated optimization algorithm. In Redwood, snippets also provide support for a distinguishing facility of visual environments: direct manipulation via drag-and-drop. An example of working with snippets, including snippet definition, visualization, customization, and mapping to code is also presented in the paper. 1.

End-user development has enormous potential to make computers more useful in a large variety of contexts by providing people without any formal programming training increased control over information processing tasks. This variety of contexts poses a challenge to end-user development system designers. No individual system can hope to address all of these challenges. The field of enduser development is likely to produce a plethora of systems fitting specific needs of computer end-users. The goal of this chapter is not to advocate a kind of universal end-user development system, but to cut across a variety of application domains based on our experience with the AgentSheets end-user simulation-authoring tool. We have pioneered a number of programming paradigms, experienced a slew of challenges originating in different user communities, and evolved end-user development mechanisms over several years. In this chapter we present design guidelines that cut across this vast design space by conceptualizing the process of end-user development as a learning experience. Fundamentally, we claim that every end-user development system should attempt to keep the learning challenges in proportion to the skills end-users have. By adopting this perspective, end-user development can actively scaffold a process during which end-users pick up new end-user development tools and gradually learn about new functionality. We structure these design guidelines in accordance to their syntactic, semantic and pragmatic nature of support offered to end-users.

This paper presents a multi purpose visual programming environment called SCIL-VP. In SCIL-VP programs are specified as data flow graphs consisting of arbitrary functions operating on arbitrary data objects. The environment enables a mixture of visual and textual programming. The visual programming interface is generated at runtime from information in a command description file. As a consequence the library of functions is easy to extend, even by laymen. The data objects are also extensible but this requires elementary programming skills. The setup of extensibility makes the environment independent of an application domain. It also opens the way to the combination of different application domains. 1