Event associations in SNOBOL4 for program debugging

An event association facility for the SNOBOL4 programming language is described. This facility permits the execution of a programmer-defined function to be associated with the occurrence of a specified event. The events with which associations can be made are those applicable to program debugging. Associations can be made with events such as variable referencing, statement execution, program interruption, function call and return, and execution-time errors. By making event associations available at the source-language level, debugging aids can be written in SNOBOL4 itself, using the full capabilities of that language. As illustrated by several examples, this approach facilitates the implementation of simple yet powerful debugging aids written in the same language as the programs to be debugged. Event associations provide a mechanism for the unification of the existing SNOBOL4 debugging facilities, and a basis for the addition of other events. The implementation of event associations is also described.     

A dataflow approach to event-based debugging

This paper describes a novel approach to event-based debugging. The approach is based on a (coarsegrained) dataflow view of events: a high-level event is recognized when an appropriate combination of lower-level events on which it depends has occurred. Event recognition is controlled using familiar programming language constructs. This approach is more flexible and powerful than current ones. It allows arbitrary debugger language commands to be executed when attempting to form higher-level events. It also allows users to specify event recognition in much the same way that they write programs. This paper also describes a prototype, Dalek, that employs the dataflow approach for debugging sequential programs. Dalek demonstrates the feasibility and attractiveness of the dataflow approach. One important motivation for this work is that current sequential debugging tools are inadequate. Dalek contributes toward remedying such inadequacies by providing events and a powerful debugging language. Generalizing the dataflow approach so that it can aid in the debugging of concurrent programs is under investigation.     

EQL: A language for numerical computation

EQL, a language for numerical computation, has been implemented. This paper describes essential properties of the EQL language, which considerably simplifies numerical analysis and programming thanks to the following features: (1) elimination of explicit sequencing: (2) matrix and array computations: (3) simple and convenient notation of iteration procedure: (4) mapping of data structures (vector or matrix) on data objects which are represented in the computer: (5) tabulation facility for function values. Also the outline of translator, which transforms an EQL program to FORTRAN codes, is described.     

Refinement calculus: A basis for translation validation,debugging and certification

In this paper, we show how refinement calculus provides a basis for translation validation of optimized programs written in high level languages. Towards such a direction, we shall provide a generalized proof rule for establishing refinement of source and target programs for which one need not have to know the underlying program transformations. Our method is supported by a semi-automatic tool that uses a theorem prover for validating the verification conditions. We further show that the translation validation infrastructure provides an effective basis for deriving semantic debuggers and illustrate the development of a simple debugger for optimized programs using this approach using Prolog. A distinct advantage of semantic debugging is that it permits the user to change values at run-time only when the values are consistent with the underlying semantics.     

A language for inquiring about the run-time behaviour of programs

This paper describes a language for studying the behaviour of programs, based upon the data collected while these programs are executed by a computer. Besides being a useful tool in debugging, the language is also valuable in the experimental evaluation of the complexity of algorithms, in studying the interdependence of conditionals in a program and in determining the feasibility of transporting programs from one machine to another. The program one wishes to analyse is written in an Algol 60-like language; when the program is executed it automatically stores, in a data base, the information needed to answer general questions about computational events which occurred during execution. This information consists (basically) of the list of labels passed while the program is being executed, and the current values of the variables. Since the list of labels is describable by regular expressions, these expressions can also be used to identify specific subparts of the list and therefore allow access to the values of the variables. This constitutes the basis for the design of the inquiry language. The user's questions are automatically answered by a processor which inspects the previously generated data base. The paper also presents examples of the use of the language and describes the implementation of its processor.     

A survey on algorithmic debugging strategies

Algorithmic debugging is a debugging technique that has been extended to practically all programming paradigms. Roughly speaking, the technique constructs an internal representation of all (sub)computations performed during the execution of a buggy program; and then, it asks the programmer about the correctness of such computations. The answers of the programmer guide the search for the bug until it is isolated by discarding correct parts of the program. After twenty years of research in algorithmic debugging many different techniques have appeared to improve the original proposal. Surprisingly, no study exists that joins together all these techniques and compares their advantages and their performance. This article presents a study that compares all current algorithmic debugging techniques and analyzes their differences and their costs. The research identifies the dimensions on which each strategy relies. This information allows us to combine the strong points of different strategies.     

Structured debugging using a domain specific language

A structured approach to debugging is presented based on restricting the class of programs that can be written. This is achieved by defining a domain specific language, eliminating control flow by using aggregate operations and eliminating side effects by using an applicative language as a base. The domain specific language is realized by defining domain specific operators as extensions to the base language; a set of operators are defined in the paper for data processing applications. The debugging strategy consists of setting up a sequence of input/output transformations; this process takes the input to the output in partial stages so that the correctness of each transformation relative to its input and output set can be verified. The approach is illustrated by a simple data processing problem.     

Very high-level language design: A viewpoint

Recent developments in very high-level language design indicate that these languages hold great promise for improving the level of man-machine communication, and hence improving computer and programmer utilization. (Essentially, a very high-level language one which allows the programmer to specify what to do, rather than how to do it.) This paper surveys these developments, outlines the goals to which an “ideal” very high-level language should aspire, and then presents the design of a very high-level language that would meet these goals. This design is presented in the interest of laying bare some basic design and implementation questions that are inherent to such an achievement. The paper then discusses these questions, indicating both old and new research problems which they suggest.     

Emerald: A general-purpose programming language

Emerald is a general-purpose language with aspects of traditional object-oriented languages, such as Smalltalk, and abstract data type languages, such as Modula-2 and Ada. It is strongly typed with a non-traditional object model and type system that emphasize abstract types, allow separation of typing and implementation, and provide the flexibility of polymorphism and subtyping with compile-time checking. This paper describes the Emerald language and its programming methodology. We give examples that demonstrate Emerald's features, and compare and contrast the Emerald approach to programming with the approaches used in other similar languages.     

Notes on the case statement

The case statement is one of the newest and one of the least known of the ‘standard’ control structures in higher level languages. Its importance has increased with the greater use of structured and goto-less programming. This paper surveys the development of the case statement and provides two extensions which are natural and intuitive and which, it is claimed, increase the intellectual manageability of the host language.     

The programming language standards scene, ten years on Paper 11: C

This paper, one of a simultaneously published set, describes the establishment in 1984/5 of the standards project for the programming language C, and the progress of the project to the end of 1993.     

The programming language standards scene, ten years on paper 20: Rexx

This paper, one of a simultaneously published set, describes the establishment in 1990 of the US standards project for the programming language Rexx, and the progress of the project to the end of 1993.     

The programming language standards scene, ten years on Paper 8: Basic

This paper, one of a simultaneously published set on ten years of activity in programming language standards, describes the developments in standardization of the programming language Basic which have taken place in the period 1983–1993.     

The programming language standards scene, ten years on Paper 4: Cobol

This paper, one of a simultaneously published set on ten years of activity in programming language standards, describes the developments in standardization of the programming language Cobol which have taken place in the period 1983–1993.     

The programming language standards scene, ten years on Paper 9: Ada

This paper, one of a simultaneously published set on ten years of activity in programming language standards, describes the developments in standardization of the programming language Ada which have taken place in the period 1983–1993.     

The programming language standards scene, ten years on paper 19: Pop

This paper, one of a simultaneously published set, describes the establishment in 1990 of the UK standards project for the Pop programming language, and the progress of the project to the end of 1993.     

PEP: An interactive programming system with an Algol-like programming language

PEP (Program Editor and Processor) is an interactive programming system based on an Algol-like language. It is intended to replace BASIC as a system for interactive program development on small computers (LSI-11). The language processed by the system allows declaration of variables, constants and procedures; it has structured statements for conditional and repetitive execution of program parts. We describe design and implementation of the system and give our impressions after 1 year of experience with the system.     

The programming language standards scene, ten years on Paper 5: Fortran

This paper, one of a simultaneously published set on ten years of activity in programming language standards describes the developments in standardization of the programming language Fortran which have taken place in the period 1983–1993.     

Unisex: A unix-based symbolic executor for pascal

UNISEX is a UNIX-based symbolic executor for Pascal. The UNISEX system provides an environment for both testing and formally verifying Pascal programs. The system supports a large subset of Pascal, runs on UNIX and provides the user with a variety of debugging features to help in the difficult task of program validation. This paper contains a brief introduction to symbolic execution, followed by an overview of the features of UNISEX, a discussion of the UNISEX Pascal language, and some of the implementation details for the UNISEX system. Finally, some of the problems encountered when designing and implementing the system are discussed as well as future directions.     

The programming language standards scene, ten years on paper 18: M[UMPS]

This paper, one of a simultaneously published set, describes the developments in the standardization of M Technology (formerly MUMPS), which have taken place in the period 1983–1993, including a progress report on the transition from the original US MUMPS standard adopted by the ANSI canvass method, to full international standard.