The$credit$for$crea-ng$these$slides$belongs$to$ Fall$2014$CS$521/621$students.$$Student$names$ have$been$removed$per$ferpa$regula-ons.

Transcription

1 The$credit$for$crea-ng$these$slides$belongs$to$ Fall$2014$CS$521/621$students.$$Student$names$ have$been$removed$per$ferpa$regula-ons.$

2 Refactoring With Synthesis

3 Refactoring and Synthesis Refactoring - restructuring existing code without changing the behavior of the code Synthesis - combining two different things to form one Code Synthesis - have software complete a piece of the code for you. Combines manually written and computer generated code for a finished product.

4 Motivation Refactoring is a key part to software engineering and agile software development techniques. It was conceived as a manual activity but soon tools have become available to help automate refactorings.

5 Motivation Tools are available to help with refactorings, but 90% are still done manually. Poor discoverability. A developer must know the refactoring by name and select it from a menu/use a known keyboard shortcut. Complex user interface for some refactorings.

6 Research Questions 1. Could a unified interface be devised that simplified the usage of automatic refactoring tools for complex refactorings? 2. Given such a tool, would developers choose to use it over performing the refactorings manually?

7 Contributions 1. A new technique, based on extending a small set of manual changes, implemented in a tool called RESYNTH 2. A user study of RESYNTH to determine its usefulness to experienced and inexperienced programmers

8 Proposed Simpler Interface 1. Press a Start Refactoring button, indicating the program whose semantics should be preserved. 2. Manually perform a few actions of the desired refactoring, resulting in another program. 3. Click a Complete button. The tool will attempt to find a sequence of refactorings from the initial program, that when applied includes the edits made in step 2.

9 Advantages of This Interface Developer doesn t have to remember menu items or keyboard shortcuts Adding a new refactoring doesn t clutter the refactoring interface Applying a sequence of refactorings becomes easier - the tool discovers the sequence for the developer Performing a set of related refactorings is easier - they can be done as a unit

10 RESYNTH 1. Program entities not edited by the user are discarded - narrows the search space 2. A* search is performed over this smaller search space to find refactoring sequences 3. Attempts to execute discovered sequences of refactorings on the entire program

11 RESYNTH The manual changes are compared to the initial program to determine a small set of desired edits (stored as a tree) Local versions of each refactoring are performed on the modified areas of the original program, generating successors A* search is used to navigate this space, finding a set of local refactorings that produce the edits

12 RESYNTH Once the desired edits are found through local refactorings, attempt to apply the full versions to the entire program If the full refactorings generate errors, continue searching Otherwise, report the refactorings to the user

13 Examples - Single Refactorings Rename - A method, field, or local variable can be renamed by editing its declaration or any reference to use the new name Initial: int x = 0; x += 5; return x; Manual Edit: int x = 0; y += 5; return x; Result: int y = 0; y += 5; return y; RESYNTH finds Rename accomplishes the local edit, applies it globally.

14 Examples - Single Refactorings Inline Local - Deleting a local variable declaration will cause its value to be inlined Initial: int x = getvalue(); return x; Manual Edit: int x = getvalue(); return x; Result: return getvalue(); RESYNTH finds Inline Local accomplishes the local edit, applies it globally.

15 Examples - Complex Refactoring Swap Fields - Switching the names of two fields will cause the appropriate renames Initial: int x = 5; int y = 15; x += 3; y *= 10; return x / y; Manual Edit: int x = 5; int y = 15; x += 3; y *= 10; return y / x; Result: int y = 5; int x = 15; y += 3; x *= 10; return y / x; RESYNTH finds three uses of Rename accomplish local edits, applies them globally. This requires Rename(x, tmp), Rename(y, x), Rename(tmp, y)

16 Adding Refactorings to RESYNTH For RESYNTH to use a refactoring tool, it must be modified to include a successors function successors takes a current program state as input and returns a finite set of possible successors after applying the refactoring locally These successors are added to the A* search space

17 Evaluation - Single Refactorings RESYNTH includes implementations of 5 common refactorings that are frequently used. Rename Inline Local Inline Method Extract Local Extract Method With Holes

18 Evaluation - Complex Refactorings These complex refactorings can be accomplished using a sequence of the single refactorings that were implemented

19 Evaluation - Timing Benchmarks Search space was limited to 20,000 trees Synthetic examples were more challenging on average than real examples In both, the time to search for a refactoring + the time for Eclipse to apply the full refactoring was relatively low

20 Evaluation - User Study 6 participants were asked to complete 3 refactoring tasks using RESYNTH, Eclipse s built in refactorings, or manual editing. In one task RESYNTH cannot come up with the correct solution. Only 2 noticed that the solution given was not exactly the expected solution 4 of the participants found the tool useful

21 Discussion 1. Previous work found that most refactorings are performed by hand?. Do you use built in refactoring tools when programming, or prefer to do the edits yourself? Why??: Negara, S., Chen, N., Vakilian, M.m Johnson, R. E., and Dig, D. A Comparative Study of Manual and Automated Refactorings. In ECOOP (2013)

22 Discussion 2. The group used to evaluate RESYNTH was extremely small and only ⅔ of the participants found it useful. Would you consider these results to be positive? How could RESYNTH be improved to be more useful?

23 Discussion 3. Some of the users forgot to activate RESYNTH when they wanted to mark an edit. Do you think RESYNTH could benefit from speculative analysis to infer when a user was performing a refactoring? What could the pros and cons be?

24 Discussion 4. Can you think of any other applications of the search technique implemented in RESYNTH? Debugging?

25 Discussion 5. RESYNTH uses an A* search in its implementation. How would you expect the average timing and deviation of times needed to come up with a solution to differ if the implementation used a breadth first or depth first search?

26 Discussion 6. RESYNTH may potentially fail to find a refactoring if the user does not do a correct manual edit. Does this seem like a major flaw? How could it be corrected?