About Me – Frank Xu
Post on 25-Feb-2016
46 Views
Preview:
DESCRIPTION
Transcript
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?
top related