Programmers routinely become stuck in the Advanced Beginner stage of refactoring because they are trained to worry about overdoing it, so they underdo it and don’t build the skill they need to progress. They might benefit from some rules to help them break through.
TDD: You're Probably Doing It Just Fine
Many programmers struggle to adopt TDD because they put pressure on themselves or because some commentators try to shame them for their imperfections or because someone else is forcing them to do it. This causes needless stress, even suffering. Let’s try to reverse that trend.
TDD: For Those Who Don't Know How to Design Software
TDD is for those who don’t know how to design software, which doesn’t have to mean that we’re all dopes who are doomed to perpetual failure. Let’s explore this idea through the lens of an experienced practitioner suddenly confronted with some sharp words from a luminary in our field.
A Guard Clause Is Maybe a Tiny Parser
A guard clause might be an embryonic parser, so what happens if you nudge it in that direction?
Which Kinds of Tests Should I Write? Revisited
“TDD or BDD?” or “Functional Tests or Unit Tests?” Write any tests! The more clearly you understand the purpose of those tests, the more these apparent dilemmas will fade into the background.
Revealing Intent: A Tiny Example
It’s easy to give the instruction to reveal intent, but harder to provide helpful examples. I’d like to provide a tiny one that illustrates the point quite clearly—at least to me.
Refactoring Test Doubles: From Stubs to Parsing
When you notice that you need “too many” stubs (mocks for querying data), you have at least two helpful options for refactoring. Here is an example of using the more-aggressive of the two options: replacing a stub with the stubbed value.
The Power of Precise Names: An Example
Let’s look at a simple example of a name. Let’s judge the name (kindly!), then imagine some likely next steps in refactoring. We can learn and do quite a lot from only a single name!
How Tests Support Refactoring
No, tests aren’t supposed to make refactoring easier; they make refactoring safer. Sometimes, by accident, they do both.
Investing Wisely in Architecture Through Refactoring
The stronger your refactoring skill, the more easily you can use architecture advice as guidelines instead of as rules to enforce. This makes it significantly more likely that you’ll invest wisely in architecture, rather than over- or under-engineer.
A Matter of Interpretation: Mock Objects
Just another little example of two people looking at a situation, one seeing a problem and the other seeing a solution.
What's Not To Like About This Code? An Experiment.
What happens when I try to review code in small steps and in public? Let’s find out.