End-user programming has become the most common form of programming today. However, despite this growth, there has been little investigation into bringing the benefits of software visualization to end-user programmers. Evidence from the spreadsheet paradigm, probably the most widely used end-user environment, reveals that end users' programs often contain faults. We would like to integrate software visualization into these end-user environments to help end users deal with the reliability issues in their programs. Towards this end, we have devised several fault localization visualization techniques for spreadsheets. This paper describes these techniques and reports the results of a formative study--using tests created by end users--to investigate how these fault localization techniques compare. Our results reveal some strengths and weaknesses of each technique, and provide insights into the cost-effectiveness of each technique for the interactive world of end-user spreadsheet development.

An execution backtracking facility in interactive source debuggers allows users to mirror their thought processes while debugging — working backwards from the location where an error is manifested and determining the conditions under which the error occurred. Such a facility also allows a user to change program characteristics and reexecute from arbitrary points within the program under examination — a “what-if ” capability. This paper describes an experimental debugger that provides such a backtracking function. We describe why the facility is useful, and why other current techniques are inadequate. We show how execution backtracking can be efficiently implemented by saving only the latest values of variables modified by a statement, and allowing backtracking only over complete program statements. We also describe how this approach relates to our work on dynamic program slicing.

This paper describes Rita, its user interface and some of its internal structure and algorithms, and relates anecdotal user experiences. Comparisons are also made with other commercial and experimental systems.

SMILE is a multi-user software engineering environment that behaves as an intelligent assistant. SMILE presents a `fileless environment', derives and transforms data to shelter users from entering redundant information, automatically invokes programming tools, and actively participates in the software development and maintenance process. Unlike other intelligent assistants, SMILE is not a rule-based environment: its knowledge of software objects and the programming process is hardcoded into the environment. We describe SMILE's functionality and explain how we achieved this functionality without reliance on artificial intelligence technology. The development and maintenance of SMILE is supported in part by the United States Army, Software Technology Development Division of CECOM COMM/ADP, Fort Monmouth, NJ and in part by ZTI-SOF of Siemens AG, Munich, Germany. This paper was written while Dr. Kaiser was a Visiting Computer Scientist at the Software Engineering Institute, Carnegie-Mello...

End-user programmers are writing an unprecedented number of programs, primarily using languages and environments that incorporate a number of interactive and visual programming techniques. To help these users debug these programs, we have developed an entirely visual, interactive approach to fault localization. This paper presents the approach. We also present the results of a think-aloud study that examined the interactive, human-centric issues that arise in end-user debugging using a fault localization strategy. Our results provide insights into the contributions such strategies can make to the end-user debugging process.

this document appears as: This is a simple simple1 = if True then 1 3.4.1 Evaluation layer: Evaluator The first step in the presentation process is the computation of the derived information in the document. The component that takes care of this is the evaluator. The evaluator is parameterized with an evaluation sheet, which is a declarative specification of the derived values. The evaluation sheet may be specified with an attribute grammar, but no final choice for the formalism has been made yet

Introspection or the ability to observe one's own behavior is one of the most powerful capabilities of human intelligence; it is the basis for understanding and improvement of one's behavior and of human progress. Similarly, introspective computer systems, introduced in this thesis, examine, reason about, and change their own behavior in powerful new ways. Because the complexity of computers is rapidly increasing, yet is restricted by limited human resources, the most attractive quality of introspective computers is their ability to manage this growing complexity themselves. Self-managing computer systems would greatly expand the rational power and complexity of computer systems that can be successfully built. The main difficulty in constructing introspective computer systems is enabling the system to obtain a description of its complete behavior in a dynamic and unobtrusive way. This thesis proposes the partition of the system into two threads of control. The first thread performs the...

lector is an X.11 application that provides highly interactive text formatting. Unlike text previewers, lector handles descriptively marked-up text, supports multiple styles, and interacts well with other programs, including other invocations of lector. Appropriate selection of texts and styles enables lector to act as text previewer, database browser, code prettyprinter, menu utility, and iconic interface. lector’s implementation revolves around a set of tradeoffs involving efficiency, simplicity, and generality. The result demonstrates the utility of generalized text display tools. 1. Introduction. Displaying text is one of the most troublesome, yet indispensable, parts of programming. Virtually ev ery program generates some text, if only diagnostic or error messages. As a result, virtually every programmer must make some choice of output device and layout. These choices are becoming increasingly complicated, thanks to the staggering variety of terminals, printers, plotters, and bitmapped workstations

Abstract not found

When more than one version of a program must be maintained, generally much of the code is repeated unchanged in many versions. Techniques such as “deltas ” and conditional compilation are commonly used to avoid duplicating these common parts. In addition to saving storage, these methods aid the programmer greatly in managing updates to the versions. Unfortunately, these representations of multi-version programs can appear very unlike a program, making them difficult to edit. Described here is a new method of automating much of the bookkeeping involved in dealing with multi-version programs. It entails use of a special editor that enables a multi-version program to be seen and modified in a fashion that is far closer to that normally permitted for a single-version program. 1.