REFACTORING

Improving the Design of Existing Code

Atakan Şimşek e1298306

Outline Definition of Refactoring Why&When Refactor? Refactoring Steps Refactoring Examples Bad Smells

Definiton Solution

Conclusion

Definition

Refactoring (noun):

Improving the design of existing code

without changing the code's observable

behavior.

Some Definitions [Fowler] a change made to the

internal structure of software to make it easier to understand cheaper to modifywithout changing its observable behavior

[Beck] Improving the design after it has been written.

Why Refactor ?

Easier to understand It becomes easy for others to understand.

To find the bugs Finding the Bugs in the program.

To reduce Software maintenance costs

To faciliate Future changes

To program faster Code complexity tends to increase

rapidly over time(Patching new functionalities)

Development slows down

Refactoring helps keeping complexity under control

Development proceed more rapidly

When to Refactor ? When you add a function

Helps you to understand the code when modifying.

Sometimes the existing design does not allow you to easily add the feature.

When you need to fix a bug If it is difficult to trace an error:

Code was not clear enough for you to see the bug in the first place.

When you do a Code Review

When you detect a “bad smell” (an indication that something is wrong) in the code

Refactor? or NOT?

Code does not work : NOT

Code has some bugs : REFACTOR

Very Close to Deadline : NOT

There are bad smells : REFACTOR

Bad Smells

Bad smell Proposed refactoring

Duplicated Code Extract Class

Long Method Extract Method

Large Class Extract SubclassExtract Interface

Long Parameter List Replace Parameter with Method

Lazy Class Inline Class

Where Can We Use?

COSE

Producer Side

Consumer Side

Conditions of Refactoring Refactoring implies working

incrementally Making changes to the program in

small steps In between run the unit tests

regularly

If you make a mistake it's easy to back out.

Steps to Refactoring Analysis, helps to identify the code

Identify problems in code by review using bad smells of code

Introduce a refactoring

Test

Refactorings Add Parameter Change Association Reference to value Value to reference Collapse hierarchy Consolidate

conditionals Procedures to objects Decompose

conditional Encapsulate collection Encapsulate downcast Encapsulate field Extract class

Extract Interface Extract method Extract subclass Extract superclass Form template method Hide delegate Hide method Inline class Inline temp Introduce assertion Introduce explain

variable Introduce foreign method

Refactoring examples

Change Association Encapsulate Field Replace Number with Constants Compose Conditions Extract Class

Bi-directional Association to Unidirectional

We have a two-way association but one class no longer needs features from the other.

Self Encapsulate Field Create getting and setting methods for the

field and use only those to access the field.

private int _low, _high;boolean includes (int arg) {

return arg >= _low && arg <= _high;

}

private int _low, _high;boolean includes (int arg){

return arg >= getLow() && arg <= getHigh();

}int getLow() {return _low;}int getHigh() {return _high;}

Replace Magic Number with Symbolic Constant Create a constant, name it after the meaning,

and replace the number with it.

double potentialEnergy(double mass, double height) {

return mass * 9.81 * height;}

double potentialEnergy(double mass, double height) {

return mass * GRAVITATIONAL_CONSTANT * height;}static final double GRAVITATIONAL_CONSTANT = 9.81;

Consolidate conditionals

When we have a complicated conditional (if-then-else) statement.

double disabilityAmount()

{

if (_seniority < 2) return 0;

if (_monthsDisabled > 12)

return 0;

if (_isPartTime) return 0

// compute the disability amount

double disabilityAmount()

{

if (isNotEligableForDisability())

return 0;

// compute the disability

amount

Extract ClassYou have one class doing work that should

be done by two. Create a new class and move the relevant fields

Bad Smells in Code Duplicated Code Long Method Large Class Long Parameter

List Divergent Change Shotgun Surgery Feature Envy Data Clumps Primitive Obsession Switch Statements

Parallel Interface Hierarchies Lazy Class Speculative Generality Temporary Field Message Chains Middle Man Inappropriate Intimacy Incomplete Library Class Data Class Refused Bequest

Few solutions to Bad Smells

Duplicated Code: If you see the same code structure in

more than one place

Duplicated Code(cont.) Bugs copied as well Increase maintenance cost

solution: perform EXTRACT METHOD and invoke the code from both places.

Long Parameter ListAn object invokes a method, then passes the result as a parameter for a method.

solution: Use REPLACE PARAMETER with METHOD Remove the parameter and let the

receiver invoke the same method with sender.

Long Method

The longer a procedure is the more difficult it is to understand.

solution: perform EXTRACT METHOD

Conclusion:

Refactoring is useful to any program that has at least one of the following shortcomings:

Programs that are hard to read Programs that have bad smells Programs that require additional

behavior

References:

More Information can be found http://www.refactoring.com/

http://www.refactoring.be/

Refactoring: Improving the Design of Existing Code By Martin Fowler