Refactoring

Refactoring
An Introduction

Prof. David Bernstein
James Madison University

Computer Science Department

bernstdh@jmu.edu

Getting Started

Refactoring Defined:
- Changing code without changing its external behavior
Purpose of Refactoring:
- Improve the structure, presentation, or performance of code (i.e., non-functional properties)

Before Refactoring Can/Should Occur

Existing Code:
- There must be existing code
Existing Tests:
- The only way to ensure that the behavior isn't changed is to have an existing test suite and perform regression testing

When is Refactoring Needed?

Duplication:
- Duplicate sequences of statements (suggesting the need for a loop, method/function, super class, etc...)
- Duplicate expressions (suggesting the need for a function/method)
- Duplicate manipulations or declarations of variables (suggesting the need for a collection or structure)
- Duplicate data (suggesting the need to combine/eliminate data structures)

When is Refactoring Needed? (cont.)

Lack of Clarity:
- Badly named variables, functions/methods, classes, etc...
- Awkward control structures
- Lack of comments
Other Defects (a.k.a. Code Smells):
- Comments that duplicate code
- Tight coupling
- Lack of information hiding
- Low cohesion
- Bloated (large) and/or lazy (small) classes
- Long methods

Examples of Refactorings to Improve Clarity

Introduce Explanatory (Intermediate) Variables:

Long expressions can be difficult to understand and debug


                                   // Original Code
        if ( 0 <= (b*b - 4*a*c)) { ... }

        // Refactored Code
        boolean hasRoots = ( 0 <= (b*b - 4*a*c));
        if (hasRoots) { ... }

Extract Sub-Program:
- Break a long program or a program that has multiple easily described steps into multiple sub-programs

The Refactoring Process

Test the existing code.
Identify a refactoring.
Make a small change that gets the code closer to the desired code.
Run regression tests and debug if necessary.
If the refactoring is not complete, go to step 3.
If the code needs further refactoring, go to step 2.

Other Kinds of Improvements (i.e., Functional Improvements)

Improved Ease of Use:
- Minor changes that make code easier to use (e.g., overloaded methods, convenience methods)
Generalization:
- Modifications that make the code applicable in a wider variety of situations (e.g., a wider range of parameter values, more types of parameters)
Increased Functionality:
- Adding capabilities (e.g., additional methods)