Refactoring

What refactoring is, when to refactor, when not to refactor, list of code smells

Transcript

1. Refactoring
2. What is refactoring?
3. "A change to the system that leaves its behavior unchanged, but enhances some nonfunctional quality – simplicity, flexibility, understandability, performance" Kent Beck, Extreme Programming Explained
4. "A change made to the internal structure of software to make it easier to understand and cheaper to modify without changing its observable behavior" Martin Fowler, Refactoring
5. Why refactoring?
6. Prevent “design decay” Clean up messes in the code Simplify the code
7. Increase readability and understandability Find bugs Reduce debugging time
8. How to refactor?
9. 1. Make sure your tests pass 2. Find some code that “smells” 3. Determine how to simplify this code 4. Make the simplifications 5. Run tests to ensure things still work correctly 6. Repeat the simplify/test cycle until the smell is gone
10. When to refactor?
11. When you add functionality When you learn something about the code When you fix a bug When the code smells
12. “Here’s a guideline Don Roberts gave me: The first time you do something, you just do it. The second time you do something similar, you wince at the duplication, but you do the duplicate thing anyway. The third time you do something similar, you refactor.” The Three Rule, Marting Fowler
13. When NOT to refactor?
14. When the tests aren’t passing When you should just rewrite the code When you have impending deadlines
15. “The other time you should avoid refactoring is when you are close to a deadline. At that point the productivity gain from refactoring would appear after the deadline and thus be too late” Marting Fowler
16. Code Smells
17. Indicators that something may be wrong in the code Can occur both in production code and test code
18. The Bloaters -Long Method -Large Class -Primitive Obsession -Long Parameter List -DataClumps
19. The Object-Orientation Abusers -Switch Statements -Temporary Field -Refused Bequest -Alternative Classes with Different Interfaces
20. The Change Preventers -Divergent Change -Shotgun Surgery -Parallel Inheritance Hierarchies
21. The Dispensables -Lazy class -Data class -Duplicate Code -Dead Code, -Speculative Generality
22. The Couplers -Feature Envy -Inappropriate Intimacy -Message Chains -Middle Man
23. Refactors