Refactoring: Improving the design of existing code. Chapter 6.
- 1. Refactoring: Improving the design of existing code Chapter 6. Composing Methods Kent Beck and Martin Fowler
- 2. Composing Methods • A large part of the author’s refactoring is composing methods to package code properly. • Almost all the time the problems come from methods that are too long. • Long methods are troublesome because they often contain lots of information, which gets buried by the complex logic that usually gets dragged in.
- 3. Composing Methods • Extract Method • Inline Method • InlineTemp • ReplaceTemp with Query • Introduce ExplainingVariable • SplitTemporaryVariable • Remove Assignments to Parameters • Replace Method with Method Object • Substitute Algorithm
- 4. Extract Method • Is the key refactoring, which takes a clump of code that is too long or needs a comment to understand its purpose and turns it into its own method. • Short, well-named methods, increases the chances that other methods can use a method when the method is finely grained and allows the higher-level methods to read more like a series of comments. • If extracting improves clarity, do it, even if the name is longer than the code you have extracted.
- 7. Inline Method • When you've done multiple extractions and realize some of the resulting methods are no longer pulling their weight • If you need to reorganize the way you've broken down methods. • When someone is using too much indirection and it seems that every method does simple delegation to another method, and I get lost in all the delegation. In these cases some of the indirection is worthwhile, but not all of it.
- 10. InlineTemp • Most of the time is used as part of ReplaceTemp with Query, so the real motivation is there. • The only time InlineTemp is used on its own is when you find a temp that is assigned the value of a method call. Often this temp isn't doing any harm and you can safely leave it there. • If the temp is getting in the way of other refactorings, such as Extract Method, it's time to inline it.
- 11. InlineTemp
- 12. ReplaceTemp with Query • The problem with temps is that they are temporary and local. • By replacing the temp with a query method, any method in the class can get at the information.That helps a lot in coming up with cleaner code for the class. • Often is a vital step before Extract Method. Local variables make it difficult to extract, so replace as many variables as you can with queries. • If the temp is used to collect a result (such as summing over a loop), you need to copy some logic into the query method.
- 15. Introduce ExplainingVariable • Put the result of the expression, or parts of the expression, in a temporary variable with a name that explains the purpose. • Is particularly valuable with conditional logic in which it is useful to take each clause of a condition and explain what the condition means with a well-named temp. • Another case is a long algorithm, in which each step in the computation can be explained with a temp. • Use Extract Method if you can.When local variables make it difficult to use Extract Method is when you may use Introduce ExplainingVariable.
- 18. SplitTemporaryVariable • You have a temporary variable assigned to more than once, but is not a loop variable nor a collecting temporary variable. • If they are set more than once is a sign that they have more than one responsibility within the method. • Any variable with more than one responsibility should be replaced with a temp for each responsibility. • Using a temp for two different things is very confusing for the reader.
- 21. Remove Assignments to Parameters • If the code assigns to a parameter. Use a temporary variable instead. • With pass by value, any change to the parameter is not reflected in the calling routine.Those who have used pass by reference will probably find this confusing.. • It is much clearer if you use only the parameter to represent what has been passed in, because that is a consistent usage.
- 22. Remove Assignments to Parameters
- 23. Replace Method with Method Object • If you have a long method that uses local variables in such a way that you cannot apply Extract Method. • Turn the method into its own object so that all the local variables become fields on that object.You can then use Extract Method on this new object to create additional methods that break down the original method.
- 24. Substitute Algorithm • If you find a clearer way to do something, you should replace the complicated way with the clearer way. • Refactoring can break down something complex into simpler pieces, but sometimes you just reach the point at which you have to remove the whole algorithm and replace it with something simpler. • This occurs as you learn more about the problem and realize that there's an easier way to do it. It also happens if you start using a library that supplies features that duplicate your code. • When you have to take this step, make sure you have decomposed the method as much as you can. Substituting a large, complex algorithm is very difficult; only by making it simple can you make the substitution tractable.
- 27. Andrés Callejas González Universidad Pontificia Bolivariana