i made the claim that m-proof, the seemingly valueless dust that microtests give us, is actually gold. not only that, but it’s gold whose working out clearly connects to the triple focus of our movement: the made, the making, and the maker.
microtests prove that what the geek said is what the computer heard is what the geek wanted.
how can such a low-seeming value really be gold?
let’s work it out, eh?
the gold of microtesting comes to us in two categories. first, there’s the artifact itself, the actual test. second, there’s the impact of working in a way that is centered around using these artifacts to write code.
which is more valuable, the artifacts – the microtests themselves – or the artifact-centricity – the complex interactions and behaviors, the approach, given to us by working in/with/around/through the microtests? noobs routinely think it’s the artifact, and olbs routinely think it’s the artifact-centricity.
we see this over and over again. in fact, noobs overemphasizing artifact over process-through-artifact is one of the reasons TDD is so hard to get in to one’s head.
okay, so consider the value of just having the artifacts. imagine we have shipped a product. we rub a lamp, we wish for microtests, they cost us nothing and they simply appear next to our code base.
what have we got?
wellll. they don’t prove the made thing was what our payers wanted, still less that it was what our payer-users wanted, and even still less that it will make us money.
and we’re done, we’re not changing any code, so they don’t give us a safety net, cuz there’s nothing at risk.
curses. i have just argued that microtests as artifacts are completely worthless, they are exactly the dust we thought they might be, and not remotely gold at all.
if we’re already completely done with the product, they’re just so much used kleenex cluttering up our repo. oh wait, no. if we’re completely done with the product, who cares whether the repo is cluttered? the repo is also completely useless. we’ve got a binary in nexus, right? no point in keeping the source code around. “rm -rf *”
all it took was a simple thought-experiment with a single starting premise, “spoze you’re already done”.
we’ve dispensed with the microtests. also the repo. also the compiler. and the programming language. and the manuals. and stack overflow.
i’m not gonna keep goofin’ on this, i’m sure you get the point. we’ve eliminated all possible value inhering in the microtests “after the software is done”. the gold, if there is any, must come “before the software is done”.
why even go this far with the silliness? simple, really. the overwhelming majority of logical analysis, especially from newcomers, is about the value of TDD based on some variety of “after the software is done”.
that’s what people mean when they say “if you get it right you don’t need TDD”. look, if you get it right, the software is done, isn’t it? i could be wrong, but my understanding is that once a thing is right, it is also done.
so, i fooled you, didn’t i? you thought we were gonna get right to the value, and here we’ve spun out again. further, i now have to depart for a bit.
but … but …
i promise i’ll be back, and we really will go straight to a list of the value provided, all of which occurs when we’re not done, and much of it occurs not from the microtests themselves but from the act of working with them.
(q: can u call a second long intro still an intro? are we allowed to have two intros? god. this spec is really hard to read.)
have a strange mid-evening!