Refactoring

REFACTORING
XP Injection
http://xpinjection.com

Do You Know Your Code?

Developer Golden Rule
Any fool can write code that a computer can understand

Good Developer Golden Rule
Any fool can write code that a computer can understand
Good programmers write code that humans can understand

Why Fix What is Not Broken?

If the Code is Hard to Understand
Hard to maintain
Hard to improve
Hard to work with evolutionary design
More expensive

What is Refactoring?
A series of small steps, each of which changes the program’s internal structure without changing its external behavior - Martin Fowler
Verify no change in external behavior by
Testing
Using the right tool (IDE)
Formal code analysis by tool
Code review or pair programming
Being very, very careful

Prerequisites for Success
Safety net
Everybody agreed “Collective code ownership”
Common understanding of refactoring methods
Supportive environment
Powerful IDE

Refactoring Cycle
Find smell
Select
refactoring
Apply
refactoring
Run
all tests

3 Ways to Start

Find Something to Improve

Make Static Analysis

Find Smell

How to Find Smell

Smells

Main Goals
Organizing data
Composing methods
Making methods calls simpler
Moving features between objects
Simplifying conditional expression
Dealing with generalizations

Operations Associated with Refactoring
Replace
Extract
Move
Change
Introduce
Remove
Pull
Consolidate
Push
Inline
Add

When to Refactor?
When add new functionality
Refactor existing code until you understand it
Refactor the design to make it simple to add
When try to find bugs
Refactor to understand the code
During code reviews
Immediate effect of code review
Allows for higher level suggestions

Key Elementsof Refactoring
Simplifying complex statements
Abstracting common solutions into reusable code
Removal of duplicate code

Refactoring Techniques

6 Techniques in Action

Extract Method
void printOwing() {
printBanner();
//print details
System.out.println("name: " + _name);
System.out.println("amount " + getOutstanding());
}
void printOwing() {
printBanner();
printDetails(getOutstanding());
}
void printDetails (double outstanding) {
System.out.println("name: " + name);
System.out.println("amount " + outstanding);
}

Extract Super Class

Decompose Conditional
if (date.before (SUMMER_START) ||
date.after(SUMMER_END)) {
charge = quantity * winterRate+ serviceCharge;
} else {
charge = quantity * summerRate;
}
if (notSummer(date)) {
charge = winterCharge(quantity);
} else {
charge = summerCharge (quantity);
}

Replace Error Code with Exception
boolean withdraw(int amount) {
if (amount > balance)
return false;
else {
balance -= amount;
return true;
}
}
void withdraw(int amount) throws BalanceException {
if (amount > balance) throw new BalanceException();
balance -= amount;
}

Replace Exception with Test
double getValueForPeriod (int period) {
try {
return values[period];
} catch (ArrayIndexOutOfBoundsException e) {
return 0;
}
}
double getValueForPeriod (int period) {
return period >= values.length ? 0 : values[period];
}

Parameterize Method

Good Design Principles
DRY
KISS
YAGNI

No Silver Bullet
Needs lots of practice
Requires discipline
Continuous usage
Little steps

Little steps – huge results

You Need to Pay Technical Debt

Refactoring Benefits
More readable code
Easier maintenance
Code reuse
Easier to add new code
Improved design
Better understanding
Speeding knowledge
Easier to test
Minimize duplication

Live Demo

Questions?

Refactoring

by Mikalai Alimenkou on Aug 28, 2011

Accessibility

Categories

Tags

Upload Details

Usage Rights

1 Embed 885

Statistics

Refactoring — Presentation Transcript