1. REFACTORING Improving the Design of Existing Code Atakan Şimşek e1298306

2. Outline Definition of Refactoring Why&When Refactor? Refactoring Steps Refactoring Examples Bad Smells Definiton Solution Conclusion

3. Definition Refactoring (noun): Improving the design of existing code without changing the code's observable behavior.

4. Some Definitions [Fowler] a change made to the internal structure of software to make it easier to understand cheaper to modify without changing its observable behavior [Beck] Improving the design after it has been written.

5. Why Refactor ? Easier to understand It becomes easy for others to understand. To find the bugs Finding the Bugs in the program.

6. To reduce Software maintenance costs To faciliate Future changes

7. To program faster Code complexity tends to increase rapidly over time(Patching new functionalities) Development slows down Refactoring helps keeping complexity under control Development proceed more rapidly

8. When to Refactor ? When you add a function Helps you to understand the code when modifying. Sometimes the existing design does not allow you to easily add the feature. When you need to fix a bug If it is difficult to trace an error: Code was not clear enough for you to see the bug in the first place.

9. When you do a Code Review When you detect a “bad smell” (an indication that something is wrong) in the code

10. Refactor? or NOT? Code does not work : NOT Code has some bugs: REFACTOR Very Close to Deadline: NOT There are bad smells: REFACTOR

11. Bad Smells Bad smellProposed refactoring Duplicated CodeExtract Class Long MethodExtract Method Large ClassExtract Subclass Extract Interface Long Parameter ListReplace Parameter with Method Lazy ClassInline Class

12. Where Can We Use? COSE Producer Side Consumer Side

13. Conditions of Refactoring Refactoring implies working incrementally Making changes to the program in small steps In between run the unit tests regularly If you make a mistake it's easy to back out.

14. Steps to Refactoring Analysis, helps to identify the code Identify problems in code by review using bad smells of code Introduce a refactoring Test

15. Refactorings Add Parameter Change Association Reference to value Value to reference Collapse hierarchy Consolidate conditionals Procedures to objects Decompose conditional Encapsulate collection Encapsulate downcast Encapsulate field Extract class Extract Interface Extract method Extract subclass Extract superclass Form template method Hide delegate Hide method Inline class Inline temp Introduce assertion Introduce explain variable Introduce foreign method

16. Refactoring examples Change Association Encapsulate Field Replace Number with Constants Compose Conditions Extract Class

17. Bi-directional Association to Unidirectional We have a two-way association but one class no longer needs features from the other.

18. Self Encapsulate Field Create getting and setting methods for the field and use only those to access the field. private int _low, _high; boolean includes (int arg) { return arg >= _low && arg <= _high; } private int _low, _high; boolean includes (int arg) { return arg >= getLow() && arg <= getHigh(); } int getLow() {return _low;} int getHigh() {return _high;}

19. Replace Magic Number with Symbolic Constant Create a constant, name it after the meaning, and replace the number with it. double potentialEnergy(double mass, double height) { return mass * 9.81 * height; } double potentialEnergy(double mass, double height) { return mass * GRAVITATIONAL_CONSTANT * height; } static final double GRAVITATIONAL_CONSTANT = 9.81;

20. Consolidate conditionals When we have a complicated conditional (if- then-else) statement. double disabilityAmount() { if (_seniority < 2) return 0; if (_monthsDisabled > 12) return 0; if (_isPartTime) return 0 // compute the disability amount double disabilityAmount() { if (isNotEligableForDisability()) return 0; // compute the disability amount

21. Extract Class You have one class doing work that should be done by two. Create a new class and move the relevant fields

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

23. Few solutions to Bad Smells Duplicated Code: If you see the same code structure in more than one place

24. Duplicated Code(cont.) Bugs copied as well Increase maintenance cost solution: perform EXTRACT METHOD and invoke the code from both places.

25. Long Parameter List An object invokes a method, then passes the result as a parameter for a method. solution: Use REPLACE PARAMETER with METHOD Remove the parameter and let the receiver invoke the same method with sender.

26. Long Method The longer a procedure is the more difficult it is to understand. solution: perform EXTRACT METHOD

27. Conclusion: Refactoring is useful to any program that has at least one of the following shortcomings: Programs that are hard to read Programs that have bad smells Programs that require additional behavior

28. References: More Information can be found http://www.refactoring.com/ http://www.refactoring.be/ http://www.refactoring.be/ Refactoring: Improving the Design of Existing Code By Martin Fowler