Refactoring: Improving the design of existing code

Refactoring
Improving the design of existing code
By Deepak Mehra & Mayank Bairagi
1

Agenda
● What is Refactoring ?
● Why Should You Refactor?
● When Should You Refactor?
● Why Refactoring Works?
● Process of Refactoring
● Bad smells in code
● Examples of Refactoring
2

What is Refactoring?
a change made to the internal structure of software to
make it easier to understand and cheaper to modify
without changing its observable behavior.
4

Why Should You Refactor?
★ Refactoring Improves the Design of Software.
6

★ Refactoring Makes Software Easier to Understand.
7

early refactorings is like wiping the dirt off a window so you can see beyond.
-Ralph Johnson
8

★ Refactoring Makes Software Easier to Understand.
★ Refactoring Helps You Program Faster.
9

When Should You Refactor?
★ Refactor When You Add Function
★ Refactor When You Need to Fix a Bug
★ Refactor As You Do a Code Review
10

Why Refactoring Works
Refactoring emphasize on what program can do for you tomorrow.
11

Programs, which are hard to work with
★ Programs that are hard to read are hard to modify.
★ Programs that have duplicated logic are hard to modify.
★ Programs that require additional behavior that requires you to change
running code are hard to modify.
★ Programs with complex conditional logic are hard to modif
12

Clutter Code
Anything in your code that doesn't add value
14

What Do I Tell My Manager?
Don't Tell
16

Process of Refactoring
● Detect a problem
Is there a problem? What is the problem?
● Characterise the problem
Why is it necessary to change something? What are the benefits? Are
there any risks?
● Design a solution
What should be the "goal state" of the code? Which code
transformation(s) will move the code towards the desired state?
● Modify the code
Steps that will carry out the code transformation(s) that leave the code
functioning the same way as it did before.
17

Bad smells in code
● Duplicated code
● Long method
● Large Class
● Long Parameter List
● Lazy Class
18

Examples of Refactoring
● Rename
Methods, variables, classes or other java items. Changing the name of
a Java item to make it less confusing and misleading.
● Move Class
Moving a class into a package where it would fit better. All import
statements should refer to the given class.
● Extract Method
Break up long methods to improve readability and maintainability.
Replace a section of code that accomplishes a single task with a new
method with a descriptive name. This will also allow methods to be
reused for a specific function.
19

● Inline Method
A method’s body is just as clear as its name. Put the method’s body
into the body of its callers and remove the method.
20

● Remove Assignments to Parameters
The code assigns to a parameter. Use a temporary variable instead.
● Extract Class
You have one class doing work that should be done by two. Create a
new class and move the relevant fields and methods from the old class
into the new class.
21

● Introduce Local Extension
A server class you are using needs several additional methods, but you
can't modify the class. Create a new class that contains these extra
methods. Make this extension class a subclass or a wrapper of the
original.
So the idea is, If want to add features to a library what you would do?
If you can modify the source that’s the best thing, If you cannot modify the
source then you can always add in a wrapper to it.
22

● Replace array with Object
You have an array in which certain elements mean different things.
Replace the array with an object that has a field for each element.
String[] row = new String[3];
row[0] = “Liverpool”;
row[1] = “15”;
Instead
Team team = new Team();
team.setName(“Liverpool”);
team.setWins(“15”);
23

● Replace Magic Number with Symbolic Constant
You have a literal number with a particular meaning. 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;
24

● Decompose Conditional
You have a complicated conditional (if-then-else) statement.
Extract methods from the condition, then part, and else parts.
if (date.before (SUMMER_START) || date.after(SUMMER_END))
charge = quantity * _winterRate + _winterServiceCharge;
else charge = quantity * _summerRate;
Refactored to
if (notSummer(date))
charge = winterCharge(quantity);
else charge = summerCharge (quantity);
25

● Remove setting method
A field should be set at creation time and never altered. Remove any
setting method for that field.
26

● Replace error code with exception
A method returns a special code to indicate an error.
int withdraw(int amount) {
if (amount > _balance)
return -1;
else {
_balance -= amount;
return 0;
}
}
27

● Replace error code with exception
A method returns a special code to indicate an error.
void withdraw(int amount) throws BalanceException {
if (amount > _balance) throw new BalanceException();
_balance -= amount;
}
28

When we should not Refactor?
● There are times when existing code is such a mess that although you
could refactor it, it would be easier to start from the beginning.
● The other time you should avoid refactoring is, when you are close to a
deadline. At that point the productivity gain from refactoring would
appear after the deadline and thus be too late.
29

References
● https://www.slideshare.net/redigon/refactoring-1658371
● Book by Martin Fowler on Refactoring
30

Refactoring: Improving the design of existing code

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Refactoring: Improving the design of existing code

Similar a Refactoring: Improving the design of existing code (20)

Más de Knoldus Inc.

Más de Knoldus Inc. (20)

Último

Último (20)

Refactoring: Improving the design of existing code

Notas del editor