Foreword

Luke Hohmann, author of Innovation Games

It turns out that computers can teach us something about transformational leadership.

When you run a software program, usually something happens. That’s kind of the point of a program, right? You click a button or you type in a command, and instantly you see some sort of feedback. You run the program, it executes, and then it’s done. In other words, it comes to a halt.

But this isn’t always the case. Sometimes a program runs for a really long time. Sometimes even for an infinitely long amount of time. This creates a problem: there’s no way to actually tell whether a program will ever be done. In fact, it’s one of the most fundamental problems in computer science, so fundamental that solving it changed both mathematics and computer science forever.

Let’s imagine a program like this:

while(true) {

print(“I am running.”)

}

Since “true” will always be true, we can see that this program will be printing for a very long time. It will never halt. This is a pretty simple example, but what about more complex programs like gene sequencing, data mining, or stock predictions? The question is known as the halting problem.

An obvious solution is to run the program and see what happens. If it runs and then stops, the problem is solved. But wait, some programs take a very long time to finish. What if our program didn’t halt now but will halt after, say, one hour, or one day, or one thousand years? How do we know if we should terminate the run or keep going? That’s the challenge: unless you run the program, you don’t know if it halts. And even if you run it, you won’t know if it halts unless you wait potentially forever.

The brilliant mathematician Alan Turing, considered by many to be the father of computer science, proved that it is impossible to tell if an arbitrary program will halt once it starts running. And when I say impossible, I don’t just mean hard. I mean literally, mathematically impossible. So the only response is to work around the problem: watch and adapt. We can monitor and limit the expected resources the program will consume (time, memory, or CPU processing) and stop the program if any of these resources are exceeded. Once stopped, we can examine, adjust, and try again.

Agile transformations often experience the organizational equivalent of the halting problem. We don’t know how long it will take. We don’t know if the transformation will make things better. We don’t exactly know what the organization will look like when we’re finished. Most leaders will argue they have a fiduciary responsibility to have answers to these questions before going any further.

Unfortunately, Turing showed us we do not get to have the luxury of those answers; we cannot know whether or where the transformation will end. Instead, the only way to know if a transformation will be successful is to start it, monitor its resource consumption, and then adjust as needed to keep things on track.

In this marvelous contribution to the agile canon, my friend and colleague Jesse Fewell shares powerful advice on how to start, monitor, and yes, if necessary, pivot your agile transformation to success.