About Me – Frank Xu• Education

▫ North Dakota State University Ph.D. in Software Engineering

▫ Towson University MS in Computer Science

▫ Southeast Missouri State University BS in Computer Science, Minor in Math

• Working Experience▫ GE Transportation, 2008- present,

Consultant▫ Gannon University, 2008- present

Director of Keystone Software Development Institute, Assistant Professor of SE▫ University VA –Wise, 2007- 2008

Assistant Professor of Software Engineering▫ Swanson Health Products, MIS department, 2005 ~ 2007

Sr. Programmer Analyst ▫ Volt Information Science Inc., 2004 ~ 2005

Software Engineer

Refactoring- A disciplined approach to rework for better design.

Objectives•What is refactoring?•Why should I refactor? •When should I refactor?•How to refactor?

Definition•Refactoring is a disciplined technique for

restructuring an existing body of code, ▫altering its internal structure ▫without changing its external behavior.

• It makes the software easier to understand and cheaper to modify.

A simple example•Example: compute gravitational potential energy

▫PEgrav = mass * g * height

double potentialEnergy(double mass, double height) { return mass * height * 9.81; }

static final double GRAVITATIONAL_CONSTANT = 9.81;

double potentialEnergy(double mass, double height) { return mass * height * GRAVITATIONAL_CONSTANT; }

Magic number

assertEquals(9.81, new RefactoringDemo().potentialEnergy(1,1),0.0);

Properties of refactoring

•One step at a time

•Preserve correctness

•Frequent testing

Why refactor?• Improves the design of software.

▫Without refactoring, the design of the program will decay

•Makes software easier to understand.▫A good design is easy to understand

•Helps you find bugs.▫The clarification process helps find bugs

•Helps you program faster.▫Poor design slow you down

When to Refactor? •As you develop

▫Example: change a variable name to something more meaningful.

•Before adding functions.▫Sometimes the existing design does not allow you to easily

add the feature.•When you need to fix a bug

▫The bug exists because the code was not clear enough for you to see the bug in the first place.

•When you do a code review▫Code reviews help spread knowledge through the

development team.▫Works best with small review groups

Steps to refactoring

•Identifying bad smells of code▫a “bad smell” = a warning sign in the code▫e.g., time consuming code

•Designing solid tests ▫for the section of code under analysis.

•Refactoring the code ▫based on the type of the smell

•Applying tests.

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

Bad smells in code•Smells within classes

▫Duplicated code▫Long method▫Large class▫…

•Smells between classes▫Primitive obsession ▫ Inappropriate intimacy▫Middle man▫…

Duplicated Code – (1)•“The #1 bad smell”

▫Copy & paste▫What if duplicates changes

•Refactoring solutions ▫Pull up a field▫Form a template method▫Substitute algorithm

Duplicated Code – (2)• Bad Smell

▫ Two subclasses have the same field.• Refactoring

▫ Pull up a field: Move the field to the superclass.

Salesman Engineer

Employee

name name

Duplicated Code – (3)•Bad Smell

▫You have two methods in subclasses that perform similar steps in the same order, yet the steps are different.

•Refactoring: Form a template method▫Get the steps into methods with the same

signature, so that the original methods become the same. Then you can pull them up.

Duplicated Code – (4)

PersonalCustomer

CorporateCustomer

Customer

getBillableAmt() getBillableAmt()

double base=unit*ratedouble tax=base*Site.TAX_RATE;return base+tax

double base=unit*rate*0.5double tax=base*Site.TAX_RATE*0.2;return base+tax

getBaseAmt()getTaxAmt()

getBaseAmt()getTaxAmt()

return getBaseAmt()+getTaxAmt()

getBaseAmt()getTaxAmt()

Duplicated Code – (5)• Bad smell

▫ Similar logic• Refactoring: Substitute algorithm

▫ Replace the body of the method with the new algorithm.

duplications

Long Method – (1)•The longer the method the harder it is to see what

it’s doing. ▫Poorly thought out abstractions and boundaries

•Refactoring solutions▫Extract method▫Replace temp with query▫ Introduce parameter object▫Preserve whole object

Long Method – (2)•Extract method

▫ break up into smaller private methods within the class

• Example

private void m1(){Statement 1;..Statement 9;}

private void m2(){Statement 10;..Statement 19;}

private void m3(){Statement 20;..Statement 30;}

public void methodA(){

}

public void methodA(){

Statement 1;Statement 2;..Statement 30;} m1();

m2();m3();

Long Method – (3)• Bad smell

▫using a temporary variable to hold the result of an expression.

▫Refactoring: Replace temp with query ▫Extract the expression into a

method.

if (basePrice() > 1000) { return basePrice() * 0.95;} else { return basePrice() * 0.98; }//any side effects?

Temp variable expression

double basePrice=basePrice();if (basePrice > 1000) { return basePrice * 0.95;} else { return basePrice * 0.98; }

Long Method – (4)•Smell: a method with a long list of parameters

▫A group of parameters that naturally go together.•Refactoring: Introduce parameter object

▫Replace them with the object.

amountInvoicedIn ( )amountReceivedIn ( )amountOverdueIn ( )

Customer start: Dateend: Date

DateRangeDateRange

Start: Date, end: DateStart: Date, end: DateStart: Date, end: Date

DateRangeDateRange

Long Method – (5)•Smell

▫You are getting several values from an object and passing these values as parameters in a method call.

•Refactoring: Preserve whole object▫Send the whole object instead.

Large Class – (1)•A class that is trying to do too much

▫Can usually be identified by looking at how many instance variables it has.

▫When a class has too many instance variables, duplicated code cannot be far behind.

•Refactoring solution▫Extract class▫Extract subclass

PhoneNumber

Large Class – (2)•Bad smell

▫Have one class doing work that should be done by two.•Refactoring: Extract class

▫Need create a new class and move the relevant fields and methods from the old class into the new class.

Customer

nameareaCodenumber

String: getPhoneNumber()

PhoneNumber: getPhoneNumber()

LaborItem

Large Class – (3)• Smell

▫ A class has features that are used only in some instances.▫Extract subclass

▫ Create a subclass for that subset of features.

JobItem

getTotalPrice()getUnitPrice()getEmployee()

Do all the JobItem objects need to have getEmployee

function?

getUnitPrice()

isLabor

Primitive Obsession – (1)•Over use primitive to represent data

▫All properties of a class are primitive types int, String, boolean, double, etc.

▫Primitive difficult to represent data money (which combines quantity and currency) a date range object

• Refactorings▫Replace data value with object ▫Replace type code with class

Primitive Obsession – (2)•Smell

▫You have a data item that needs additional data or behavior.

•Refactoring▫Turn the data item into an object.

Order

customer: String

Customer

id: Stringlast Name:: StringmiddleName: StringfirstName: Stringphone: PhoneNumber

Primitive Obsession – (3)•Smell

▫A class has a numeric type code that does not affect its behavior.

•Refactoring: Replace type code with class ▫Replace the number with a new class.

Person

O: intA: intB:intAB:int

BloodType

O: BloodTypeA: BloodTypeB: BloodTypeAB: BloodType

bloodType:int

public class Person{ …… int bloodType =BloodType.O; …….}

public class BloodType{ public static final int O 1; public static final int A 2; public static final int B 3; public static final int AB 4;}

public enum BloodType { O,A,B,AB}

Inappropriate Intimacy – (1)•Two classes are overly entertwined

▫Sharing of secrets between classes▫Leads to data coupling

•Refactorings▫Hide delegate▫Replace inheritance with delegation

What is problem? Change to Delegate will propagate to the

cleint

Inappropriate Intimacy – (2)•Motivation

▫A client is calling a delegate class of an object.•Refactoring: Hide delegate

▫Create methods on the server to hide the delegate.

Client Server

Delegate

taskA() taskA()

public void method(){ delegate.taskA();}

Client Delegate

taskA()

Inappropriate Intimacy – (3)

ClientClass

Employee

Department

getDepartment() getManager()

public class Department{ private Employee manager; …… public Department (Employee manager){ this.manager=manager; } public string getManager(){ return manager; } …..}

manager=john. Object need to know less about other parts of the

system

public getManager(){ return department.getManager();}

getManager()

getDepartment().

getManager();

Inappropriate Intimacy – (3)• Motivation

▫ A subclass uses only part of a superclasses interface or does not want to inherit data.

• Refactoring: Replace inheritance with delegation▫ Create a field for the superclass, adjust methods to delegate to the

superclass, and remove the subclassing.

Middle Man• Smell

• A method's body is just as clear as its name • Refactoring

▫ Put the method's body into the body of its callers and remove the method

int getRating() { return (moreThanFiveLateDeliveries()) ? 2 :

1; }

boolean moreThanFiveLateDeliveries() { return _numberOfLateDeliveries > 5;

}

int getRating() { return (_numberOfLateDeliveries > 5) ? 2 : 1;

}

Why might you still not refactor your programs?•You might not understand how to refactor.

• If the benefits are long-term, why exert the effort now? In the long term, you might not be with the project to reap the benefits!

•Refactoring code is an overhead activity; you're paid to write new features.

•Refactoring might break the existing program.

Summary•Refactoring is a disciplined approach to rework

for better design.•Refactor when code smells.•Take advantage of IDE (Eclipse/IntelliJ/ Java

Studio).•Check online resources for updated refactoring.•Know refactoring before your interview.

References•http://wiki.java.net/bin/view/People/Smells

ToRefactorings•https://netfiles.uiuc.edu/dig/RefactoringIn

fo/•http://www.refactoring.com/

Questions?