Topic
Program transformation
About: Program transformation is a research topic. Over the lifetime, 2468 publications have been published within this topic receiving 73415 citations.
Papers published on a yearly basis
Papers
More filters
10 Jul 1997
TL;DR: Schema-based program transformation has been proposed as an effective technique for the optimisation of logic programs as discussed by the authors, where schemata are applied to a logic program, mapping inefficient constructs to more efficient ones.
Abstract: Schema-based program transformation [8] has been proposed as an effective technique for the optimisation of logic programs. Schemata are applied to a logic program, mapping inefficient constructs to more efficient ones. One challenging aspect of the technique is that of proving that the schemata are correct.
18 citations
01 Jan 2004
TL;DR: An innovative and automatic approach to partitioning with emphasis on correctness is presented, characterised as a program transformation task and the partitioned system is derived from the original description of the system by applying transformation rules, all of them proved from the basic laws of occam.
Abstract: A crucial point in hardware/software co-design is how to perform the partitioning of a system into hardware and software components. Although several algorithms to partitioning have been recently proposed, the formal verification of the partitioning procedure is an emergent research topic. In this paper we present an innovative and automatic approach to partitioning with emphasis on correctness. The formalism used is occam and the algebraic laws that define its semantics. In the proposed approach, the partitioning procedure is characterised as a program transformation task and the partitioned system is derived from the original description of the system by applying transformation rules, all of them proved from the basic laws of occam. A tool has been developed to allow the partitioning to be carried out automatically. The entire approach is illustrated here through a small case study.
18 citations
23 Sep 2019
TL;DR: It is argued in this paper that one can improve program comprehension when she applies particular transformations to introduce lambda expressions, and that state-of-the-art models for estimating program readability are not helpful to capture the benefits of a program transformation to introducelambda expressions.
Abstract: Background: The Java programming language version eighth introduced a number of features that encourage the functional style of programming, including the support for lambda expressions and the Stream API. Currently, there is a common wisdom that refactoring a legacy code to introduce lambda expressions, besides other potential benefits, simplifies the code and improves program comprehension. Aims: The purpose of this paper is to investigate this belief, conducting an in depth study to evaluate the effect of introducing lambda expressions on program comprehension. Method: We conduct this research using a mixed-method study. First, we quantitatively analyze 66 pairs of real code snippets, where each pair corresponds to the body of a method before and after the introduction of lambda expressions. We computed two metrics related to source code complexity (number of lines of code and cyclomatic complexity) and two metrics that estimate the readability of the source code. Second, we conduct a survey with practitioners to collect their perceptions about the benefits on program comprehension, with the introduction of lambda expressions. The practitioners evaluate a number between three and six pairs of code snippets, to answer questions about possible improvements. Results: We found contradictory results in our research. Based on the quantitative assessment, we could not find evidences that the introduction of lambda expressions improves software readability--one of the components of program comprehension. Differently, our findings of the qualitative assessment suggest that the introduction of lambda expression improves program comprehension. Implications: We argue in this paper that one can improve program comprehension when she applies particular transformations to introduce lambda expressions (e.g., replacing anonymous inner classes by lambda expressions). In addition, the opinion of the participants shine the opportunities in which a transformation for introducing lambda might be advantageous. This might support the implementation of effective tools for automatic program transformations. Finally, our results suggest that state-of-the-art models for estimating program readability are not helpful to capture the benefits of a program transformation to introduce lambda expressions.
18 citations
29 Sep 1998
TL;DR: This work proposes a refinement of Leroy's type-directed unboxing transformation, still relying only on visible types, and proves that it satisfies the safety condition for time complexity, and extends the usual logical relation method, in which correctness and safety are proved simultaneously.
Abstract: Avoiding boxing when representing native objects is essential for the efficient compilation of any programming language For polymorphic languages this task is difficult, but several schemes have been proposed that remove boxing on the basis of type information. Leroy's type-directed unboxing transformation is one of them. One of its nicest properties is that it relies only on visible types, which makes it compatible with separate compilation. However it has been noticed that it is not safe both in terms of time and space complexity ---i.e. transforming a program may raise its complexity. We propose a refinement of this transformation, still relying only on visible types, and prove that it satisfies the safety condition for time complexity. The proof is an extension of the usual logical relation method, in which correctness and safety are proved simultaneously.
18 citations
Book•
01 Jan 2004
TL;DR: This book discusses Domain-Specific Optimization, DSL Implementation in MetaOCaml, Template Haskell, and C++, and Runtime Code Generation in C++ as a Foundation for Domain- specific Optimisation.
Abstract: Surveys.- The Road to Utopia: A Future for Generative Programming.- From a Program Family to a Domain-Specific Language.- A Gentle Introduction to Multi-stage Programming.- DSL Implementation in MetaOCaml, Template Haskell, and C++.- Program Optimization in the Domain of High-Performance Parallelism.- A Personal Outlook on Generator Research.- Domain-Specific Languages.- Generic Parallel Programming Using C++ Templates and Skeletons.- The Design of Hume: A High-Level Language for the Real-Time Embedded Systems Domain.- Embedding a Hardware Description Language in Template Haskell.- A DSL Paradigm for Domains of Services: A Study of Communication Services.- PiLib: A Hosted Language for Pi-Calculus Style Concurrency.- Tools for Program Generation.- A Language and Tool for Generating Efficient Virtual Machine Interpreters.- Program Transformation with Stratego/XT.- Retrofitting the AutoBayes Program Synthesis System with Concrete Syntax.- Domain-Specific Optimization.- Optimizing Sequences of Skeleton Calls.- Domain-Specific Optimizations of Composed Parallel Components.- Runtime Code Generation in C++ as a Foundation for Domain-Specific Optimisation.- Guaranteed Optimization for Domain-Specific Programming.
18 citations