Binary number system and bit - byte concepts: Visual walkthrough

Before we start, one promise: every symbol is earned. We will not write $2^{i}$ until you have seen, in a picture, exactly why the number $2$ raised to a position shows up.

Step 1 — Start with something you already trust: counting pebbles

WHAT. Forget bases, forget binary. A number is just how many things — pebbles in a pile. We want a way to record that pile so we can read it back later without recounting.

WHY. If we can't agree on what "a number" means physically, no notation can be justified. So we anchor everything to a concrete pile of dots.

PICTURE. Below: a pile of $13$ dots. That count — thirteen — is the thing we will encode. Every step from here on must, at the end, reproduce exactly this many dots.

Step 2 — Why grouping is the only way to write big counts compactly

WHAT. Instead of drawing $13$ separate dots forever, we bundle them into fixed-size groups. A computer's switch has exactly two states (ON, OFF), so the natural bundle size is two.

WHY two? Because a switch can only tell us one of two things. It can answer the yes/no question "is there a leftover single dot after making pairs?" — and nothing more subtle. So the group size the hardware can record is $2$ . This is the whole reason binary appears: it is dictated by the switch, not chosen for elegance.

PICTURE. We take $13$ dots and repeatedly bundle into pairs. Each bundling either leaves a lonely dot (a leftover = 1) or leaves nothing (0). That leftover is what a single switch stores.

Step 3 — Peel the bits off, one switch at a time (repeated halving)

WHAT. Repeatedly divide the count by $2$ . Each division gives a quotient (how many pairs) and a remainder (0 or 1, the leftover). The remainder is one bit; the quotient is what remains to be encoded.

WHY. Dividing by $2$ is the act of "bundle into pairs and note the leftover" done in arithmetic. We repeat until nothing is left, peeling one bit off the right each time.

PICTURE. A staircase: at each step the pile shrinks (quotient), and we drop a bit (remainder) onto a shelf. Read the shelf from the bottom up to get the number.

For $N = 13$ the shelf fills like this (first remainder = rightmost bit):

step	count $q$	$q mod 2$ (bit)	$q \div 2$ (next)
1	$13$	$1$	$6$
2	$6$	$0$	$3$
3	$3$	$1$	$1$
4	$1$	$1$	$0$

Reading the bits bottom-to-top: $1101$ .

Step 4 — Where the column weights come from (why $1, 2, 4, 8$ )

WHAT. Unfold the recurrence from Step 3. Substituting each quotient back in shows every bit is multiplied by a power of two.

WHY. The first leftover counts single dots (weight $1$ ). The next leftover was measured in pairs, so each of its dots is worth $2$ . The next in pairs of pairs, worth $4$ . Each shelf-level up doubles the worth — because we grouped in twos every time.

PICTURE. Four boxes side by side, growing: a single dot (1), a domino (2), a $2 \times 2$ tile (4), a $2 \times 4$ tile (8). Each ON switch "spends" its box's worth of dots.

Step 5 — Assemble the value: multiply each bit by its weight, then add

WHAT. A binary pattern $d_{n - 1} \dots d_{1} d_{0}$ (each $d_{i}$ a bit) stands for the number you get by adding each bit times its column weight.

WHY. An ON switch ( $d_{i} = 1$ ) contributes a whole box of dots ( $1 \cdot 2^{i}$ ). An OFF switch ( $d_{i} = 0$ ) contributes nothing ( $0 \cdot 2^{i} = 0$ ). Summing the contributions rebuilds the original pile.

PICTURE. The pattern $1101$ with weights written under each bit; ON columns light up, their dot-boxes pour into one basket that must hold exactly $13$ dots again.

Check it closes the loop: $110 1_{2} = d_{3} 1 \cdot 8 + d_{2} 1 \cdot 4 + d_{1} 0 \cdot 2 + d_{0} 1 \cdot 1 = 8 + 4 + 0 + 1 = 13$ We got our $13$ dots back. The encoding (Step 3) and the decoding (Step 5) are true inverses.

Step 6 — Edge case A: the all-OFF pattern (zero) and the all-ON pattern (the max)

WHAT. Two extreme patterns. Every switch OFF, and every switch ON.

WHY. These are the boundaries of what $n$ switches can express. If we don't show them, a reader meets $00000000$ or $11111111$ and panics. They are simply the two ends of the range.

PICTURE. Left panel: $4$ switches all OFF → empty basket → value $0$ . Right panel: $4$ switches all ON → every box poured in → value $1 + 2 + 4 + 8 = 15 = 2^{4} - 1$ .

Step 7 — Edge case B: a leading zero and a switch that "isn't there"

WHAT. What does an extra zero on the left do? And what about a position with no switch at all?

WHY. Beginners fear $0011$ vs $11$ . We show a leading OFF switch contributes $0 \cdot 2^{i} = 0$ — it changes nothing about the value, only the width of the register.

PICTURE. $11$ and $0011$ side by side: the two extra OFF boxes on the left are empty, they pour in zero dots, both baskets hold $3$ .

The one-picture summary

Everything on this page in a single loop: count → halve repeatedly (peel bits) → weights are powers of two → multiply-and-add → same count. Encoding and decoding are two directions around one circle.

Recall Feynman retelling — explain the whole walkthrough to a 12-year-old

You've got a pile of $13$ marbles and a row of light switches. You keep bundling the marbles into pairs. Every time you bundle, either one marble is left over (flip that switch ON = 1) or none is (leave it OFF = 0). Do it again with the pairs, again with the pairs-of-pairs — each time noting the leftover on the next switch to the left. When the pile is gone, your switches read $1101$ from left to right (remember: the first leftover is the rightmost switch, so read your notes bottom-up!).

To turn switches back into marbles, give each switch a "worth" that doubles as you go left: $1, 2, 4, 8$ . Add up the worths of the ON switches: $8 + 4 + 0 + 1 = 13$ . You got your marbles back — proof the code is honest. If all switches are OFF that's $0$ ; if all are ON with four switches that's $8 + 4 + 2 + 1 = 15$ , the biggest four switches can say, which is always one less than the next doubling. And sticking extra OFF switches on the far left costs nothing — an empty box pours in no marbles. That's the entire idea behind every number a computer stores.

Recall Quick self-test

Encode $13$ by halving; the remainders are? ::: $1, 0, 1, 1$ (produced in that order) → read bottom-up → $1101$ . Decode $110 1_{2}$ . ::: $8 + 4 + 0 + 1 = 13$ . Value of $001 1_{2}$ vs $1 1_{2}$ ? ::: Both $3$ ; leading zeros add $0$ . Largest value in $4$ switches and why? ::: $15 = 2^{4} - 1$ ; $16$ patterns run $0..15$ , $0$ is counted. Where does the weight $2^{i}$ come from? ::: Grouping in twos $i$ times; each level up doubles the worth.

Connections

Boolean Algebra & Logic Gates — these ON/OFF bits are exactly what logic gates transform.
Logic Gates — AND/OR/NOT act on the individual switch states shown here.
Hexadecimal number system — bundles four of these switches (a nibble) into one compact symbol.
Two's complement — reuses the same weight-and-add idea, with the top weight made negative.
Memory addressing — the byte (8 switches) is the unit given an address.