Interactive programming environments

This paper explores both the design and classroom usage of a visual and interactive programming environment. This environment, named JavaTown, provides a visual representation of the inner workings of object-oriented programs, in which on-screen characters are literally depicted as carrying messages to each other and remembering values. JavaTown was created to aid in the introduction of some of the most elusive concepts in the CS1/CS2 curriculum: object references, parameter passing, variable scope, recursion, and linked lists.

We introduce Plotting Agent, a system that enables users to directly manipulate plots using natural language instructions within an interactive programming environment. It maps language to plot updates. We formulate this problem as a slot-based task-oriented dialog problem, which we tackle with a sequence-to-sequence model. Practitioners such as data scientists broadly defined, and researchers interested in Natural Language Interfaces (NLIs) may find our demo useful.

Interactive programming environments

This chapter describes an in-depth analysis of the errors made by novice programmers learning to write programs in a language called SOLO. It then analyzes the underlying causes of these errors, based upon in-depth analyses of session transcripts. The relative importance of different types of error is very hard to assess, particularly across different languages, programmer skill levels, and types of programming environment. The trap philosophy allows the user to enter nearly-correct lines of a program, and then relies on the user-interface to make sense of obvious errors. J. B. H. duBoulay looked in depth at programming errors made by school teachers learning the language LOGO. Naturally, users of interactive computing environments, especially beginners, are destined to make some mistakes. Semantic and conceptual errors can be characterized by the presence of ill-formed plans in a programmer's emerging repertoire of skills.

This paper presents a functional overview of the features and capabilities of QLISP, one of the newest of the current generation of very high level languages developed for use in Artificial Intelligence (AI) research.QLISP is both a programming language and an interactive programming environment. It embeds an extended version of QA4, an earlier AI language, in INTERLISP, a widely available version of LISP with a variety of sophisticated programming aids.The language features provided by QLISP include a variety of useful data types, an associative data base for the storage and retrieval of expressions, the ability to associate property lists with arbitrary expressions, a powerful pattern matcher based on a unification algorithm, pattern-directed function invocation, teams of pattern invoked functions, a sophisticated mechanism for breaking a data base into contexts, generators for associative data retrieval, and easy extensibility.System features available in QLISP include a very smooth interaction with the underlying INTERLISP language, a facility for aggregating multiple pattern matches, and features for interactive control of programs.A number of applications to which QLISP has been put are briefly discussed, and some directions for future development are presented.

Studies have been made on computer systems based on the user model reflecting the behavior of the users, aiming at the human interface which is easy to use. Recently, it has been proposed that individual models be constructed for the users, rather than a model where the only one “typical” human model represents the user in general. A case has not been observed, however, where the individual model is utilized fully in the interactive computer system which actually requires such an approach. From such a viewpoint, this paper proposes a generation of suitable messages utilizing the individual user model, by restricting the problem to the generation of the messages from the computer side in the construction of a program in the interactive programming environment. The features of the user model which will be useful in such a problem, are pointed out. The points in this study are that the skill of the user concerning the system is separated into the general understanding level and the knowledge of the individual functions; utilization of the information obtained by the operating system and for the language processor; and object‐oriented user model whose contents are always updated. A human interface was implemented experimentally which indicates the individual user, the error message from Lisp interpreter according to each situation. We have conducted an experiment by using the interface. The usefulness of our method was demonstrated by the result of experiment.

Alien is a generator for interactive language-specific programming environments. The system makes a language definition environment available to the language definer and supports him with an interactive generator. Using these tools every syntactic unit of a language can be made available. This can be done by a method of stepwise testing, correction and expansion. Fully defined environments can easily be restricted to subsets of a language.This paper introduces a method making a large software product executable on small UNIX machines as well as a survey of the system's components. These are designed to make the implementation on PCs effective and to develop a powerful generator for programming environments. Therefore the results are of interest to all projects in the programming environment field.ALIEN has been implemented in C running on Siemens PC-X, PC-X10, PC-MX-2 machines and Atari PC. Implementation on Apollo and SUN workstations is still in progress and on IBM PC is planned.The project is supported by the Stiftung Volkswagen-werk under grant 1/61 602.

A large variety of tools for program development are available today. The tools tend to become more and more sophisticated, but are usually isolated utilities that have to be applied one by one. An alternative to the tool-box approach is an integrated programming environment utilizing powerful interaction facilities.The design and a prototype implementation of an integrated programming environment is described and the qualities of such a system are discussed. One important design goal was to obtain an environment which has an execution efficiency comparable to that of a system based on a conventional compiler, and a reasonable interaction speed. For this reason the system is based on incremental translation to native code. Another goal was to obtain incremental execution, i.e. the possibility to modify an executing program. The properties of this mechanism and its consequences are investigated.

The Smalltalk-80 system is an interactive graphical programming and applications environment. In the system the language, graphical display, editors, programming tools, operating system features, and application programs are integrated by treating each in a consistent object-oriented manner. The object-orientation of the Smalltalk-80 language, in which all information structure is in the form of objects and all processing is in the form of message-sending, greatly facilitates this consistency of the system.

For better or worse, the web browser has become a widely used target platform for software applications. Desktop-style applications such as word processors, spreadsheets, calendars, games and instant messaging systems that were earlier written for specific operating systems, CPU architectures or devices are now written for the World Wide Web, to be used from a web browser. In this paper we summarize our experiences in using the web browser as a target platform for real applications. As a concrete example, we use the Sun? Labs Lively Kernel, a system that implements an exceptionally interactive web programming environment running in a web browser without any plug-in components. Based on this work, we analyze the limitations, challenges and opportunities related to the web browser as an application platform.

Vu is an interactive visual programming environment, which enables interface designers to create highly interactive, graphical, direct-manipulation-style graphical user interfaces in a very natural manner. The general strategy of vu is to enable the designer to draw the screen display that the end user will see, and to test the interface by performing actions just as the end user would. This is achieved by providing exploratory programming in a highly visual and object-oriented environment. This paper describes the design principles and structure of vu.

The PRC Adaptive Knowledge-based Text Understanding System (PAKTUS) is an environment for developing natural language understanding (NLU) systems. It uses a knowledge-based approach in an integrated hybrid architecture based on a factoring of the NLU problem into its lexi-cal, syntactic, conceptual, domain-specific, and pragmatic components. The goal is a robust system that benefits from the strengths of several NLU methodologies, each applied where most appropriate. PAKTUS employs a frame-based knowledge representation and associative networks throughout. The lexical component uses morphological knowledge and word experts. Syntactic knowledge is represented in an Augmented Transition Network (ATN) grammar that incorporates rule-based programming. Case grammar is used for canonical conceptual representation with constraints. Domain-specific templates represent knowledge about specific applications as patterns of the form used in logic programming. Pragmatic knowledge may augment any of the other types and is added wherever needed for a particular domain. The system has been constructed in an interactive graphic programming environment. It has been used successfully to build a prototype front end for an expert system. This integration of existing technologies makes limited but practical NLU feasible now for narrow, well-defined domains.

Programming environments support the creation, modification, execution and debugging of programs. The goal of integrating a programming environment is more than simply building tools that share a common data base and provide a consistent user interface. Ideally, the programming environment appears to the programmer as a single tool; there are no firewalls separating the various functions provided by the environment. This paper describes the techniques used to integrate Magpie, an interactive programming environment for Pascal. Display windows, called browsers, provide a consistent approach for interacting with the Pascal source code or the execution state of the program. Incremental compilation allows the programmer to specify debugging actions in Pascal, eliminating the need for a separate debugging language.

The PROSPEC software environment for designing and verifying communication protocols is described. It integrates several tools that implement methods for protocol verification and construction (i.e., fair reachability analysis, multiphase construction, and protocol projection). The system provides a unified graphical interface to facilitate the application of these methods and creates an interactive environment for specifying, verifying, and designing communication protocols. PROSPEC was used successfully to design and verify versions of BSC, X.21, X.25, and Telnet document transfer protocols. >

The PSG programming system generator developed at the Technical University of Darmstadt produces interactive, language-specific programming environments from formal language definitions. All language-dependent parts of the environment are generated from an entirely nonprocedural specification of the language's syntax, context conditions, and dynamic semantics. The generated environment consists of a language-based editor, supporting systematic program development by named program fragments, an interpreter, and a fragment library system. The major component of the environment is a full-screen editor, which allows both structure and text editing. In structure mode the editor guarantees prevention of both syntactic and semantic errors, whereas in textual mode it guarantees their immediate recognition. PSG editors employ a novel algorithm for incremental semantic analysis which is based on unification. The algorithm will immediately detect semantic errors even in incomplete program fragments. The dynamic semantics of the language are defined in denotational style using a functional language based on the lambda calculus. Program fragments are compiled to terms of the functional language which are executed by an interpreter. The PSG generator has been used to produce environments for Pascal, ALGOL 60, MODULA-2, and the formal language definition language itself.