Ran Ettinger

Untangling: a slice extraction refactoring

Separation of concerns in existing code can be achieved by specific refactoring techniques. Modern refactoring tools support a number of well-known refactoring transformations, including method extraction. In this paper, we examine how method extraction can be improved through program slicing. Furthermore, we show how a generalization of such slice extraction can be applied to untangle existing code by extracting aspects.

Refactoring via Program Slicing and Sliding

This short paper is a summary of my doctoral research, which was conducted under Oege de Moors supervision at the University of Oxford, starting October 2001. The thesis was submitted on September 29, 2006, and defended on January 18, 2007. The final version was submitted, after minor corrections, on June 15, 2007.

Fine slicing: theory and applications for computation extraction

Software evolution often requires the untangling of code. Particularly challenging and error-prone is the task of separating computations that are intertwined in a loop. The lack of automatic tools for such transformations complicates maintenance and hinders reuse. We present a theory and implementation of fine slicing, a method for computing executable program slices that can be finely tuned, and can be used to extract non-contiguous pieces of code and untangle loops. Unlike previous solutions, it supports temporal abstraction of series of values computed in a loop in the form of newly-created sequences. Fine slicing has proved useful in capturing meaningful subprograms and has enabled the creation of an advanced computation-extraction algorithm and its implementation in a prototype refactoring tool for Cobol and Java.

Re-approaching the refactoring Rubicon

Fowler saw the availability of automated support for the Extract Method refactoring in modern IDEs as an indication for the crossing of the refactoring Rubicon. In spite of the advances in refactoring technology, it seems that this Rubicon has not yet been crossed, and refactoring support in modern IDEs leaves a lot to be desired. We performed a case study in which we converted a Java servlet to use the model-view-controller pattern, using as much automated support as available. We found that while the whole conversion could be described as a series of refactorings, most of these were inadequately supported by the IDE, and some were not supported at all. Based on these findings, we outline the requirements from a refactoring framework that will support much more of the conversion process, and will also enable the composition of small refactorings into larger ones.

Improving slice accuracy by compression of data and control flow paths

Program slicing is a useful technique in tools for program understanding and transformation. Computing correct and accurate slices for unstructured programs is particularly difficult. We present a new family of slicing algorithms that are proved correct and are more accurate than the best previous algorithms. An empirical study shows significant improvements of our algorithms on real code.

Program sliding

As program slicing is a technique for computing a subprogram that preserves a subset of the original programs functionality, program sliding is a new technique for computing two such subprograms, a slice and its complement, the co-slice. A composition of the slice and co-slice in a sequence is expected to preserve the full functionality of the original code. The co-slice generated by sliding is designed to reuse the slices results, correctly, in order to avoid re-computation causing excessive code duplication. By isolating coherent slices of code, making them extractable and reusable, sliding is shown to be an effective step in performing advanced code refactorings. A practical sliding algorithm, based on the program dependence graph representation, is presented and evaluated through a manual sliding-based refactoring experiment on real Java code.

Duplication for the Removal of Duplication

A semantics-preserving code-motion refactoring transformation by Komondoor and Horwitz (KH) had been shown to be effective in the elimination of type-3 clones, partly thanks to its successful combination of statement reordering with duplication of predicates. According to a recent clone refactorability definition by Tsantalis, however, such a transformation is considered unacceptable whenever the given code fragments contain any statement that cannot be moved. We propose an adaptation of the KH transformation that yields refactorable results according to the definition of Tsantalis. An evaluation of this approach on real-world type-3 clones from the Java portion of the Tiarks benchmark produces promising results, demonstrating how code motion with the duplication of predicates forms an effective step towards the removal of duplication in source code.

Efficient method extraction for automatic elimination of type-3 clones

A semantics-preserving transformation by Komondoor and Horwitz has been shown to be most effective in the elimination of type-3 clones. The two original algorithms for realizing this transformation, however, are not as efficient as the related (slice-based) transformations. We present an asymptotically-faster algorithm that implements the same transformation via bidirectional reachability on a program dependence graph, and we prove its equivalence to the original formulation.