Showing papers on "Program transformation published in 1978"

Can programming be liberated from the von Neumann style?: a functional style and its algebra of programs

Abstract: Conventional programming languages are growing ever more enormous, but not stronger. Inherent defects at the most basic level cause them to be both fat and weak: their primitive word-at-a-time style of programming inherited from their common ancestor—the von Neumann computer, their close coupling of semantics to state transitions, their division of programming into a world of expressions and a world of statements, their inability to effectively use powerful combining forms for building new programs from existing ones, and their lack of useful mathematical properties for reasoning about programs.An alternative functional style of programming is founded on the use of combining forms for creating programs. Functional programs deal with structured data, are often nonrepetitive and nonrecursive, are hierarchically constructed, do not name their arguments, and do not require the complex machinery of procedure declarations to become generally applicable. Combining forms can use high level programs to build still higher level ones in a style not possible in conventional languages.Associated with the functional style of programming is an algebra of programs whose variables range over programs and whose operations are combining forms. This algebra can be used to transform programs and to solve equations whose “unknowns” are programs in much the same way one transforms equations in high school algebra. These transformations are given by algebraic laws and are carried out in the same language in which programs are written. Combining forms are chosen not only for their programming power but also for the power of their associated algebraic laws. General theorems of the algebra give the detailed behavior and termination conditions for large classes of programs.A new class of computing systems uses the functional programming style both in its programming language and in its state transition rules. Unlike von Neumann languages, these systems have semantics loosely coupled to states—only one state transition occurs per major computation.

Proving and applying program transformations expressed with second-order patterns

Abstract: We propose a program transformation method based on rewriting-rules composed of second-order schemas. A complete second-order matching algorithm is presented that allows effective use of these rules. We show how to formally prove the correctness of the rules using a denotational semantics for the programming language. We establish the correctness of the transformation method itself, and give techniques pertaining to its actual implementation. The paper is illustrated with recursion removal examples.

A synthesis of several sorting algorithms

Abstract: We synthesise versions of six well known sorting algorithms from a common specification using program transformation techniques. On the way to the sorting algorithms we synthesise three algorithms for generating permutations thus building up a family tree for the sorts exposing certain relationships between them.

Is “sometime” sometimes better than “always”?: intermittent assertions in proving program correctness

Abstract: This paper explores a technique for proving the correctness and termination of programs simultaneously. This approach, the intermittent-assertion method, involves documenting the program with assertions that must be true at some time when control passes through the corresponding point, but that need not be true every time. The method, introduced by Burstall, promises to provide a valuable complement to the more conventional methods.The intermittent-assertion method is presented with a number of examples of correctness and termination proofs. Some of these proofs are markedly simpler than their conventional counterparts. On the other hand, it is shown that a proof of correctness or termination by any of the conventional techniques can be rephrased directly as a proof using intermittent assertions. Finally, it is shown how the intermittent-assertion method can be applied to prove the validity of program transformations and the correctness of continuously operating programs.

The Logic of Computer Programming

Abstract: Techniques derived from mathematical logic promise to provide an alternative to the conventional methodology for constructing, debugging, and optimizing computer programs. Ultimately, these techniques are intended to lead to the automation of many of the facets of the programming process.

Systematics of Transformation Rules

Abstract: There are essentially two ways to attack the problem of the "correctness" of program transformations: transformation rules can be given as axioms — thus determining (parts of) the semantics of the language — or they can be verified with respect to a particular definition of the semantics. This classification is taken here as a guide-line for a systematic survey of transformation rules.

Examples for Change of Types and Object Structures

Abstract: The abstract, algebraic definition of data types by describing their properties forms a solid formal basis for the specification of computation structures independent of their particular representations. Thus programs can be designed and developed working with objects of an abstractly defined computation structure. The choice of particular representations (implementations), the releasing of this representation to the "outer world" and the consequences on further program development are demonstrated with examples of joint refinement.