Yishai A. Feldman

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.

Detecting refactored clones

The availability of automated refactoring tools in modern development environments allows programmers to refactor their code with ease. Such tools, however, enable developers to inadvertently create code clones that quickly diverge in form but not in meaning. Furthermore, in the hands of those looking to confuse plagiarism-detection tools, automated refactoring may be abused to avoid discovery of copied code. We present Cider, an algorithm that can detect code clones regardless of various refactorings that may have been applied to some of the copies but not to others. Most significant is the ability to discover interprocedural clones, where parts of one copy have been extracted to separate methods. We evaluated Cider on several open-source Java projects, attempting to detect interprocedural clones between successive versions of each project. Interprocedural clones were detected in all evaluated projects, demonstrating the pervasive nature of the problem. Compared to a manual assessment, Cider performed well in terms of both recall and precision.

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.

Where is the business logic

One of the challenges in maintaining legacy systems is to be able to locate business logic in the code, and isolate it for different purposes, including implementing requested changes, refactoring, eliminating duplication, unit testing, and extracting business logic into a rule engine. Our new idea is an iterative method to identify the business logic in the code and visualize this information to gain better understanding of the logic distribution in the code, as well as developing a domain-specific business vocabulary. This new method combines and extends several existing technologies, including search, aggregation, and visualization. We evaluated the visualization method on a large-scale application and found that it yields useful results, provided an appropriate vocabulary is available.

Code-motion for API migration: fixing SQL injection vulnerabilities in Java

Refactoring often requires the reordering of code fragments; such is the case when migrating from one API to another. Performing such reordering manually is complex and error-prone. A specific example in the security domain involves database query execution, in which some of the parameters come from untrusted sources. In Java, the Statement API provides opportunities for SQL injection attacks. The recommended remedy is to replace it with the secure Prepared-Statement API; however, that sometimes requires changing the order in which the query is built. We present an algorithm that performs this migration, moving code as necessary to preserve functionality while changing the structure of the original code as little as possible.

A Parallel On-Demand Algorithm for Computing Interprocedural Dominators

We present a new algorithm for computing interprocedural dominators. The algorithm identifies a set of special nodes, which are the only ones that can have interprocedural dominance edges, and extends the intraprocedural dominator trees by deriving those edges. The computation of the dominators of each node is independent of the computation of any other node, and therefore can be done on demand for each node as required. For the same reason, the algorithm lends itself naturally to parallelization. The algorithm has been implemented, and is shown to be practical for large programs. Because of its cooperative caching behavior, the algorithm gains a large performance boost when running on parallel hardware. We also present an efficient way of extending the algorithm for computing interprocedural dominance frontiers and control dependence.

Automatic recovery of statecharts from procedural code

We have developed a static-analysis algorithm that extracts statecharts from procedural implementations of state machines. The extracted statecharts are semantically-equivalent to the original program, and can be used for further development instead of the procedural code. We have implemented this algorithm in a tool called StatRec. We report on the results of running StatRec on a number of examples, including an implementation of the TCP protocol.

A screen-oriented representation for mobile applications

Program analysis plays an important role in a variety of software engineering processes, such as automated code refactoring, compiler optimizations, and program slicing. The internal program representation used by the program analysis algorithm affects the power and efficiency of the analysis. In particular, representations that contain data-flow information alongside control flow are known to be especially useful. While there are many popular internal program representations with data-flow information for traditional languages and platforms, few specifically target mobile applications. In this paper, we propose a new data-flow-enabled representation that addresses the screen-oriented nature of a mobile application and explores its potential. We consider a mobile application to be a reactive system whose states are the screens, and whose events are user actions, incoming communication, or anything else that causes transition from one screen to another. The resulting representation is a finite state machine extended with data-flow information. We suggest that this representation can greatly contribute to optimization, refactoring, and understanding of mobile applications.

Refactoring of statecharts

Statecharts are an important tool for specifying the behavior of reactive systems, and development tools can automatically generate object-oriented code from them. As the system is refactored, it is necessary to modify the associated statecharts as well, performing operations such as grouping or ungrouping states, extracting part of a statechart into a separate class, and merging states and transitions. Refactoring tools embedded in object-oriented development environments are making it much easier for developers to modify their programs. However, tool support for refactoring statecharts does not yet exist. As a result, developers avoid making certain changes that are too difficult to perform manually, even though design quality deteriorates. Methodologically, statecharts were meant to enable a systems engineer to describe a complete system, which would then be refined into a concrete implementation (object-oriented or other). This process is not supported by object-oriented development environments, which force each statechart to be specified as part of a class. Automated tool support for refactoring statecharts will also make this kind of refinement possible. This paper describes a case study that shows the usefulness of refactoring support for statecharts, and presents an initial catalog of relevant refactorings. We show that a top-down refinement process helps identify the tasks and classes in a natural way.