Marc Eisenstadt

My hairiest bug war stories

ming and debugging [1, 2, 5, 8–12], while important in their own right, have generally overlooked the potential benefit of self-reports by programmers that reflect the phenomenology of debugging, that is, what its really like out there from the program-mers perspective. However, two exceptions to this observation are the detailed account by Knuth of using a logbook to document all the errors he encountered over a 10-year development period working on TeX [6] and a logbook of the development efforts of a team implementing the S Smalltalk-80 virtual machine [7]. Such self-reports and logs are valuable sources on the nature of software design, development, and maintenance. The work reported here seeks to expand the single-user-logbook approach to investigate the phenomenology of debug-ging across a large population of users, aiming to understand and address the problems of professional programmers working on very large programming tasks. Toward this end, I conducted a survey of professional programmers, asking them to describe their most difficult bugs involving large pieces of software. The survey was conducted through email and conferencing/bulletin board facilities with worldwide access, including Usenet newsgroups, the BYTE Information Exchange (BIX), CompuServe, and AppleLink. My contribution was to gather, edit, and annotate the stories, categorizing them in a way that may shed light on the nature of the debugging enterprise. In particular , I looked at the lessons learned from the stories. Here, I discuss what they tell us about what is needed in the design of future debugging tools.

The transparent PROLOG machine (TPM): an execution model and graphical debugger for logic programming☆

Abstract An augmented and ⧸ or tree representation of logic programs is presented as the basis for an advanced graphical tracing and debugging facility for PROLOG. An extension of our earlier work on “retrospective zooming”, this representation offers several distinct advantages over existing tracing and debugging facilities: (1) it naturally incorporates traditional and ⧸ or trees and Byrd box models (call⧸exit⧸fail⧸redo procedural models) as special cases; (2) it can be run in slow-motion, close-up mode for novices or high-speed, long-distance mode for experts with no attendant conceptual change; (3) it serves as the uniform basis for textbook material, video-based teaching material, and an advanced user interface for experienced PROLOG programmers; (4) it tells the truth about clause head matching and deals correctly with the cut. One of the key insights underlying the work is the realization that it is possible to display an execution space of several thousand nodes in a meaningful way on a modern graphics workstation. By enhancing and ⧸ or trees to include “status boxes” rather than simple “nodes”, it is possible to display both a long-distance view of execution and the full details of clause-head matching. Graphical “collapsing” techniques enable the model to deal with user-defined abstractions, higher-order predicates such as setof, and definite-clause grammars. The current implementation runs on modern graphics workstations and is written in PROLOG.

Visual knowledge engineering

The knowledge engineer is only weakly supported at three critical stages in the knowledge engineering life cycle: (1) knowledge acquisition during which problem conceptualization must largely be tackled with paper and pencil; (2) knowledge encoding, during which it is frequently necessary to be able to navigate across a variety of knowledge representation formalisms; and (3) large-scale debugging, in which the graphical rule traces cannot cope with enormous rule sets involving hundreds or thousands of rules. The research described attempts to provide just such support through complementary visual programming (VP) and program visualization (PV) techniques embedded in a fully implemented software environment called KEATS: the knowledge engineers assistant. Several novel visual programming and program visualization techniques aimed at knowledge engineers have been developed, which include (1) a hypertext transcript analyzer from which conceptual models can be generated, (2) a direct graph manipulation sketchpad which allows the knowledge engineer to sketch out objects and relations (including control flow and rule dependencies) from which code can be generated, and (3) dependency viewers which allow the knowledge engineer to examine and manipulate temporal and logical rule dependencies at different levels of granularity. How these facilities are incorporated into KEATS and the key themes that emerge from this approach to visual knowledge engineering are discussed. >

Knowledge acquisition as a process of model refinement

The strengths and weaknesses of our earlier system, KEATS-1, have led us to embark upon the design and implementation of a new knowledge engineering environment, KEATS-2, which provides a novel, integrated framework for performing both bottom-up and top-down knowledge acquisition. In this paper we discuss the nature of the knowledge acquisition activities and we introduce the support tools embedded in KEATS-2. We characterize knowledge acquisition as the composition of knowledge elicitation, data analysis and domain conceptualization and we emphasize that a knowledge engineering tool has to support these activities as well as bridging the gap between acquiring the data and implementing the final system.

Collaboration in the Semantic Grid: A Basis for e-Learning

The CoAKTinG project aims to advance the state of the art in collaborative mediated spaces for the Semantic Grid. This paper presents an overview of the hypertext and knowledge-based tools that have been deployed to augment exiting collaborative environments, and the ontology that is used to exchange structure, promote enhanced process tracking, and aid navigation of resources before, after, and during a collaboration. While the primary focus of the project has been supporting e-Science, this paper also explores the similarities and application of CoAKTinG technologies as part of a human-centered design approach to e-Learning.

Methodological foundations of KEATS, the knowledge engineer's assistant

The numerous tasks required by the knowledge engineering process and their inherent complexity combine to make building knowledge-based systems both a time consuming and arduous activity. The key to reducing the complexity of the problem is to provide a methodological framework which can clarify the nature of the intermediate steps required to encode effectively knowledge into a performance system. Such a framework can then be used to drive the design of a comprehensive knowledge engineering toolkit. This is the approach we adopted in the KEATS project. In this paper, we provide an overview of the KEATS knowledge engineering methodology, which is based on a view of knowledge engineering as iterative refinement of qualitatively and teleologically different models, and we show how these ideas have driven the design of the KEATS toolkit.

A framework for describing and implementing software visualization systems

In recent years many prototype systems have been developed for graphically visualizing program execution in an attempt to create a better interface between software engineers and their programs. Several classification-based taxonomies have been proposed to describe visualization systems and several general frameworks have been proposed for implementing such systems. In this chapter we provide a framework for both describing existing systems and implementing new ones. We demonstrate the utility of automatic program visualization by re-implementing several existing programming language visualization systems using this framework.

A fine-grained account of Prolog execution for teaching and debugging

A clear and consistent execution model of any programming language can lay the foundations not only for a good leaming experience, but also for a smoother design/edit/run/debug cycle. In this paper, we describe our attempt to construct precisely such a model for the logic programming language Prolog, based upon a notational extension of logic programmings traditional AND/OR trees. Our extension, called the “AORTA” diagram, is an And/OR Tree, Augmented to include invocation history “status boxes” at each node. This augmentation makes it possible to present a graphical view of Prolog execution which is very compact, yet which contains complete details of unification and control history, including multiple (backtracking) invocations and extra-logical features such as the cut. The paper describes our fine-grained view of Prolog execution in detail, and argues that this fine-grained view can readily be integrated into a coarse-grained model such as thatrequired for understanding the execution of very large programs. Indeed, our notation is already in use across a range of media, including textbook diagrams, video animations, and a graphical tracing and debugging facility running on modem graphics workstations.

Prolog programming techniques

In this paper we introduce the concept of a Prolog programming technique. This concept is then distinguished both from that of an algorithm and that of a programming cliché. We give examples and show how a knowledge of them can be useful in both programming environments and in teaching programming skills. The extraction of the various techniques is outlined. Finally, we discuss the problem of representing techniques where we conclude that the most promising approach is the development of a suitable meta-language.

A Methodology and Tool for Knowledge Acquisition in Keats-2

Publisher Summary This chapter presents a methodology and tool for knowledge acquisition in the second version of the KEATS (The Knowledge Engineers Assistant) system. This account emphasized the progression from knowledge elicitation through data analysis and domain conceptualization. The development of KEATS was motivated by the idea of building a knowledge engineering toolkit that could provide a comprehensive range of tools to help the knowledge engineer fill the gap between the raw data and final system. The KEATS-2 project as a whole aims to address some of the frontline problems of knowledge engineering. These include: (1) very large knowledge bases, it discusses how enormous knowledge bases could be implemented and maintained by a team of engineers in a clear and consistent manner, using knowledge derived from disparate sources. (2) Learning—current research indicates that the acquisition of expertise by humans is an intensive process requiring the refinement of both declarative and procedural knowledge over a period of years. (3) Common sense reasoning, and (4) environments. Tackling these problems will require a fruitful combination of empirical research, top–down methodologies and supporting environments. Work on Acquist and KEATS-2 as a whole continues in this spirit, and future results are eagerly awaited.