TDD

TDD Pro-Tip: Iterations Aren’t Increments

TDD Pro-Tip: TDD depends heavily on a view that accepts and even values iteration. TDD is an I&I style of work: iteration and increment are both involved. Nearly everyone gets "increment": an increment is an improvement, an enhancement, a detectable step forward in value. Each increment is a pass over the code, during which we add to its function. TDD noobs take "increment", then, to mean "add a passing test". On the one hand, that’s great. On the other hand, […]

TDD Pro-Tip: Iterations Aren’t Increments See Full Post

TDD Pro-Tip: Graceful and Awkward

TDD Pro-Tip: The first step past beginner-TDD lies in grasping the difference between awkward and graceful collaborations, and learning the myriad contextualized patterns for moving from the former to the latter. Folks invest a little in TDD, maybe cuz they’re excited, maybe cuz they’re ordered. They read a little. They try an exercise or two. They learn a little about their xUnit options. Maybe they boldly even use TDD to write a method or a class in their day job.

TDD Pro-Tip: Graceful and Awkward See Full Post

Building the Wrong Thing

Folks worry a lot about building the wrong thing, that is, making software that does not please the many and different interests of the org, the users, the operators. I’ve certainly seen that. We all have. Government seems particularly consistent at doing it, tho surely there are plenty of commercial orgs that have the same problem. I see this problem differently from most folks. I’d like to take a few tweets and walk through my approach. The key insight for

Building the Wrong Thing See Full Post

TDD Pro-Tip: Build Cells

TDD Pro-Tip: Build cells — logic nucleus on the inside, environment inputs & outputs on the outside, and a semi-permeable cell wall between the two. The metaphor i’m proposing here is really about the nature of borders in code. Prior to TDD, my grasp of this topic was driven largely by the great theory of object-orientation that began to emerge back in the ’80s and came to dominate the modern s/w landscape. As with so many aspects of the programming

TDD Pro-Tip: Build Cells See Full Post

The Gold Of Microtests: The Value

This entry is part [part not set] of 3 in the series The Gold of Microtests

Okay, twice now i’ve intro’d this question about the value of m-proof, the rather trivial proof microtests give: what the geek said is what the computer heard is what the geek wanted. Time to just deal with it, eh? Remember that all of the value that comes from microtests comes before we’re done with the program. As we’ll see, some of it comes from the fact that the artifacts — the microtests — exist at all, and some of it

The Gold Of Microtests: The Value See Full Post

The Gold Of Microtests: Another? Intro

This entry is part [part not set] of 3 in the series The Gold of Microtests

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

The Gold Of Microtests: Another? Intro See Full Post

The Gold Of Microtests: The Intro

This entry is part [part not set] of 3 in the series The Gold of Microtests

Okay, shall we take a breather from difficult concepts and do something at least a little more concrete and geeky? And the windswept trees whisper "yessssss, yessssss". Recall that a microtest is a tiny snippet of test code, run in a separate app, that depends on a tiny snippet of shipping code. It is typically focused in its intent on a single branch or calculation in that shipping code. It is fast to write, to read, to diagnose. What does

The Gold Of Microtests: The Intro See Full Post

The Correlation Premise: Redux

This entry is part [part not set] of 9 in the series Underplayed Premises

My five TDD premises stuff has been well-received over the months since I put it out, but one of them seems still very underplayed, even by many died-in-the-wool TDD’ers: the correlation premise. The correlation premise says that the internal quality of our code correlates directly with our productivity. When the internal quality goes up, productivity goes up. When it goes down, productivity goes down. All of the premises were formulated in part to undercut dangerous misunderstandings about what TDD is

The Correlation Premise: Redux See Full Post

TDD Pro-Tip: Start Builders & Partial Comparators Early

TDD Pro-Tip: Prevent complex test data from spiraling out of control by going to builder & custom comparator early on. The push-to-small, coupled with SOLID, coupled with things like third normal form, all lead us to a place of wanting to compose domain objects into potentially very rich dependency graphs. A card in a address-tracking subsystem sounds at first blush like a class with about 5 simple strings in it, and we certainly start there when we first approach it.

TDD Pro-Tip: Start Builders & Partial Comparators Early See Full Post

TDD Pro-Tip: ‘No, Smaller.

TDD Pro-Tip: "No, smaller." In TDD, almost without exception, we want everything: a test, a method, a class, a step, a file, really, almost everything, to be as small as it can be and still add value to what we’re doing. This is the most common gaping hole in the practice of the noob, and it’s a constant obsession for the olb. But it’s not just an old-timer’s tic, like the way my lips purse when someone uses the word

TDD Pro-Tip: ‘No, Smaller. See Full Post

Scroll to Top