Abstract: In this article we develop some algorithms and tools for solving matrix problems on parallel processing computers. Operations are synchronized through data-flow alone, which makes global synchronization unnecessary and enables the algorithms to be implemented on machines with very simple operating systems and communication protocols. As examples, we present algorithms that form the main modules for solving Liapounov matrix equations. We compare this approach to wave front array processors and systolic arrays, and note its advantages in handling missized problems, in evaluating variations of algorithms or architectures, in moving algorithms from system to system, and in debugging parallel algorithms on sequential machines.

Abstract: This thesis investigates the process whereby faults are diagnosed and corrected in human-designed artifacts in general, and in computer programs in particular. Established automatic diagnostic techniques are useful in cases where the artifact design is known to be correct, but they are inadequate when the design itself may be faulty. Instead, it is necessary for the diagnostician to identify the intentions underlying the design of the artifact and reason about these intentions in order to identify and correct faults. In other words, the diagnostician must understand the artifact in order to correct it. Such understanding is doubly necessary if the designer is a student, and the diagnostician is a teacher who is trying to find out why the student is having difficulties. Intention-based error diagnosis has been implemented in a program called PROUST, which identifies non-syntactic bugs in programs written by novice Pascal programmers. Empirical studies of PROUST's performance show that it achieves high performance in finding bugs in non-trivial student programs.

Abstract: Knowledge programming, which makes use of the explicit representation and interpretation of knowledge to create intelligent programs, requires specialized languages and tools to help programmers. Prolog, an implementation of a logic programing language, provides some of these tools; it and other languages have been argued to be the "best" way to do such knowledge programming. This paper raises questions which suggest that any single paradigm of programming (e.g., logic programming or object-oriented programming) benefits by being integrated in a single environment with other paradigms of programming. Integration of these paradigms with each other, and within a flexible, user-friendly computing environment is also necessary. Such an environment must provide source level debugging and monitoring facilities, analysis and performance tuning tools, and an extended set of user communication programs.

Abstract: A trace database model for debugging concurrent Ada programs is presented. In this approach, trace information is captured in an historical database and queried using Prolog. This model was used to build a prototype debugger, called Your Own Debugger for Ada (YODA). The design of YODA is described and a trace analysis of a sample program exhibiting misuse of shared data is presented. Because the trace database model is flexible and general, it can aid diagnosis of a variety of runtime errors.

Abstract: Automated protocol validation tools are by necessity often based on some form of symbolic execution. The complexity of the analysis problem however imposes restrictions on the scope of these tools. The paper studies the nature of these restrictions and explicitly addresses the problem of finding errors in data communication protocols of which the size precludes analysis by traditional means. The protocol tracing method described here allows one to locate design errors in protocols relatively quickly by probing a partial state space. This scatter searching method was implemented in a portable program called Trace. Specifications for the tracer are written in a higher-level language and are compiled into a minimized finite state machine model, which is then used to perform either partial or exhaustive symbolic executions. The user of the tracer can control the scope of each search. The tracer can be used as a fast debugging tool but also, depending on the complexity of the protocol being analyzed, as a slower and rather naive correctness prover. The specifications define the control flow of the protocol and may formalize correctness criteria in assertion primitives.

Abstract: An integrated CAD system for the automated design of digital signal-processing (DSP) circuits for audio and telecommunication applications is described. The system uses as unique input a symbolic description of algorithm. This representation is translated into an actual layout using a two-step process. First, the symbolic input is mapped into the target architecture, which consists basically of a set of concurrent processors and dedicated I/O circuitry. The resulting hardware configuration is compiled into a layout description through a full exploitation of the hierarchy and the modularity of the architecture, calling consecutively a tiler, a floorplanner, and a global placement and routing tool. All these layout generation tools are able to support a wide range of technologies. The provision of a dedicated register transfer level simulator allows for the efficient debugging and algorithmic checking of the real-time operating signal-processing algorithms. The efficiency and the usefulness of this design methodology has been demonstrated by multiple examples. Experiments have shown that the use of these techniques can reduce the complete design process to a few months.

Abstract: This paper reports on an experimental debugger for concurrent programs. Design objectives include a showing of greatest usefulness when dealing with multiprocess interactions, creation of a simplified more approachable interface for programmers, allowance for the systematic organization (and limitation) of debugging information by programmers, reflection of a natural view of concurrency, and portability. The design responds to a perceived need for debugging techniques applicable in systems of concurrent, communicating, asynchronous processes. During debugging sessions, a user is able to dynamically explore interprocess synchronization points, parallel actions and deadlock situations. The programmer interface is based on a transparent window multiplexer providing a set of windows for each concurrent process. The window manager interactively maps interesting windows to programmer-specified viewscreen locations, while relegating temporarily uninteresting windows to the background. In implementing a debugger for concurrent programs, a principal concern is the probe effect, or the possibility that the debugger itself masks synchronization errors in the program being debugged. For the examples explored, the probe effect was not observed to limit the localization of implanted synchronization errors.

Abstract: This paper presents the computational architecture for the Utah-MIT hand, and discusses design issues encountered in its hardware and software development. The large number of linkages, actuators, and sensors offers a potentially severe computational burden for control; a multiprocessor hardware configuration has been developed to distribute this computation. In the interests of efficiency, minimal operating systems were devised for each processor which nevertheless were made sufficiently general for task scheduling, intertask communication, and debugging. This computational architecture is a general system which is potentially useful for other robotics applications.

Abstract: Author(s): Taylor, Richard N.; Clarke, Lori; Osterweil, Leon J.; Wileden, Jack C.; Young, Michal | Abstract: The research objectives of the Arcadia project are two-fold: discovery and development of environment architecture principles and creation of novel software development tools, particularly powerful analysis tools, which will function within an environment built upon these architectural principles.Work in the architecture area is concerned with providing the framework to support integration while also supporting the often conflicting goal of extensibility. Thus, this area of research is directed toward achieving external integration by providing a consistent, uniform user interface, while still admitting customization and addition of new tools and interface functions. In an effort to also attain internal integration, research is aimed at developing mechanisms for structuring and managing the tools and data objects that populate a software development environment, while facilitating the insertion of new kinds of tools and new classes of objects.The unifying theme of work in the tools area is support for effective analysis at every stage of a software development project. Research is directed toward tools suitable for analyzing pre-implementation descriptions of software, software itself, and towards the production of testing and debugging tools. In many cases, these tools are specifically tailored for applicability to concurrent, distributed, or real-time software systems.The initial focus of Arcadia research is on creating a prototype environment, embodying the architectural principles, which supports Ada1 software development. This prototype environment is itself being developed in Ada.Arcadia is being developed by a consortium of researchers from the University of California at Irvine, the University of Colorado at Boulder, the University of Massachusetts at Amherst, TRW, Incremental Systems Corporation, and The Aerospace Corporation. This paper delineates the research objectives and describes the approaches being taken, the organization of the research endeavor, and current status of the work.

Abstract: To date, program development environments have been static rather than dynamic. Even emerging interactive, integrated program development environments, like the Cornell Program Synthesizer, view program editing and execution as essentially independent activities. We envision an even more dynamic environment in which the functionality (input/output relationship) of a network of programs, an individual program, or a program segment can be viewed “continuously” with editing changes to either the program input or program body. This is the VisiCalc concept extended to program development environments (VisiProg). In this paper, this “dynamic” approach to program development, testing and debugging is addressed, and considerations for the user interface are discussed. The latter includes a workstation with a flexible windowing system, three-dimensional views of programs, insertion of program control and observation points, and dynamic program slicing for “viewing” program execution. An existing prototype and current development activities are also discussed.

Abstract: As long as simulation is relied upon, the hardware will only be as good as the test data; therefore most widely used computers contain bugs. Verification is the only known technique for theoretically complete debugging, but it remains impractical despite researchers' efforts. This article explores a methodology in between functional simulation and formal verification. The correctness of hardware is specified as in formal verification. Input and output assertions are given in predicate calculus. Then, instead of showing that output assertions will be satisfied by the functional specification of hardware for all inputs that satisfy input assertions, it is shown that this relation holds for selected inputs. The triple, input assertion, hardware specification, and output assertion are run against test data. The advantage of this method over functional simulation is that the output data are automatically checked for correctness. The advantage over formal verification is that processes can be executed without being penalized by the incompleteness and inefficiency of theorem provers. Concurrent Prolog provides a readable, efficient compromise between functional simulation and formal verification of VLSI chip design. It is well suited for simulation of component systems and may become the language of choice for this application.

Abstract: An expert system (DIALOG) is described to check correctness of logic levels and timing composition rules in n- or CMOS VLSI logic. Knowledge is described in an engineer oriented language (LEXTOC) allowing for unification (cfr PROLOG), object creation, property assignment, association of relations, rule formulation, logic or arithmetic evaluation as well as conversational constructs. The system is illustrated by checking racefree dynamic CMOS design composition rules. Up to 250 transistors can be handled in the LISP interpretative way on the VAX 11/780. An efficient automatic translation of LEXTOC into Pascal shows the feasibility for batch oriented debugging of up to 50,000 transistors in a workstation environment, while keeping knowledge programming efficiency of LEXTOC.

Abstract: In this paper, an approach to the modeling of software testing is described. A major aim of this approach is to allow the assessment of the effects of different testing (and debugging) strategies in different situations. It is shown how the techniques developed can be used to estimate, prior to the commencement of testing, the optimum allocation of test effort for software which is to be nonuniformly executed in its operational phase. In addition, the question of application of statistical models in cases where the data environment undergoes changes is discussed. Finally, two models are presented for the assessment of the effects of imperfections in the debugging process.

Abstract: In this paper, we describe ASSPEGIQUE, an integrated environment for the development of large algebraic specifications. We first describe the underlying specification language, PLUSS-E, based on the specification-building primitives of ASL and E,R-algebras, a formal framework for exception handling. We then describe the design and organization of the specification environment. This environment allows the user to introduce specifications in a hierarchized library, to edit them through a special purpose editor (with a graphical interface), to compile them and to debug them. A symbolic evaluator and theorem proving tools completes ASSPEGIQUE into an environment suitable for rapid prototyping.

Abstract: This paper describes a debugger of message-based, communicating processes. This debugger is designed to reduce the apparent complexity of large systems of communicating programs by regarding only the interprocess activities of such programs. The debugger provides users with information about how sets of processes behave rather than what each program associated with each process does. It also provides various primitives for manipulating the interprocess activities of processes. In order to concentrate on just those operations pertinent to multi-process debugging, the debugger provides no ability to access the source code of any program. Our system includes a user-interface program, a mechanism to fire and execute interprocess debugging demons and a mechanism to obtain transcripts of interprocess activities. The user interface executes commands for the user at a terminal for creating and manipulating individual interprocess events. Demons are an event-driven mechanism used to automatically monitor and modify interprocess events. Transcripts provide a record of interprocess events executed for a process that can be replayed later. We make use of these tools to provide individual process control, communication monitoring and process testing.

Abstract: Lisp and its successors provide the programmer with a powerful single tool [2] in which he can write, modify, debug and execute programs. Side effects play a crucial role in these programming environments. We propose an alternative approach to debugging that doesn't rely on side effects. Then we describe an implementation of our approach in a purely functional language.

Abstract: Debugging is a task that requires access to extensive information about a program and its execution state. The more effectively this information can be presented to the user by a debugger, the better tool the debugger becomes. Graphics is a meaningful and effective way of presenting a program''s data structures. This paper describes the design and implementation of an extension to a standard debugger. The extension presents data structures graphically and enables a UNIX debugger DEX runs on a Sun Workstation using multiple windows, a bitmap display, and a mouse pointing device.

Abstract: This symbolic run-time debugger for Ada provides facilities for observing and manipulating the execution of a monitored program, also for concurrent aspects. The debugger can be used interactively, and also as a monitoring program to control the application. A feature of this project is the use of relational algebra for defining compiler and kernel interfaces and for handling debugger information. The implementation is based on an Ada task to interface with the debugging operator and a set of user-defined Ada monitoring tasks. A prototype of the debugger was completed as a part of ART, a relational translator and interpreter for Ada.

Abstract: Conceptual simplicity, tight coupling of tools, and effective support of host-target software development will characterize advanced Ada programming support environments. Several important principles have been demonstrated in the Arcturus system, including template-assisted Ada editing, command completion using Ada as a command language, and combining the advantages of interpretation and compilation. Other principles, relating to analysis, testing, and debugging of concurrent Ada programs, have appeared in other contexts. This paper discusses several of these topics, considers how they can be integrated, and argues for their inclusion in an environment appropriate for software development in the late 1980's.

Abstract: This paper reports the results of an exploratory study that investigated expert and novice debugging processes with the aim of assessing the relevance of situation-dependent problem solving to debugging expertise The method used was verbal protocol analysis Data was collected from sixteen subjects employed by the same organization The study first controlled for the variability in individual problem solving by incorporating certain aspects of programmers' debugging processes into the debugging model The criterion of expertise was the subjects' ability to effectively chunk the program they were required to debug This method proved effective in explaining much of the variability in debugging performance and provided the basis for the expert-novice classification used in subsequent analysis of the protocol data Further analysis focused on situational factors in debugging lt took two forms: (1) a static or content analysis of subjects' problem solving behavior that aggregated data across a protocol: and (2) a dynamic or process analysis of subjects' debugging processes that examined data as closely as possible to its natural state The results support the notion that experts respond to the data in the task while novices are constrained by preconceived ideas or early hypotheses about the source of error

Abstract: Efficient multiprocessing requires new methods of problem decomposition— and new debugging and analysis tools for developing and evaluating asynchronous, parallel programs.

Abstract: The programming of robot manipulators to perform assembly is a highly interactive task. The manipulator arm is often used to define objects and their locations in the workspace. For all but the simplest operations, it is necessary to use the manipulator to debug and tune the operation so that it works reliably. As the development of working manipulator programs can be a very difficult and time-consuming activity it is important to provide tools to aid in this task. This dissertation examines both the problems unique to manipulator programming that arise from including the physical world as a part of the programming environment and also the consequent problems of programming in this environment. Some specific issues discussed include object definition, motion control, use of force and compliance, error recovery, and parallelism. Requirements for a successful manipulator programming environment are formulated in light of these and other problems. Based on these requirements, a highly interactive manipulator programming system, designed and implemented to facilitate the development of manipulator programs written in the AL language, is described. Major modules include: an interpreter with source-level debugging features, a syntax-directed display editor knowledgeable about AL, and a force graphics subsystem. Each module is described, and examples are given showing the system in operation. Using the interactive AL system, manipulator programs can be written, modified, debugged, and run in a single environment, providing an efficient and flexible man-machine interface between the programmer and the manipulation.

Abstract: We describe a programming environment for Prolog, a common logic programming language. The services offered by our system assist a Prolog user in the tasks of composing, editing, and storing logic (rule-based) programs, as well as in the control of their execution for debugging purposes.In order to facilitate effective debugging of Prolog programs, we propose a new model of computation that can handle both pure Prolog and impure (side-effect causing) Prolog operations quite gracefully. This model employs two stacks representing the state of a computation with respect to the two major activities of Prolog execution: recursion and backtracking. This representation, in addition to being quite clear and intuitive, is easy to display on a terminal's screen and can be further processed.We also describe a Prolog oriented editor with which the user may easily create and update Prolog source programs and, further, inspect states of computation as generated by the debugger.

Abstract: A prototyping and simulation tool that supports the development of distributed programs is described. This tool, called Jems, forms a part of Jade, a distributed software prototyping environment. The Jade environment provides tools for the design, implementation, debugging, testing, maintenance, and performance analysis of distributed, concurrent programs. Novel features of Jade include the support of: multi-lingual distributed programs; flexible monitoring of inter-process communication; multiple views into executing programs via a window system; graphical animation of executing programs; and the prototyping of distributed software. This paper presents an overview of the Jade environment, describes the distributed software prototyping tool, and outlines the status of the project.

Abstract: It has been claimed that logic programming offers outstanding possibilities for new concepts in programming environments. But with the exceptions of the pioneering work of Shapiro on algorithmic debugging, Pereira's rational debugging and early work on expert systems from Imperial College, there has been little progress reported in the field of logic programming environments. This summary describes our current work on a generic software engineering shell for logic programming. We use reflection and the amalgamation of meta-level language with the object level to express and support the incremental character of specifying/programming. An important facet of the shell is that we formalize some aspects of programming methodology and provide heuristics for avoiding errors. These heuristics formalize what experienced programmers may already know. The shell bears similarities to an expert system since it has explanation mechanisms and provides programming-knowledge acquisition. Currently, it supports single user Prolog programming and runs in C-Prolog. The shell is generic in that it provides support for activities ranging from artificial intelligence programming to formal specification development. This research has been supported in part by the IBM Young Faculty Development Award and in part by the NSF grant # MCS-84-05079.