Today, I was working on a refactoring exercise; I had code, and tests in place, and all of my tests are passing. I made a change, ran the tests, and tests failed. Startled, I reverted the change. The tests are now passing again.
But I had to stop here, because I happened to notice a problem: the change that I reverted to pass the test was correct.
What had happened? Well, that's easy -- one of my earlier edits included a mistake, because of the mistake, the behavior of the code was incorrect. But the test didn't detect the mistake at the point that it was introduced. Instead the test appeared later.
This concerns me, because one of the illusions that I carry around with me is that there is a payoff in TDD that you spend less time in the debugger because mistakes are caught when you make them. Test-commit-revert is, to some degree, founded on this idea -- that you can discard the mistake by simply reverting the code.
Assuming, for the moment, that all other things are equal, I prefer habits that produce short intervals between the mistake and its detection to those that produce longer intervals.
So, what happened today?
(There would still be interesting adjustments needed with an integer-based type, but there'd be fewer. Just go with me here.)— Ron Jeffries (@RonJeffries) November 12, 2019
The difference between our newly-imagined design and our existing one is technical debt.
8/22
I was working on a greenfield project; write a test, make it pass, clean it up, repeat. And my "imagined design" was not expressed in the code. The changes I want to introduce appear to be getting harder, so I'm interrupting my "progress" to make the next change easy.
My imagined design is a finite state machine, and I'm trying to organize the code in a way that introducing a new state (with new behavior) will be easy.
I'm writing a game, and tracking the token as it moves from the starting square to the second square; the tests verify the descriptions of the squares against a fixed transcript. The test that I am anticipating moves the token back to the original square, with a different description than was initially displayed.
My thought was to introduce a predicate which is always true (preserving the current behavior), and then to introduce the new test which would pass if the predicate were false. Thus, I would meet one of my goals: minimizing the time required to complete the "Green" task.
And, having practice that approach several times this morning, it works fine.
But not the first time that I tried it.
The first time through, there were two differences in the technique that I used which both contributed. One difference was that I typed my code, rather than using the refactoring tools. That made it possible to introduce an error - a line of code I thought was assigning a value to a variable was in fact a no-op.
The other difference is that I started out my refactoring by introducing the writes; creating the new variable, assigning the data to it. I introduced the error during this phase, but because the variable is not yet being read anywhere, the coding error I've introduced has no impact at all on the behavior. So all of the tests continue to pass. When I introduced the new variable into the predicate, now the bug appears.
On the other hand, on the interations where I started from "If True", mistakes were detected at the moment I introduced them.
It felt a bit like TDD as if you meant it: if True is trivially correct, then true is rewritten into an equivalent comparison between two literal values, not we extract variable on one of those literals, and then that variable can be moved around in the source code. At each mistake, a simple revert/undo would take me back to not merely a passing state, but actual bug free code that passed its tests.
Another way of considering this lesson is that we should start as close to the actual constraints of the tests, and work backwards from there, gradually moving our changes into the parts of our implementation where we have more freedom.
It's similar in nature to starting with a hard coded return value, and then removing duplication as your refactor your way toward the function arguments.