Showing papers on "Program transformation published in 1976"

Goal-Directed Program Transformation

Abstract: Program development often proceeds by transforming simple, clear programs into complex, involuted, but more efficient ones. This paper examines ways this process can be rendered more systematic. We show how analysis of program performance, partial evaluation of functions, and abstraction of recursive function definitions from recurring subgoals can be combined to yield many global transformations in a methodical fashion. Examples are drawn from compiler optimization, list processing, very high-evel languages, and APL execution.

Goal-directed program transformation

Abstract: Program development often proceeds by transforming simple, clear programs into complex, involuted, but more efficient ones. This paper examines ways this process can be rendered more systematic. We show how analysis of program performance, partial evaluation of functions, and abstraction of recursive function definitions from recurring subgoals can be combined to yield many global transformations in a methodical fashion. Examples are drawn from compiler optimization, list processing, very high level languages, and APL execution.

Primitive recursive program transformation

Abstract: We describe how to transform certain flowchart programs into equivalent explicit primitive recursive programs. The input/output correctness conditions for the transformed programs are more amenable to proof than the verification conditions for the corresponding flowchart programs. In particular, the transformed correctness conditions can often be verified automatically by the theorem prover developed by Boyer and Moore [1].

The Specification of Assemblers

Abstract: The problem of applying formal techniques of program specification and verification to large complex programs is considered. It is argued that a practical solution requires a variety of techniques, including both procedural and nonprocedural specifications, hierarchical program organization, and the use of program transformations. In particular, a case is made for flexible problem-oriented choice of specification techniques and languages. These ideas are expanded by specifying a load-and-go assembler in three parts: a transduction grammar describing the correspondence between concrete and abstract syntax for assembly language programs; a set of transformations of the abstract form; and a nonconstructive axiomatic specification of the result of core assembly and loading of transformed abstract programs.

A case study in program transformation

Abstract: A simple problem relating to binary trees is considered, and a recursive program is proved to solve this problem. The program may be transformed into a more efficient iterative one, usinggoto-statements and explicit stack handling. An independent correctness proof for this transformed version is given and compared with the original proof. Finally it is shown how a non-recursive conception of the problem may yield a structured iterative program, based onwhile-statements. A proof of this program is presented, reflecting its non-recursive conception, and it turns out that this proof has little similarity with the other two.