This document discusses refactoring code to improve its structure and design without changing its external behavior. Refactoring involves applying small, incremental changes through techniques like extracting methods, replacing conditionals, and parameterizing methods. It improves code quality by making it more readable, reusable, maintainable and less error-prone. The key is to refactor in small steps through practices like testing and code reviews to pay off technical debt over time.

1. REFACTORINGXP Injectionhttp://xpinjection.com

2. Do You Know Your Code?

3. Developer Golden RuleAny fool can write code that a computer can understand

4. Good Developer Golden RuleAny fool can write code that a computer can understandGood programmers write code that humans can understand

5. Why Fix What is Not Broken?

6. If the Code is Hard to UnderstandHard to maintainHard to improveHard to work with evolutionary designMore expensive

7. What is Refactoring?A series of small steps, each of which changes the program’s internal structure without changing its external behavior - Martin FowlerVerify no change in external behavior byTestingUsing the right tool (IDE)Formal code analysis by toolCode review or pair programmingBeing very, very careful

8. Prerequisites for SuccessSafety netEverybody agreed “Collective code ownership”Common understanding of refactoring methodsSupportive environmentPowerful IDE

9. Refactoring CycleFind smellSelect refactoringApply refactoringRun all tests

10. 3 Ways to Start

11. Find Something to Improve

12. Make Static Analysis

13. Find Smell

14. How to Find Smell

15. Smells

16. Main GoalsOrganizing dataComposing methodsMaking methods calls simplerMoving features between objectsSimplifying conditional expressionDealing with generalizations

17. Operations Associated with RefactoringReplaceExtractMoveChangeIntroduceRemovePullConsolidatePushInlineAdd

18. When to Refactor?When add new functionalityRefactor existing code until you understand itRefactor the design to make it simple to addWhen try to find bugsRefactor to understand the codeDuring code reviewsImmediate effect of code reviewAllows for higher level suggestions

19. Key Elementsof RefactoringSimplifying complex statementsAbstracting common solutions into reusable codeRemoval of duplicate code

20. Refactoring Techniques

21. 6 Techniques in Action

22. Extract Methodvoid printOwing() {printBanner(); //print detailsSystem.out.println("name: " + _name);System.out.println("amount " + getOutstanding());}void printOwing() {printBanner();printDetails(getOutstanding());}void printDetails (double outstanding) {System.out.println("name: " + name);System.out.println("amount " + outstanding);}

23. Extract Super Class

24. Decompose Conditionalif (date.before (SUMMER_START) || date.after(SUMMER_END)) { charge = quantity * winterRate+ serviceCharge;} else { charge = quantity * summerRate;}if (notSummer(date)) { charge = winterCharge(quantity);} else { charge = summerCharge (quantity);}

25. Replace Error Code with Exceptionboolean withdraw(int amount) { if (amount > balance) return false; else { balance -= amount; return true; }}void withdraw(int amount) throws BalanceException { if (amount > balance) throw new BalanceException(); balance -= amount;}

26. Replace Exception with Testdouble getValueForPeriod (int period) { try { return values[period]; } catch (ArrayIndexOutOfBoundsException e) { return 0; }}double getValueForPeriod (int period) { return period >= values.length ? 0 : values[period];}

27. Parameterize Method

28. Good Design PrinciplesDRYKISSYAGNI

29. No Silver BulletNeeds lots of practiceRequires disciplineContinuous usageLittle steps

30. Little steps – huge results

31. You Need to Pay Technical Debt

32. Refactoring BenefitsMore readable codeEasier maintenanceCode reuseEasier to add new codeImproved designBetter understandingSpeeding knowledgeEasier to testMinimize duplication

33. Live Demo

34. Questions?