This document discusses refactoring code to improve its structure and design without changing its external behavior. Refactoring includes techniques like extracting methods, moving methods between classes, simplifying conditional logic, and improving data structures. The goal of refactoring is to make code more readable, reusable, and maintainable by removing duplication, poorly structured code, and unnecessary complexity. It discusses various code smells that indicate needs for refactoring and provides examples of specific refactoring techniques at the method and class level as well as for data structures and communication between code elements.

1. Anand Bait
Developer
Allerin Tech Pvt Ltd

2. 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

3. Contents
 Introduction to Refactoring
 Method-Level Refactoring
 Class and Condition Focused Refactoring
 Data Focused Refactoring
 Communication and High Level Refactoring
 Conclusion

4. 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

5. What ‘REFACTORING’ is NOT?
 Not debugging
 Not adding feature
 Not changing observable behavior of code
 Not performance improving

6. Why to use?

7. When to use?
 Write – Scan – Refactor at the end : INCORRECT
 Write – Scan – Refactor regularly : CORRECT
 Code reviews
How to use?

8. Code smell
 Duplicated code
 Long methods
 Comments
 Doesn’t tell what to do but tells us what to notice

9. 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

10. Preparing to refactor
 Requirement of automated testing vs manual testing

11. 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)

12. Extract Method refactoring
 Smaller and specific is better
 Provides reusability
 Ease of overriding while using inheritance

13. Extract Method with parameters
 Parameters should be related to the method
Extract Method with variables
 Temporary variables can be extracted

14. Code smells for using Extract
Method
 Long method
 Comments(having comments vs need comments)

15. Inline Method refactoring
 Removing method that adds no value

16. Refactoring to remove temps
 Increase temptation to write longer methods
 Change temps to small methods

17. Refactoring to add temps
 Split temporary variables
 Introduce explaining variables
 Remove assignments to parameters

18. Split temporary variables
 Don’t use same temporary variable for different
purposes

19. Introduce explaining variables
 To improve readability
 Introduce when a small method may not be required

20. Remove assignments to
parameters
 Add temporary variables that assigns value to
parameters may give undesired results

21. 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

22. 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

23. Extract Class and Inline Class
 Code smell: Large class

24. Making conditions easier to read
 Decompose conditionals
 Consolidate conditionals
 Consolidate duplicate conditionals

25. Replacing conditions with
polymorphism
 Conditions to check custom behavior

26. Replacing type code with
subclasses
 Data can be categorized into subclasses

27. Data Focused Refactoring
 Moving and encapsulating fields
 Working with data clumps
 Simplifying method calls and parameter use
 Pulling and pushing methods and fields

28. Moving and encapsulating fields
 If a field is more related and being used by the other
class

29. 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)

30. 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)

31. Pulling and pushing methods and
fields
 Pull up method
 Pull up field
 Push down method
 Push down field

32. 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

33. Conclusion

34. References
 http://refactoring.com

35. Thank you