Exploring Extreme Programming
Coupling occurs when one part of a system depends on another part. That is, if one part changes, the other must be adjusted too. Lambda expressions can reduce coupling by needing to refer to fewer things. Dependencies on Objects Consider Continue reading Lambda to Reduce Coupling
Several mainstream languages have added better support for lambda expressions (including lighter syntax) in the last few years. This can let you define new forms of control structures, and reduce duplication in a different way than say extracting a common Continue reading Lambda for Control Structures, a Refactoring
Duplication across tests may not be as harmful as duplication in production code, but a parameterized unit test can reduce duplication and help us create better tests. Judging Tests – The Pause Spotting duplication in tests is like spotting it Continue reading Extracting Parameterized Unit Tests
Automated refactoring tools are great, but sometimes the tool doesn’t make the best choice. We can often nudge the tool to a better choice. Why Bother? Why bother nudging? Couldn’t you do the refactoring manually just as quickly? You could Continue reading Refactoring: Forcing the Right Extract Method
Nested structures are challenging to read; a pipeline is usually easier to read and think about. Nested structures have that “arrow of doom” feeling, where you work your way in multiple levels then out. It’s hard to tell what’s being Continue reading Nested Loops to Functional Pipeline
Sometimes you want to change from using a basic type (such as Int or String) to a type that contains the basic type as a value. (See Refactoring in the References.) The change itself isn’t hard, but then you have Continue reading Wrapping a Type, All the Way
Once in a while, I run into a 1980s-era BASIC program, typically written for Commodore 64, Apple ][, or TRS-80. I’d like to transliterate it into a modern language, refactor it, and explore it. These old programs make a nice Continue reading Transliterating Old-School BASIC
As you refactor, you sometimes need to understand how the data flow through the code. We’ll look at several ways that can reveal that information. Data Flow Analysis Data flow analysis tracks the creation and use of data through the Continue reading Data Flow Analysis for Refactoring
To refactor is to systematically “improve the design of existing code”. There are many ways to classify refactorings, but one distinction stands out to me: local refactorings. A local refactoring affects only one file (and perhaps its tests). Why Local? Continue reading Local Refactorings
The Template Method design pattern defines an algorithm in an abstract class, and defers some steps to its subclasses. A Strategy defines a family of pluggable implementations. We’ll see how to convert from Template Method to Strategy. Template Method A Continue reading Refactor Template Method to Strategy