Trustworthy Refactoring via Decomposition and Schemes: A Complex Case Study

@inproceedings{Horpcsi2017TrustworthyRV,
  title={Trustworthy Refactoring via Decomposition and Schemes: A Complex Case Study},
  author={D{\'a}niel Horp{\'a}csi and Judit K{\"o}szegi and Zolt{\'a}n Horv{\'a}th},
  booktitle={VPT@ETAPS},
  year={2017}
}
Widely used complex code refactoring tools lack a solid reasoning about the correctness of the transformations they implement, whilst interest in proven correct refactoring is ever increasing as only formal verification can provide true confidence in applying tool-automated refactoring to industrial-scale code. By using our strategic rewriting based refactoring specification language, we present the decomposition of a complex transformation into smaller steps that can be expressed as instances… 

Towards a Generic Framework for Trustworthy Program Refactoring

TLDR
By separating the various concerns in the transformation process, this approach enables modular and language-parametric implementation and proposes high-level abstractions for refactoring definition and outlines a generic framework which is capable of verifying and executingRefactoring specifications.

Machine-checked natural semantics for Core Erlang: exceptions and side effects

TLDR
This paper presents an extended natural semantics for Core Erlang based on the previous formalisation implemented with the Coq Proof Assistant, which includes the concepts of exceptions and side effects.

Program Equivalence in an Untyped, Call-by-value Lambda Calculus with Uncurried Recursive Functions

TLDR
A number of existing approaches of expression equivalence are adapted to a simple functional programming language that carries the main features of sequential Core Erlang and the properties of the equivalence relations are examined and formally established.

Adaptation of a Refactoring DSL for the Object-Oriented Paradigm

TLDR
This work presents a proposal for adapting this language from the functional to the object-oriented programming paradigm, using Java in place of Erlang as a representative, and formally defines the chosen base refactoring as a composition of scheme instances.

References

SHOWING 1-10 OF 25 REFERENCES

Towards Trustworthy Refactoring in Erlang

TLDR
A simple, high-level but rigorous, notation for defining refactoring transformations in Erlang is proposed, and it is shown that this notation provides an extensible, verifiable and executable specification language forRefactoring.

Renaming Global Variables in C Mechanically Proved Correct

TLDR
A refactoring operation is considered, and it is proved that its core implementation preserves the set of possible behaviors of transformed programs and relies on the operational semantics of C provided by CompCert C in Coq.

Formalizing refactorings with graph transformations

TLDR
It is demonstrated that it is possible to prove that refactorings preserve certain program properties, and that graph rewriting is a suitable f ormalism for such proofs.

Mechanical verification of refactorings

TLDR
The formal verification of refactorings for untyped and typed lambda-calculi is described in the proof assistant Isabelle/HOL, and the formalisation adopted and the alternatives explored are described.

A Domain-Specific Language for Scripting Refactorings in Erlang

TLDR
The domain-specific language framework of Wrangler is introduced that allows users to script composite refactorings, test them and apply them on the fly and can be previewed, applied and ‘undone' interactively.

A formal pattern language for refactoring of Lisp programs

  • A.M. Leitdo
  • Computer Science
    Proceedings of the Sixth European Conference on Software Maintenance and Reengineering
  • 2002
TLDR
The pattern language is used to define refactoring operations that can be as powerful as is computationally possible but that are very, easy to write.

Specifying and implementing refactorings

TLDR
This work shows that the concept of microrefactorings are powerful enough to provide high-level specifications of many of the refactorings implemented in Eclipse that are precise enough to serve as the basis of a clean-room reimplementation of these refactoring that is very compact, yet matches Eclipse's for features and outperforms it in terms of correctness.

Practical analysis for refactoring

TLDR
A new definition of refactoring is given that focuses on preconditions and postconditions of the refactorings, rather than on the program transformation itself, and the criteria that are necessary for anyRefactoring tool to succeed are identified.

JunGL: a scripting language for refactoring

TLDR
A domain-specific language for refactoring, named JunGL, which manipulates a graph representation of the program: all information about the program, including ASTs for its compilation units, variable binding, control flow and so on is represented in a uniform graph format.

A Formal Pattern Language for Refactoring of Lisp Programs

TLDR
This paper presents a new approach to refactoring that addresses many of the challenges faced in today's rapidly changing environment and shows real-time improvements in the speed and efficiency of these tools.