Type 0.1 + 0.2 into Python. Go on, try it.

You might expect 0.3. You would get 0.30000000000000004.

A machine that can simulate entire worlds, beat grandmasters at chess, and guide rockets to Mars — and it cannot add up two simple numbers. What is going on?

Computers Only Speak Binary

Here is the problem. Humans count in base 10 — we have ten fingers, so we have ten digits (0 through 9). When we write 0.1, we know exactly what we mean.

Computers count in base 2 — binary. They only have two digits: 0 and 1. Everything a computer stores, from your photos to your messages to your maths homework, gets translated into long strings of 0s and 1s before the computer can do anything with it.

Whole numbers translate cleanly. The number 5 becomes 101 in binary. The number 8 becomes 1000. No problem.

But fractions are trickier. Think about how we write one third in decimal: 0.3333333... It goes on forever. We cannot write it exactly — we just agree to round it.

The same thing happens to computers with numbers like 0.1. In binary, 0.1 is a repeating fraction — it never ends cleanly. The computer has to cut it off somewhere and round the answer. Most of the time the rounding error is so tiny you never notice it.

Until you add 0.1 + 0.2 and something unexpected appears.

Why Does This Matter?

This sounds like a curiosity — a fun quirk. But it has caused real problems in the real world.

In 1991, during the Gulf War, a US Patriot missile defence system failed to intercept an incoming missile because of a floating point rounding error. The system had been running for 100 hours, and a tiny timing error had accumulated over thousands of calculations until it was large enough to matter. The result was a tragedy.

In 1996, the Ariane 5 rocket — which had taken a decade to build — exploded 37 seconds after launch. The cause was a software error involving a number that was too large to be stored in the space the computer had set aside for it. £370 million, gone in less than a minute.

A tiny rounding error. A catastrophic result.

Floating Point: The Clever Workaround

Computer scientists knew about this problem from the very beginning. Their solution is called floating point representation — a way of storing numbers that works a bit like scientific notation.

Instead of trying to store 0.30000000000004 in full, a computer stores the important digits and separately stores where the decimal point goes. It is a clever compromise: you can represent an enormous range of numbers — from subatomic scales to the size of the observable universe — using a fixed amount of space.
The trade-off is precision. You get an approximation, not an exact answer. For most purposes, the approximation is close enough that it does not matter. For a missile defence system that has been running for four days, it matters a great deal.

The Lesson

Computer science is full of trade-offs like this. Every choice a designer makes — how much space to use, how much precision to keep, how to round a number — has consequences. Most of the time those consequences are invisible. Occasionally, they are not.

So next time you open Python and type 0.1 + 0.2, you are not looking at a mistake. You are looking at a deliberate design decision made by computer scientists decades ago — one that works brilliantly almost all of the time, and spectacularly badly the rest.

That is computing for you.

Gareth Edgell is a Senior Examiner and Head of Computer Science. He writes about CS concepts and exam technique at compscitutoring.com.