Exploring Extreme Programming
Context: You have a class that implements one or more protocols. The class has become long, and it’s confusing to understand what parts are there for the protocols, and what parts are for the class’ internal needs. Solution: Divide the Continue reading Divide Class into Class + Extension (Swift Refactoring)
Extract Protocol lets us generalize our types. Context: You have a class (or other entity), and want to let another class stand in for it in some cases. You could make the other class a subclass. But this couples the Continue reading Extract Protocol Refactoring (Swift) – Elevate Common Behavior
Evolutionary design is a strategy to enable incremental delivery of capabilities. Consider two delivery strategies. In one, we plan everything we need, develop, then deliver when everything is ready. In the other, an incremental strategy, we first deliver a minimal Continue reading Evolutionary Design: Techniques and Example
This article (originally published in Better Software) explores generalization in TDD. The basic notion is that refactoring sets out to not change the behavior of code for any of its inputs, but TDD sets out to change behavior (in the Continue reading Refactoring and Generalization in TDD
When you clean up code, you often need refactorings that aren’t in any tool, and aren’t in Martin Fowler’s Refactoring catalog. You’re on your own. When this happens, think like a language lawyer and a logician. Language Lawyer and Logician Continue reading Home-Grown Refactorings – Be Careful!
We’ll look at Test-Driven Development (TDD) and Test-Commit-Revert (TCR) in terms of how they work with frequent commits to source control. Test-Driven Development (TDD) Test-Driven Development is often described with this cycle: Red-Green-Refactor (or Red-Green-Gold, as I learned from Alex Continue reading TDD, TCR, and Frequent Commits
Kent Beck’s TCR workflow experiment has generated some good discussion. Rachel Carmena has documented several TDD workflows. I’d like to add an approach that I’ve used for a while: “Call Your Shots”. Call Your Shots If you’re playing pool seriously, you don’t just Continue reading The “Call Your Shots” TDD Workflow
Teams often don’t pay enough attention to language. A team can improve its language by using what Eric Evans calls Ubiquitous Language: “A language structured around the domain model and used by all team members to connect all the activities Continue reading Ubiquitous Language – A Triple-Play for Words
Martin Fowler writes, “Refactoring is the process of changing a software system in such a way that it does not alter the external behavior of the code yet it improves its internal structure.” [Refactoring, 1999, p. xvi] But what does Continue reading Limits of Refactoring: What IS Behavior?
We’ll look at two refactorings suitable for conditional statements: Pull Up Common Head of Conditional and Pull Down Common Tail of Conditional. I originally learned these as performance optimizations but they also help simplify and clarify code. In Refactoring, Martin Continue reading Refactoring: Pull Common Code from Conditional