Refactoring as formal refinements

Program restructuring in the context of object-oriented programming is known as refactoring. This consists of changes made to the internal structure of software in order to improve its legibility and make it easier to modify without changing its external behaviour. In practice, refactoring usually relies on compilation and tests in order to guarantee behaviour preservation. Works like those by Opdyke and Roberts have already been done in the direction of refactoring formalisation by means of the identification of conditions that must be satisfied to guarantee that a change to a program is behaviour preserving. The conditions, which are usually written in the predicate calculus, are introduced as preand postconditions of the refactorings. Other approaches for the proof of refactoring behaviour preservation use formalisms such as concept analysis and graph rewriting. However, there is no algebraic technique that presents refactorings as behaviour preserving transformations, with proofs carried out. This avoids changes of notation and facilitates mechanisation. Our contribution is to present refactorings as transformations of programs written in the language rool (Refinement object-oriented Language), which is a Java-like imperative language with classes, visibility control for attributes, dynamic binding, and recursion. It allows reasoning about object-oriented programs and specifications, as both kinds of constructs are mixed as in Morgan’s refinement calculus. The semantics of rool, as usual for refinement calculi, is based on weakest preconditions. A set of programming laws is available for the imperative constructs of rool as well as for its object-oriented features. The correctness of these laws, which is also a contribution of the present work, is proved against the semantics of rool. We present refactorings as algebraic refinement rules involving program terms. The proof that these rules are behaviour preserving is accomplished by the application of the programming laws of one of the sides of the rule to obtain the other side. The proofs of some refactoring rules also involve data refinement of classes. We generalise the standard data refinement technique from single modules (classes) to class hierarchies. Design patterns arise as a natural objective for refactoring a system. The literature on design patterns already presents works that propose the formalisation of design patterns. They usually concentrate on the formal description of patterns, not on the transformation of a system with the intention of obtaining a final system structure according to a design pattern. In this work, we also present how to obtain a system that is in accordance with design patterns by the application of refactoring rules proved to be behaviour preserving. We also present the transformation of a monolithic application to a well-structured one according to an architectural pattern.