Refactoring is usually
motivated by noticing a code smell. For example the method at hand may
be very long, or it may be a near duplicate of another nearby method. Once
recognized, such problems can be addressed by refactoring the source code, or transforming it into a new form
that behaves the same as before but that no longer "smells". For a
long routine, one or more smaller subroutines can be extracted; or for
duplicate routines, the duplication can be removed and replaced with one shared
function. Failure to perform refactoring can result in accumulating technical
There are two general
categories of benefits to the activity of refactoring.
Maintainability. It is easier to fix bugs because the source code
is easy to read and the intent of its author is easy to grasp. This might be
achieved by reducing large monolithic routines into a set of individually
concise, well-named, single-purpose methods. It might be achieved by moving a method
to a more appropriate class, or by removing misleading comments.
Extensibility. It is easier to extend the capabilities of the
application if it uses recognizable design patterns, and it
provides some flexibility where none before may have existed.
Before applying a refactoring
to a section of code, a solid set of automatic unit tests is needed. The
tests are used to demonstrate that the behavior of the module is correct before
the refactoring. If it inadvertently turns out that a test fails, then it's
generally best to fix the test first, because otherwise it is hard to
distinguish between failures introduced by refactoring and failures that were
already there. After the refactoring, the tests are run again to verify the
refactoring didn't break the tests. Of course, the tests can never prove that
there are no bugs, but the important point is that this process can be
cost-effective: good unit tests can catch enough errors to make them worthwhile
and to make refactoring safe enough.
The process is then an
iterative cycle of making a small program transformation, testing it to
ensure correctness, and making another small transformation. If at any point a
test fails, the last small change is undone and repeated in a different way.
Through many small steps the program moves from where it was to where you want
it to be. For this very iterative process to be practical, the tests must run
very quickly, or the programmer would have to spend a large fraction of his or
her time waiting for the tests to finish. Proponents of extreme programming
and other agile methodologies describe this activity as an integral part
of the software development cycle.
Techniques that allow for more abstraction
o Encapsulate Field – force code to access the
field with getter and setter methods
o Generalize Type – create more general types
to allow for more code sharing
o Replace type-checking code
o Replace conditional with polymorphism
Techniques for breaking code apart into more logical pieces
o Componentization breaks code
down into reusable semantic units that present clear, well-
o Extract Class moves part of the code from an existing class
into a new class.
o Extract Method, to turn part
of a larger method into a new method. By breaking down code in smaller
pieces, it is more easily understandable. This is also applicable to functions.
Techniques for improving names and location of code
o Move Method or Move Field –
move to a more appropriate Class or source file
Method or Rename Field – changing the name into a new one that better
reveals its purpose
o Pull Up – in OOP, move to a superclass o Push Down – in OOP, move to a subclass