Lost In Translation Or Where do bugs come from?

Today I want to talk about translations. between languages, but also between other things. And how these translations breed bugs.

We translate. All day, every day. And, we think that we’re doing great, because these are languages we know. But we’re not really good at it.

Let’s start at the beginning. The beginning of software, that is.
The customer has a problem. They need a fix, but they can’t tell us HOW they want it fixed.

Ok, sometimes they do, but they are as good at this as we are.

So, in comes the Product Manager and offers a solution. “This is what we need to build”. That solution is a translation from the “problem space” to the “solution space”.

Right, we know WHAT we want to build. But how?

In comes the architect. Or lead designer. Or senior developer. Or all of them. They suggest a way to build the solution. One that will fit the current architecture, that will benefit the solution, and won’t cost a whole lot of money. “This is how we’re going to build it”.

This is the translation from the WHAT to the HOW. That’s already two translations.

But we’re not done yet.

This “how” needs to be translated from the high-level design to the low-level. From servers and libraries, to modules, classes and functions. From architecture to pieces of code. We have developers to do that.

And so, the developers do the final translation – from design to code.

That’s all?

Ok, there are a couple more stages of translation – the code gets built. Compilation turns text into bytes. Transpilation from one code to another. Sometimes that translation is done through known methods, that we can explain. Sometimes…

Then the app is deployed. And (hopefully) runs.

No errors found

We think that all these translations are 1:1. Accurate. Complete.

Alas, they are not. With each translation, come translation errors. Lots of “I thought that…”, and “I assumed that” and “The users will never…”.

Oh, but they will.

Where do bugs come from?

I left out the testers, so here’s a couple of translation for them. Testers translate the Product Manager’s requirements to testing specifications. Then to test steps and examples.

Same process, different translation errors.

And behold! Out of all these translation errors, come…

It looks like an unsolvable problem.

Well, it really is, we cannot get rid of translation errors. Even if everyone knew everything in the team, there are still going to be differences in understanding.

So, what can we do about this?

First, accept it. Bugs are not going away.

Next, communicate. Over and over, all the time.

Relying on documents, diagrams and yes, even code – The almighty real truth – these never tell the whole story. The truth sits as fragments in different people’s minds.

So no, documents are not going away either. They are our storage mechanisms. But like little children – documents should never be left alone. Or relied on.

One way to capture common understanding, and therefore reduce translation errors is automated tests. Check out my TDD and Unit Testing workshop.

I hope I made myself clear. And that there were no translation errors.