Stuart I. Feldman

Make — a program for maintaining computer programs

Good programmers break their projects into a number of pieces, each to be processed or compiled by a different chain of programs. After a set of changes is made, the series of actions that must be taken can be quite complex, and costly errors are frequently made. This paper describes a program that can keep track of the relationships between parts of a program, and issue the commands needed to make the parts consistent after changes are made. Make has been in use on UNIX UNIX is a trademark of Bell Laboratories. systems since 1975. The underlying idea is quite simple and can be adapted to many other environments.

IGOR: a system for program debugging via reversible execution

Typical debugging tools are insufficiently powerful to find the most difficult types of program misbehaviors. We have implemented a prototype of a new debugging system, IGOR, which provides a great deal more useful information and offers new abilities that are quite promising. The system runs fast enough to be quite useful while providing many features that are usually available only in an interpreted environment. We describe here some improved facilities (reverse execution, selective searching of execution history, substitution of data and executable parts of the programs) that are needed for serious debugging and are not found in traditional single-thread debugging tools. With a little help from the operating system, we provide these capabilities at reasonable cost without modifying the executable code and running fairly close to full speed. The prototype runs under the DUNE distributed operating system. The current system only supports debugging of single-thread programs. The paper describes planned extensions to make use of extra processors to speed the system and for applying the technique to multi-thread and time dependent executions.

Environment Parameters and Basic Functions for Floating-Point Computation

A language-independent proposal for environment parameters and basic functions for floating-point computation is presented. Basic functions are proposed to analyze, synthesize, and scale floating-point numbers. The model provides a small set of parameters and a small set of axioms along with sharp measures of roundoff error. The parameters and functions can be used to write portable and robust codes that deal intimately with the floating-point representation. Subject to underflow and overflow constraints, a number can be scaled by a power of the floating-point radix inexpensively and without loss of precision. A specific representation for FORTRAN is included.

Implementation of a portable Fortran 77 compiler using modern tools

I have recently written a portable compiler [1] for the Fortran 77 language [2]. It attacks an old language with new tools: the parser is generated automatically from an LALR(1) grammar, the program is produced by code generators designed for another language. These tools proved very valuable, but they are based on theory and experience one or two decades fresher than that underlying Fortran, so they really do not fit this application. The following discusses the approach taken, the ways in which the tools had to be bent to do the job, the properties of Fortran that seem to cause the most trouble, and the costs of writing a portable compiler. It also describes certain aspects of the approach to code generation, since others may wish to use the same tools. This paper does not describe low-level details of the implementation. This compiler is intimately connected with the programming language C[3]. The compiler is written in C, it uses tools written in C, the input/output library uses the standard C library, and it uses the second pass of a C compiler as code generator. To a much smaller extent, this compiler is based on the UNIXï¾ operating system, since all of the development work was done on UNIX systems and the current version of the compiler assumes the UNIX system process structure. It would require a serious but not enormous effort to move this compiler to a different operating system; it would be impossible to move it to a non-C environment.

A Fortranner's lament: comments on the draft proposed ANS Fortran standard

The Fortran Standard is now ten years old, and the XSJ3 Committee has recently published a proposal for a new one. Much has been learned about programming during this period. Many Fortran extensions have been implemented in various compilers. We must agree that a new standard is timely. The Committee undertook a Herculean task, for which they deserve great credit. Changing Fortran must be like fighting the Hydra--repairing one problem must introduce two new ones in its place. (We wish they had adopted the Augean Stables approach instead.)

An application of symbolic computation to crystal physics

This paper describes a practical application of symbolic computation to a problem in chemical physics. We compute a series approximation to a fairly complicated integral using straightforward techniques, allowing the computer to take over when the problem becomes too messy. Even though Altran [1] has no direct way to handle non-rational functions, introducing a few auxiliary variables renders the problem tractable. We certainly hope that more users will attempt to solve standard problems of this sort using symbolic manipulation programs.

A brief description of Altran

This paper contains a summary of the Altran (Algebraic Translator) language and system for performing symbolic computations on algebraic data. We hope we have included enough details to make it easy to understand published Altran programs. To this end, we describe the syntax and semantics of the language and briefly define the available library procedures. We have not included all of the details of error conditions, special cases, and default that a user may need to know to program a complicated problem.