Simple, not Easy

I was asked on Twitter what I meant when I said ‘Simple, not easy. There’s a difference.’ I have no idea what I meant then, but here’s what I think just now.¹

I don’t remember the original context, and if it was in the context of an article, I can’t find it. Searching google, it’s not clear that I’m the only, or the first, person to say it. Charging on, Junilu is certainly right that while the TDD cycle seems simple enough, doing TDD well is difficult, not easy.

As for #DTSTTCPW, the original of that was first used in my life by Kent Beck, who used to ask “What’s the simplest thing that could possibly work”. Kent may have learned it from or used it when working with Ward Cunningham.

Now I perverted that idea, taking it to DO the simplest thing. Kent’s formulation gets you thinking of simple solutions and mine is more about actually trying the simplest thing you can think of.

Here, the context is different, at least at first. Here, doing the simplest thing probably is easy. “What if we just search the table, and see what happens.” That’s probably easy, and we might just find that the search takes 30 milliseconds and that’s just fine. So from the simple::easy viewpoint, #DTSTTCPW can be both.

But the quote – see, I came back – whatever its original context, refers to lots of things in Agile and in life. Scrum is simple; it isn’t easy. Exercise, diet: they’re simple, but not easy. Love is simple, but not easy.

Life … well, life isn’t simple, nor is it easy.

So, what’s the truth? Probably there is no actual truth in an aphorism, yet there may be value anyway. When we look at our work or our lives, at almost any scale, there is true complexity there, and we could zoom in forever. Unfortunately, we’re not smart enough to encompass all of life, or even all of TDD, or all of our little program, most of the time. And because our world is so complex, what I’m about to say won’t always work.

Nonetheless, pretending that things are simple, taking simple steps, pulling out one simple bit and doing it, often seems to work. It’s not guaranteed to work, in fact it’s guaranteed to fail sooner or later. And yet, paradoxically, it seems to me it’s always worth trying something simple.

Often, the simple thing works. Often, it partly works, or maybe it doesn’t work at all, but we learn something.

And that brings us back to TDD, where, at least right now at 4 AM, I find something paradoxical. The TDD cycle is simple. Sticking to TDD is often not easy. And yet, when I do the not-easy thing and stick to the simple rules of TDD, my coding becomes easier, and my program becomes more simple.

Maybe simple isn’t easy, but often simple leads to easy after all.