This paper briefly surveys what transformational programming is about, and how to make progress in the field. A program transformation is a meaning-preserving mapping defined on a programming language. Transformational programming is a program development methodology in which an implementation I is obtained from a specification S by applying a sequence T k :::T 1 of transformations to S. If S and each transformation T i applied to successive implementations T i\Gamma1 :::T 1 S of S are proved correct for

Given are a directed edge-labelled graph G with a distinguished node n0, and a regular expression P which may contain variables. We wish to compute all substitutions φ (of symbols for variables), together with all nodes n such that all paths n0 → n are in φ(P). We derive an algorithm for this problem using relational algebra, and show how it may be implemented in Prolog. The motivation for the problem derives from a declarative framework for specifying compiler optimisations. 1 Bob Paige and IFIP WG 2.1 Bob Paige was a long-standing member of IFIP Working Group 2.1 on Algorithmic Languages and Calculi. In recent years, the main aim of this group has been to investigate the derivation of algorithms from specifications by program transformation. Already in the mid-eighties, Bob was way ahead of the pack: instead of applying transformational techniques to well-worn examples, he was applying his theories of program transformation to new problems, and discovering new algorithms [16, 48, 52]. The secret of his success lay partly in his insistence on the study of general algorithm design strategies (in particular

We demonstrate how several programming language concepts and methods can be used economically to obtain an improved solution to a difficult algorithmic problem. The problem is to compile a subset RCS of Relational Calculus defined by Willard (1978) in a novel way so that efficient run-time query performance is guaranteed. Willard gives an algorithm to compile each query q belonging to RCS so that it executes in O(n log d n+o) steps and O(n) space, where n and o are respectively the input and output set sizes, and d is a parameter associated with the syntax of query q. Willard's time bounds are based on the assumption that hashing unit-space data takes unit time. In this paper we use a set-theoretic complexity measure and formal transformational techniques to reconstruct the linear time fragment of RCS in a simplified way. In doing this, we show how complexity can be determined by language abstraction and algebraic reasoning without resorting to low level counting arguments. This ap...

Tarski-Givant’s map calculus is briefly reviewed, and a plan of research is outlined aimed at investigating applications of this ground equational formalism in the theorem-proving field. The main goal is to create synergy between first-order predicate calculus and the map calculus. Techniques for translating isolated sentences, as well as entire theories, from first-order logic into map calculus are designed, or in some cases simply brought nearer through the exercise of specifying properties of a few familiar structures (natural numbers, nested lists, finite sets, lattices). It is also highlighted to what extent a state-of-the-art theorem-prover for first-order logic, namely Otter, can be exploited not only to emulate, but also to reason about, map calculus. Issues regarding ’safe ’ forms of map reasoning are singled out, in sight of possible generalizations to the database area. 1

Abstract not found

hereby granted, provided that this notice and the reference

Abstract. The objectives of this research are to improve software productivity, reliability, and performance of complex systems. The approach combines program transformations, sometimes in reflective ways, to turn very high level perspicuous specifications into efficient implementations. These transformations will be implemented in a meta-transformational system, which itself will be transformed from an executable specification into efficient code. Experiments will be conducted to assess the research objectives in scaled up applications targetted to systems that perform complex program analysis and translation. The transformations to be used include dominated convergence (for implementing fixed points efficiently), finite differencing (for replacing costly repeated calculations by less expensive incremental counterparts), data structure selection (for simulating associative access on a RAM in real time), and partial evaluation (for eliminating interpretive overhead and simplification). Correctness of these transformations, of user-defined transformations, and of the transformational system itself will be addressed in part. Both the partial evaluator and components of the

The group was exciting in the 1970’s, when we were groping for direction and divided by different orientations. I guess it was in this atmosphere that combined purpose with uncertainty where I found my own voice. The common goal was a transformational program development methodology that would improve productivity of designing and maintaining correct software. The emphasis was on algorithmic software. We differed as to how to achieve this goal, and my approach was out on a limb. Based on a few transformations, the most exciting of which was Jay Earley’s iterator inversion combined with high level strength reduction, and also on an overly optimistic faith in the power of science to shed light on this subject, I believed that algorithms and algorithmic software could be designed scientifically from abstract problem specifications by application of a small number of rules, whose selection could be simplified (even automated in some cases) if it could be guided by complexity. Most all others (including the SETL crowd at Courant) disagreed, and accepted the notion that algorithm design was ‘inspired’, and that the most significant steps in a derivation were unexplainable ‘Eureka ’ steps. I knew that my goals were ambitious and with little supporting evidence. In fact the

Abstract not found