Anand Bait

Developer

Allerin Tech Pvt Ltd

Refactoring Code

Making code better, may not be faster

Better structured, better built

More readable, more understandable

Easy to work with

Easy to add new features

Easy to spot and fix bugs

Keeping code in control

Improving existing code

Contents Introduction to Refactoring

Method-Level Refactoring

Class and Condition Focused Refactoring

Data Focused Refactoring

Communication and High Level Refactoring

Conclusion

What ‘REFACTORING’ is? Techniques of improving code that already exists

No rules that anyone can blindly follow to improve code

Techniques of recognize issues as per consciousness

Applied without thinking will be dangerous

What ‘REFACTORING’ is NOT? Not debugging

Not adding feature

Not changing observable behavior of code

Not performance improving

Why to use?

When to use? Write – Scan – Refactor at the end : INCORRECT

Write – Scan – Refactor regularly : CORRECT

Code reviews

How to use?

Code smell Duplicated code

Long methods

Comments

Doesn’t tell what to do but tells us what to notice

Method Level Refactoring Preparing to refactor

Grouping refactorings together

Using the Extract Method refactoring

Extract Method with parameters and variables

Common code smells for Extract Method

Using IDEs for the Extract Method refactoring

The Inline Method refactoring

Refactorings that remove temps

Refactorings that add temps

Preparing to refactor Requirement of automated testing vs manual testing

Grouping refactorings together Individual Method(name? parameters? Temp

variables? Duplicate? Too much in method?)

Context of method in class (right class? similarity with other methods class)

Communication between classes(inheritance)

Extract Method refactoring Smaller and specific is better

Provides reusability

Ease of overriding while using inheritance

Extract Method with parameters

Parameters should be related to the method

Extract Method with variables Temporary variables can be extracted

Code smells for using Extract Method Long method

Comments(having comments vs need comments)

Inline Method refactoring Removing method that adds no value

Refactoring to remove temps Increase temptation to write longer methods

Change temps to small methods

Refactoring to add temps Split temporary variables

Introduce explaining variables

Remove assignments to parameters

Split temporary variables Don’t use same temporary variable for different

purposes

Introduce explaining variables To improve readability

Introduce when a small method may not be required

Remove assignments to parameters

Add temporary variables that assigns value to parameters may give undesired results

Class and Condition Focused Refactoring Move Method

Extract Class and Inline Class

Making conditions easier to read

Replacing conditions with polymorphism

Replacing type code with subclasses

Move Method Move method from one class to another

When a method interact with multiple classes then move it to the class with which it interacts more

Code smell: feature envy, inappropriate intimacy, shotgun surgery

Extract Class and Inline Class Code smell: Large class

Making conditions easier to read Decompose conditionals

Consolidate conditionals

Consolidate duplicate conditionals

Replacing conditions with polymorphism

Conditions to check custom behavior

Replacing type code with subclasses Data can be categorized into subclasses

Data Focused Refactoring Moving and encapsulating fields

Working with data clumps

Simplifying method calls and parameter use

Pulling and pushing methods and fields

Moving and encapsulating fields If a field is more related and being used by the other

class

Working with data clumps Preserve whole object

(instead of parameters pass object)

Introduce parameter object

(minimize parameters list by creating a class for set of parameters)

Simplifying method calls and parameter use Rename method

Remove parameter

Add parameter

Parameterize method

(same behavior multiple methods)

De-parameterize method

(same type of parameter but different behavior depending on parameter)

Separate Query from Modifier

(split method with individual focus on functioning)

Pulling and pushing methods and fields

Pull up method

Pull up field

Push down method

Push down field

Communication and High-Level Refactoring

Refining hierarchies

Extract superclass, Extract subclass, collapse hierarchy

Communication refactoring

Code smell: message chain, middle man

Larger scale refactoring

Convert procedural to OO

Code smell: large classes, god classes, dumb data

Conclusion

References http://refactoring.com

Thank you