Kenneth M. Kahn

ToonTalkTM—An Animated Programming Environment for Children☆

Seymour Papert once described the design of the Logo programming language as taking the best ideas in computer science about programming language design and ‘child engineering’ them. Twenty-five years after Logos birth, there has been tremendous progress in programming language research and in computer-human interfaces. Programming languages exist now that are very expressive and mathematically very elegant and yet are difficult to learn and master. We believe the time is now ripe to attempt to repeat the success of the designers of Logo by child engineering one of these modern languages. When Logo was first built, a critical aspect was taking the computational constructs of the Lisp programming language and designing a child friendly syntax for them. Lisps ‘CAR ’ was replaced by ‘FIRST’, ‘DEFUN’ by ‘TO’, parentheses were eliminated, and so on. Today there are totally visual languages in which programs exist as pictures and not as text. We believe this is a step in the right direction, but even better than visual programs areanimated programs.Animation is much better suited for dealing with the dynamics of computer programs than static icons or diagrams. While there has been substantial progress in graphical user interfaces in the last twenty-five years, we chose to look not primarily at the desktop metaphor for ideas but instead at video games. Video games are typically more direct, more concrete, and easier to learn than other software. And more fun too. We have constructed a general-purpose concurrent programming system, ToonTalk, in which the source code is animated and the programming environment is a video game. Every abstract computational aspect is mapped into a concrete metaphor. For example, a computation is a city, an active object or agent is a house, birds carry messages between houses, a method or clause is a robot trained by the user and so on. The programmer controls a ‘programmer persona’ in this video world to construct, run, debug and modify programs. We believe that ToonTalk is especially well suited for giving children the opportunity to build real programs in a manner that is easy to learn and fun to do.

Mechanizing temporal knowledge

The importance that an understanding of time plays in many problem-solving situations requires that intelligent programs be equipped with extensive temporal knowledge. This paper discusses one route to that goal, namely the construction of a time specialist, a program knowledgable about time in general which can be used by a higher level program to deal with the temporal aspects of its problem-solving. Some examples are given of such a use of a time specialist. The principal issues addressed in this paper are how the time specialist organizes statements involving temporal references, checks them for consistency, and uses them in answering questions.

Integrating Access-Oriented Programming into a Multiparadigm Environment

The Loops knowledge programming system integrates function-oriented, system object-oriented, rule-oriented, and—something notfound in most other systems—access-oriented programming.

Complete visualizations of concurrent programs and their executions

The theory and methods for a completely visual formalism for programs and their executions are presented. The appearance, and not the construction, completely describes programs, data, and states of execution. Programs, their model of execution, and their execution traces are visualized in the same pictorial terms. A list of advantages of this visual formalism is given. A case study using the Janus language is presented.<<ETX>>

Drawings on napkins, video-game animation, and other ways to program computers

P usually type characters on a keyboard to enter, test, and debug computer programs. More than 30 years ago researchers began augmenting those characters with diagrams [20] but pure ASCII text is still the ubiquitous standard. We will argue that these attempts to make programming more visual have failed to become mainstream because they are too conservative. Various radical syntaxes for programs are feasible and offer many advantages over the state of the art. Programs, for example, can be defined by the topology of sketches, even hand-drawn scanned sketches [8]. A programming environment can parse these sketches and generate animations of the drawings that evolve as the program executes [6]. Or programs can be defined by manipulating physical objects, for example, by connecting blocks together [21] or inserting plastic cards into slots [17]. We are currently building a system called ToonTalk in which programs are created, run, and debugged in a manner that closely resembles playing a video game [7]. In the near future we may see program development systems that exist only in virtual reality or ones that interpret gestures in the real world. Program sources need not be static collections of text or even Drawings on Napkins, Video-Game Animation,and Other Ways to Program Computers K e n K a h n •

Objects in concurrent logic programming languages

Concurrent Prolog supports object-oriented programming with a clean semantics and additional programming constructs such as incomplete messages, unification, direct broadcasting, and concurrency synchronization [Shapiro 1983a]. While it provides excellent computational support, we claim it does not provide good notation for expressing the abstractions of object-oriented programming. We describe a preprocessor that remedies this problem. The resulting language, Vulcan, is then used as a behicle for exploring new variants of object-oriented programming which become possible in this framework.

Actors as a special case of concurrent constraint (logic) programming

Saraswat recently introduced the framework of concurrent constraint programming [14]. The essence of the framework is that computations consist of concurrent agents interacting by communicating constraints. Several concurrent constraint programming languages have been defined. They differ in the kinds of constraints that can be used as well as the kinds of operations on constraints which are available. In this paper we introduce a very simple concurrent constraint language we call Lucy, designed to closely mimic the actor model of computation. Agents can communicate only by the posting of constraints upon bags (un-ordered collections possibly with duplicate elements). This very impoverished concurrent constraint language is a syntactic subset of Janus, a concurrent constraint language which closely resembles concurrent logic programming languages such as Guarded Horn Clauses [21], Strand [5], Parlog [2] and Flat Concurrent Prolog [13]. By identifying the subset of Janus which is an actor language, we elucidate the relationship between actors and concurrent logic programming (and its generalization as concurrent constraint programming). Lucy is best not thought of as a unification of logic and constraint programming with actor and object-oriented programming, but as the missing link between these programming language genera.

Virtual copies: at the boundary between classes and instances

Knowledge bases built in object-oriented systems use networks of interconnected objects in their representations. The mechanism described here provides a way to use such a network as a prototype by making virtual copies of it. The virtual copy is created incrementally. Values of instance variables in the virtual copy are inherited from the prototype until locally overridden in the copy, similar to inheritance of defaults between instances and classes in Loops. A virtual copy preserves the topology of the original network. Virtual copies can be made from virtual copies. Alternative implementations of virtual copies allow different tradeoffs in space and lookup time. Virtual copies can be used for building knowledge bases for design, for representing contexts in a problem solving system, and have other uses in ordinary programming.

An actor-based computer animation language

This paper describes a computer language based upon actor semantics designed especially for computer graphics and animation. The thesis that animation is best facilitated by considering each entity on the display screen as an independent process is discussed and demonstrated by examples. The system is built upon MacLisp and is compatible with Lisp-Logo. The language is designed to be used by both very sophisticated programmers and by school children.

The role for simulations in theory construction for the social sciences: Case studies concerning Divergent Modes of Religiosity

Abstract Religion is, at the very least, a highly complex social phenomenon. The theories we use to understand religion – and sociocultural systems more generally – are often so complex that even experts in the field may not be able to see all their consequences. Social simulations can help us understand and communicate the consequences of a theory, provided we can describe the theory with sufficient precision and comprehensiveness in order to run it on a computer. In this article we demonstrate the benefits of simulating the predictions of a well-known theory in the Cognitive Science of Religion, the theory of Divergent Modes of Religiosity. Many of these predictions have already been tested against contemporary and longitudinal evidence, using the methods of both qualitative case study and large-scale survey, and some of the mechanisms responsible for the patterns observed have been investigated by means of controlled experiments. Nevertheless, in simulating the patterns of religious transmission and transformation predicted by the modes theory we discovered numerous aspects that were underspecified, generating new hypotheses for investigation in future empirical research. This back-and-forth between simulation and theory testing has the potential to accelerate progress in the scientific study of religion.