Binary number system — conversions from - to decimal, counting in binary: Visual walkthrough

We build everything. If a symbol appears, it was defined the line before. Ready? One switch at a time.

Step 1 — A switch has exactly two states

WHAT. Picture a single light switch on a wall. It can only be down (OFF) or up (ON). Nothing in between counts.

WHY. A computer is built from millions of tiny switches (transistors). We choose a name for each state: OFF is called 0, ON is called 1. The word "bit" just means "one such switch" — a thing that holds a 0 or a 1. We use two states (and not ten) because a switch that only has to be clearly-down or clearly-up is cheap and rarely misread.

PICTURE. In the figure, the left switch is down (we write 0 under it) and the right switch is up (we write 1 under it). That label under each switch is its bit.

Figure — Binary number system — conversions from - to decimal, counting in binary

Step 2 — A row of switches, and "position"

WHAT. Line up several switches side by side. Reading right-to-left, we give each a position number starting at $0$ : the rightmost switch is position $0$ , the next is position $1$ , then $2$ , then $3$ , and so on.

WHY. We start counting positions at 0, not 1, because in a moment each position will get a value $2^{i}$ , and we want the rightmost switch to be worth $2^{0} = 1$ . If we started at 1 the rightmost would wrongly be worth $2^{1} = 2$ . Starting at 0 makes the maths line up.

$position 3 d_{3} position 2 d_{2} position 1 d_{1} position 0 d_{0}$

Here each $d_{i}$ (read "dee-eye") is just the bit sitting at position $i$ — a stand-in that is either 0 or 1. The little number $i$ tells you which switch we mean.

PICTURE. The figure numbers the switches from the right. Notice the arrow: position numbers grow as we move left.

Step 3 — Each position is worth double the one to its right

WHAT. Give position $i$ the weight $2^{i}$ . Reading right-to-left the weights are $1, 2, 4, 8, 16, 32, \dots$ — each one is double its right neighbour.

WHY doubling, and why powers of 2? Because there are only two digits. In decimal a new column appears once you'd need a digit bigger than 9 — so decimal columns are worth $\times 10$ each. In binary a new column appears the moment you'd need a digit bigger than 1 — so each binary column is worth $\times 2$ . That "times two per step to the left" is exactly what "powers of two" means:

$2^{0} = 1, 2^{1} = 2, 2^{2} = 4, 2^{3} = 8, 2^{4} = 16, \dots$

The exponent (the small raised number) counts how many times we multiplied by 2. Position $0$ multiplied zero times gives $1$ .

PICTURE. Above each switch we chalk its weight. The blue arrow shows the " $\times 2$ " jump from one column to the next as you step left.

Step 4 — A bit either "collects" its weight or it doesn't

WHAT. Multiply each bit by its weight: the column contributes $d_{i} \cdot 2^{i}$ . Because $d_{i}$ is only ever 0 or 1, this multiplication has just two outcomes.

WHY this is the key trick. Look at what $d_{i} \cdot 2^{i}$ does:

If the switch is off ( $d_{i} = 0$ ): $0 \cdot 2^{i} = 0$ . It contributes nothing.
If the switch is on ( $d_{i} = 1$ ): $1 \cdot 2^{i} = 2^{i}$ . It contributes its full weight.

So a bit acts like a gate on its weight: a 1 lets the weight through, a 0 blocks it. There is no in-between because there is no other digit. This is why binary is easy to add up — you never scale a weight by 3 or 7, only by 0 or 1.

PICTURE. Green switches (on) pass their weight down; grey switches (off) drop a $0$ . The values that survive are circled.

Step 5 — Sum the surviving weights (the formula appears)

WHAT. Add every column's contribution. Written all at once, that sum is the binary-to-decimal formula.

WHY a sum (the $\sum$ symbol). We are combining many separate contributions into one total, so the natural tool is addition. The symbol $\sum$ (a big Greek "S", for "Sum") is shorthand for "add up all of these":

$(d_{n} \dots d_{1} d_{0})_{2} = \sum_{i = 0}^{n} d_{i} \cdot 2^{i}$

Read it term by term:

$\sum$ — "add together everything that follows".
$i = 0$ underneath — start the counter $i$ at the rightmost column.
$n$ on top — stop at the leftmost column (position $n$ ).
$d_{i} \cdot 2^{i}$ — the one contribution being added: bit times its weight.

Because each $d_{i}$ is 0 or 1, this long sum quietly becomes "add the weights where the bit is 1", exactly Step 4.

PICTURE. The figure lays out $101 1_{2}$ : weights $8, 4, 2, 1$ on top, bits $1, 0, 1, 1$ below, and only the on-columns feed the running total $8 + 2 + 1 = 11$ .

Step 6 — A bigger number, same picture ( $11010 0_{2}$ )

WHAT. Convert $11010 0_{2}$ by the exact same method — just more columns.

WHY show a longer one. To prove the recipe doesn't change with size, and to make you see the zeros doing their job (contributing nothing while still holding a position).

Weights (right-to-left): $1, 2, 4, 8, 16, 32$ . Bits: $1, 1, 0, 1, 0, 0$ .

$32116180412010$

On-columns are positions $5, 4, 2$ :

$32 + 16 + 4 = 52$

PICTURE. Six switches; the three zero-switches sit dark but still occupy their slots, so the weights above them ( $8, 2, 1$ ) are simply skipped, not deleted.

Step 7 — The degenerate cases: all-zeros and all-ones

WHAT. Two edge cases you must never trip over.

All switches off — $000 \dots 0$ . Every term is $0 \cdot 2^{i} = 0$ , so the total is $0$ . Binary zero is just "all off". No special rule needed; the formula already handles it.

All switches on — $n$ ones in a row. Now every weight survives, so we add the whole staircase:

$2^{0} + 2^{1} + \dots + 2^{n - 1} = 2^{n} - 1$

WHY the $- 1$ , visually. Stack the weights and add one more $1$ : it fills every gap and rolls all the way up to the next power of two, landing one short — $2^{n} - 1$ . Example: $111 1_{2} = 8 + 4 + 2 + 1 = 15 = 2^{4} - 1$ . This is why $n$ bits reach a maximum of $2^{n} - 1$ , not $2^{n}$ : you start counting at $0$ , so the last of the $2^{n}$ values is one below $2^{n}$ .

PICTURE. The tower of weights $1, 2, 4, 8$ plus a phantom $+ 1$ (pink) tips the whole stack up to $16$ , then we step back down one to $15$ .

Recall Why does 8 bits max out at 255?

All eight on: $128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = 255 = 2^{8} - 1$ . ::: $2^{8} = 256$ values ( $0$ through $255$ ), largest is $255$ .

The one-picture summary

WHAT. One figure that fuses the whole walkthrough: switches on top, weights $2^{i}$ hovering over each, on-switches lighting a path down into a single sum, out pops the decimal number.

The pipeline you now own:

Recall Feynman retelling — say it to a friend

Lay out some light switches. Number them from the right, starting at zero. Give the rightmost one the value 1, and each switch to its left is worth double: 1, 2, 4, 8, 16… Now walk the row: if a switch is ON, keep its value; if it's OFF, throw a zero away. Add up everything you kept — that total is the number the switches spell. All off means zero. All on means you kept every value, which stacks up to one below the next doubling. That's the whole game: add the weights of the switches that are on.

Connections

Place-value and number bases — this whole page is the $b = 2$ case of $\sum d_{i} b^{i}$ .
Bits and Bytes — 8 switches in a row = a byte, values $0$ – $255$ (Step 7).
Logic gates and switches — why each switch has only two states.
Hexadecimal and Octal — grouping these switches into blocks for shorter writing.
Binary addition and overflow — what happens when the "on" columns start to carry.
Two's complement — reusing the leftmost switch to mean "negative".