7 Refactoring

Refactoring
Improving the Design of Existing Code
Matthias Ringwald
Software Engineering Workshop,
December 5-6, 2005
What is Refactoring?
“Refactoring(noun): A change made to the internal

structure of a software to make it easier to
understand and cheaper to modify without
changing its observable behavior”
Martin Fowler, "Refactoring - Improving the design of existing code",

Addison Wesley, 1999.
Disclaimer: Most slides are derived from this book
December 5, 2005 Matthias Ringwald, Institut for Pervasive Computing, ETH Zurich, mringwal@inf.ethz.ch 2
Talk Overview
What is refactoring?
Why and when should you refactor?
Java refactorings in Eclipse
Advanced refactorings
Other languages & tools
Hints/Own Opinion/Take Home Message
Why should you Refactor?
Because Refactoring...
Improves the design of software
- the design of a program will decay over time
as people change code to realize short-term goal
Makes software easier to understand
- by refactoring, software gets cleaned up
Helps you to find bugs
- clarifying the structure exposes bugs
Helps you to program faster
- as a result from the previous three points
When to Refactor?
“If you do something similar the third time...”

When you add a feature
to understand the code or improve design
When you need to fix a bug
clear code => no bugs :)
As you do a code review
When you encounter a “bad smell”…
Bad Smells!
“Bad Smells” in code give a hint to refactor
Duplicate Code
The #1 bad smell !
Long Method
Large Class
…
Switch Statements ( … breed duplication … )
Comments ( … not bad by itself …. )
... many more ( 23 in total )
Java refactoring in Eclipse
DEMO
Refactoring Example
All refactorings are described in a template.
Collapse Hierarchy
Situation
A superclass and subclass are not very different
Plan
Merge them together
Motivation
[some explanation]
Refactoring Example: Collapse Hierachy (2)
Mechanics:
Choose which class is going to be removed:
superclass or subclasses
Use Pull Up Field and Pull Up Method or Push Down
Field and Push Down Method
Compile and test with each move
Adjust references to the class that will be removed to
use the merged class. This will affect variable
declaration, parameter types, and constructors
Remove empty class
Compile and test
Refactoring and Design Patterns
“Refactoring to Patterns” by Joshua Kerievsky,

Addison Wesley, 2005
Provides insights into the combination of
refactoring and design patterns
Watch out for design-pattern smells!
e.g. Singletonitis: “addiction to the Singleton pattern”
Refactorings can be used towards or away from
certain design patterns.
Move Embellishment to Decorator
Situation:
Code provides an embellishment to a class' core
responsibility.
Plan:
Move the embellishment code to a Decorator.
Motivation:
Adding features makes a class complicated over time.
Place each embellishment in its own class and let that
class wrap the type of the object it needs to embellish.
Move Embellishment to Decorator (2)
Hints
Automated tests are required

Refactoring is best done continuously
Trial & Error => Code & Refactor & Test
CVS does not support renaming, use SVN to
keep file history
Checking the long list of refactorings might help
once in a while
Other Languages & Tools
SmallTalk: The “Refactoring Browser”

C#: There are tools, too.
C/C++: SlickEdit IDE/Plug-In (300 USD)
Refactoring in C: rename {variables, functions},
extract function, modify parameter list
Scripting Languages?
List: www.refactoring.com/tools.html
Own Opinion
Most important software engineering technique

since Design Patterns
One of several Extreme Programming practices
that can stand out alone (like e.g. automatic
testing)
Got popular because of its inclusion into Eclipse
Take Home Message
No reason for not using it with Java

… and Eclipse is the tool for this
Even non-automatic refactorings will reduce
errors
After getting used to refactoring, check out
Kerievsky's book “Refactoring to patterns
Literature
www.refactoring.com
Martin Fowler's Site dedicated to Refactoring, more books there
Martin Fowler, "Refactoring - Improving the design of existing code",

Addison Wesley, 1999.
Must-read introduction.
Joshua Kerievsky, "Refactoring to Patterns", Addison Wesley, 2005.

Combines refactoring with design patterns by showing how
refactoring is used to change existing designs to, towards or away
from pattern implementation.
Why people hesitate
Conventional wisdom would discourage

modifying a design
You might break something in the code
You have to update the documentation
=> Both expensive
But, there are longer term concerns:
sticking with an inappropriate design
- Makes the code harder to change
- Makes the code harder to understand and maintain
- Very expensive in the long run
Bad Smells in Code
Duplicated Code. Lazy Class.

Long Method. Speculative Generality.
Large Class. Temporary Field.
Long Parameter List. Message Chains.
Divergent Change. Middle Man.
Shotgun Surgery. Inappropriate Intimacy.
Feature Envy. Alternative Classes with Different
Data Clumps. Interfaces.
Primitive Obsession. Incomplete Library Class.
Switch Statements. Data Class.
Parallel Inheritance Hierarchies. Refused Bequest.
Comments.
Advanced Refactorings
Composing Methods
Moving Features Between Objects
Organizing Data
Simplifying Conditional Expressions
Making Method Calls Simpler
Dealing with Generalization
Composing Methods
Extract Method.
Inline Method.
Inline Temp.
Replace Temp with Query.
Introduce Explaining Variable.
Split Temporary Variable.
Remove Assignments to Parameters.
Replace Method with Method Object.
Substitute Algorithm.
Moving Features Between Objects
Move Method.
Move Field.
Extract Class.
Inline Class.
Hide Delegate.
Remove Middle Man.
Introduce Foreign Method.
Introduce Local Extension.
Organizing Data
Self Encapsulate Field.

Replace Data Value with Object.
Change Value to Reference.
Change Reference to Value.
Replace Array with Object.
Duplicate Observed Data.
Change Unidirectional Association to Bidirectional.
Change Bidirectional Association to Unidirectional.
Organizing Data (2)
Replace Magic Number with Symbolic Constant.

Encapsulate Field.
Encapsulate Collection.
Replace Record with Data Class.
Replace Type Code with Class.
Replace Type Code with Subclasses.
Replace Type Code with State/Strategy.
Replace Subclass with Fields.
Simplifying Conditional Expressions
Decompose Conditional.
Consolidate Conditional Expression.
Consolidate Duplicate Conditional Fragments.
Remove Control Flag.
Replace Nested Conditional with Guard
Clauses.
Replace Conditional with Polymorphism.
Introduce Null Object.
Introduce Assertion.
Making Method Calls Simpler
Rename Method.
Add Parameter.
Remove Parameter.
Separate Query from Modifier.
Parameterize Method.
Replace Parameter with Explicit Methods.
Preserve Whole Object.
Replace Parameter with Method.
Making Method Calls Simpler (2)
Introduce Parameter Object.

Remove Setting Method.
Hide Method.
Replace Constructor with Factory Method.
Encapsulate Downcast.
Replace Error Code with Exception.
Replace Exception with Test.
11. Dealing with Generalization
Pull Up Field.
Pull Up Method.
Pull Up Constructor Body.
Push Down Method.
Push Down Field.
Extract Subclass.
Extract Superclass.
11. Deal with Generalization (2)
Extract Interface.
Collapse Hierarchy.
Form Template Method.
Replace Inheritance with Delegation.
Replace Delegation with Inheritance.

7 Refactoring

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

7 Refactoring

Uploaded by

Copyright:

Available Formats

Refactoring

Improving the Design of Existing Code

“Refactoring(noun): A change made to the internal

Martin Fowler, "Refactoring - Improving the design of existing code",

Disclaimer: Most slides are derived from this book

 “If you do something similar the third time...”

“Bad Smells” in code give a hint to refactor

 All refactorings are described in a template.

 “Refactoring to Patterns” by Joshua Kerievsky,

 Automated tests are required

 SmallTalk: The “Refactoring Browser”

 Most important software engineering technique

 No reason for not using it with Java

 Martin Fowler, "Refactoring - Improving the design of existing code",

 Joshua Kerievsky, "Refactoring to Patterns", Addison Wesley, 2005.

refactoring is used to change existing designs to, towards or away

from pattern implementation.

 Conventional wisdom would discourage

 Duplicated Code.  Lazy Class.

 Self Encapsulate Field.

 Replace Magic Number with Symbolic Constant.

 Introduce Parameter Object.

You might also like

“If you do something similar the third time...”

All refactorings are described in a template.

“Refactoring to Patterns” by Joshua Kerievsky,

Automated tests are required

SmallTalk: The “Refactoring Browser”

Most important software engineering technique

No reason for not using it with Java

Martin Fowler, "Refactoring - Improving the design of existing code",

Joshua Kerievsky, "Refactoring to Patterns", Addison Wesley, 2005.

Conventional wisdom would discourage

Duplicated Code. Lazy Class.

Self Encapsulate Field.

Replace Magic Number with Symbolic Constant.

Introduce Parameter Object.