The issues of re-engineering and reverse engineering have become important ones in the computing industry. A legacy system that has evolved has usually been worked on by many different programmers and reflects the different programming styles as practised by those programmers. We address the re-engineering of a large system, the TAMPR automatic program transformation system, written in pure Lisp. TAMPR is an essential tool in ongoing research on potential applications of automated program transformation. The program implementing the TAMPR system is better designed and more consistently coded than most legacy systems. Why, then, is reverse engineering being attempted for this system, given that it suffers few of the problems of more traditionally implemented legacy systems? We are interested in studying the problem of abstraction in reverse engineering, and the TAMPR system, with its systematic design and coding, provides a good starting point for studying approaches to automated abstraction to an object-oriented form. In addition, while the system in its present form meets the current needs of its users, there are problems with providing widely available, efficient implementations of the system. The target language for this experiment in reverse engineering is Java. Java was chosen because of its widespread availability, claimed portability and its integration with components for the construction of graphical user interfaces. We use TAMPR transformations to reverse engineer the TAMPR program itself.

Abstract One can have all the advantages of functional programming – correctness, clarity, simplicity, and flexibility – without any sacrifice in performance, even for a scientifically significant computation on a supercomputer. Therefore, why use Fortran? We demonstrate parity – equality of speed and storage use – between a program generated automatically from a functional specification and a program written by hand in the procedural style. To our knowledge, this demonstration of parity is the first for a program that solves a scientifically significant problem – quasi-linear hyperbolic partial differential equations – on a scientifically interesting supercomputer – the CRAY X-MP. We use pure Lisp, including higher-order functions, to express the functional specification for the PDE solver. We designed this specification for maximal clarity and flexibility, rather than for efficiency. Nevertheless, we obtain a highly efficient program to solve the PDEs: automated program transformations put back the missing efficiency as they produce an executable Fortran program from the specification. The generated Fortran program vectorizes on the CRAY X-MP and runs about 4% faster than a handwritten Fortran program for the same problem. We describe the problem and the specification, and some of the problem-domain-specific and hardware-specific transformations that we use to obtain the high-efficiency program.

How can a program written in pure applicative LISP be reused in a Fortran environment? One answer is by automatically transforming it from LISP into Fortran. In this paper we discuss a practical application of this technique-one that yields an efficient Fortran program. We view this process as an example of abstract programming, in which the LISP program constitutes an abstract specification for the Fortran version. The idea of strategy-a strategy for getting from LISP to Fortran-is basic to designing and applying the transformations. One strategic insight is that the task is easier if the LISP program is converted to ``recursive'' Fortran, and then the recursive Fortran program is converted to nonrecursive standard Fortran. Another strategic insight is that much of the task can be accomplished by converting the program from one canonical form to another. Developing a strategy also involves making various implementation decisions. One advantage of program transformation methodology is that it exposes such decisions for examination and review. Another is that it enables optimizations to be detected and implemented easily. Once a strategy has been discovered, it can be implemented by means of rewrite-rule transformations using the TAMPR program transformation system. The transformational approach to program reuse based on this strategy has a measure of elegance. It is also practical-the resulting Fortran program is 25 percent faster than its compiled LISP counterpart, even without extensive optimization.

Message quality is a critical factor in influencing user acceptance of a program product. Good error messages can reduce the time and cost to create and maintain software, as well as help users learn about the product. We have developed a methodology for conducting controlled usability evaluations of error messages. The Message Test Program is easily modified to adapt to different product situations, and messages can be evaluated even before working code exists. The Message Test Program can be used to test error messages for a batch product, as well as messages for an interactive product. It can also be used for stand-alone messages, for products that offer on-line help, or messages that provide additional information in a reference manual. Message testing enables us to objectively evaluate error messages and provide specific feedback about the difficulties users encounter and how error messages can be improved.

To study a different star the astronomer moves his telescope. To study a different bacterium the biologist moves his microscope slide. In the case of the astronomer, it is the viewing instrument that is being moved, while in the case of the biologist it is the viewed object that is being moved. These scientists have no choice, the nature of their equipment requires that they operate in a pre-defined way. The user of a video display terminal (VDT), however, can be given a choice. The VDT user views a representation of an area of computer memory. In most cases the portion of memory the user wishes to examine is much larger than that which will fit on the screen at one time. For this reason almost all VDT's are equipped with some sort of “scroll function” that allows the user to display data that is located beyond the limits of the screen.

The problem of giving an algorithmic specification of the semantics of identifier denotation and block structure in Algol 60 is investigated.To facilitate the statement of the algorithms, a set of "canonical identifiers" and certain auxiliary languages are introduced.The algorithms for identifier denotation are then given.They transform an Algol 60 program into one in which no identifier is ever redeclared; hence they unambiguously associate each identifier with its proper declaration.Informal proofs of the correctness of the algorithms are provided.The implications of the algorithms for resolving some of the remaining trouble spots in Algol 60, and their applicability to other languages, are briefly discussed.