Program transformation

About: Program transformation is a research topic. Over the lifetime, 2468 publications have been published within this topic receiving 73415 citations.

Beyond Tamaki-Sato Style Unfold/Fold Transformations for Normal Logic Programs

Abstract: Unfold/fold transformation systems for logic programs have been extensively investigated. Existing unfold/fold transformation systems for normal logic programs allow only Tamaki-Sato style folding using clauses from a previous program in the transformation sequence: i.e., they fold using a single, non-recursive clause. In this paper we present a transformation system that permits folding in the presence of recursion, disjunction, as well as negation. We show that the transformations are correct with respect to various semantics of negation including the well-founded model and stable model semantics.

The normal object form: bridging the gap from models to code

Abstract: The value of graphical modeling within the analysis and design activities of object-oriented development is predicated on the assumption that the resulting models can be mapped correctly, optimally and efficiently into executable (normally textual) code In practice, however, because of the large potential mismatch in abstraction levels, the mapping of graphical models into code is often one of the weakest and most error prone links in the chain of development steps This paper describes a practical approach for addressing this problem based upon the definition of a restricted extension of the UML known as the Normal Object Form (NOF) The basic purpose of the NOF is to provide a set of UML modeling concepts which are "semantically close" to those found in object-oriented programming languages Highly abstract UML models can then be mapped into corresponding executable code by means of a series of semantically small refinement (intra-UML) and translation (extra-UML) translation steps, rather than in one large (often ad hoc) step This not only increases the chances of a correct and optimal mapping, but also significantly improves the traceability of UML constructs to and from code constructs, with all the associated advantages for maintenance and reuse

A Formal Model Driven Approach to Dependable Software Evolution

Abstract: The paper proposes a unified formal model driven approach to software evolution based on both program transformation and model transformation of legacy systems. A formal model definition ensures a consistent interpretation of the legacy system and provides a theoretical foundation for dependable software evolution. The theoretical foundation is based on the construction of a wide spectrum language for reengineering, known as WSL, which enjoys a sound formal semantics. The architecture and working flow of the approach are proposed, and the mappings between WSL and PSL in MDA provide an engaging combination of traditional program transformation and modern model transformation, which shows that the proposed approach is feasible and promising in its domain. A prototype tool is developed to test the approach and a case study is used for experiments with the proposed approach and the prototype tool. Conclusion is drawn based on analysis and further research directions are also discussed.

Implementing Typeful Program Transformations

Abstract: The notion of program transformation is ubiquitous in programming language studies on interpreters, compilers, partial evaluators, etc. In order to implement a program transformation, we need to choose a representation in the meta language, that is, the programming language in which we construct programs, for representing object programs, that is, the programs in the object language on which the program transformation is to be performed. In practice, most representations chosen for typed object programs are typeless in the sense that the type of an object program cannot be reflected in the type of its representation. This is unsatisfactory as such typeless representations make it impossible to capture in the type system of the meta language various invariants in a program transformation that are related to the types of object programs. In this paper, we propose an approach to implementing program transformations that makes use of a first-order typeful program representation, where the type of an object program as well as the types of the free variables in the object program can be reflected in the type of the representation of the object program. We introduce some programming techniques needed to handle this typeful program representation, and then present an implementation of a CPS transform function where the relation between the type of an object program and that of its CPS transform is captured in the type system of DML. In a broader context, we claim to have taken a solid step along the line of research on constructing certifying compilers.