Bases: Binary, Decimal, Hex

You already count in base ten — you've done it your whole life without calling it that. This phase shows you that base ten is one choice among many. Once you see the pattern underneath it, binary and hex stop being cryptic computer trivia and become the same idea in different clothes.

If numbers still feel like they're out to get you, the calmer framing in Why Math Isn't Your Enemy pairs well with this. Nothing here requires it, though.

Positional notation: the idea under every number system

Look at the decimal number 234. You read it instantly as "two hundred thirty-four," but notice how the meaning is built. The same digit means different amounts depending on where it sits:

  234
  │││
  ││└─ 4 in the ones place    →  4 × 1   = 4
  │└── 3 in the tens place    →  3 × 10  = 30
  └─── 2 in the hundreds place →  2 × 100 = 200
                                 ─────────────
                                  total   = 234

Each place is a power of ten:

234 = 2×10² + 3×10¹ + 4×10⁰
    = 2×100 + 3×10  + 4×1

That number ten is the base. Here's the cleanest definition you'll get: the base is how many digits you have before you run out and have to carry. Decimal has ten digits (0 through 9). Count past 9 and there's no single symbol left, so you carry: 9 rolls over to 10.

Why this matters: nothing about positional notation is special to ten. Pick any base b, and the places become powers of b. Change the base, keep the machinery. That one insight unlocks binary and hex.

Binary (base 2): two digits, powers of two

Binary uses exactly two digits: 0 and 1. With only two symbols, you carry much sooner — after 1 you're already out, so 1 + 1 = 10 in binary (which is two, not ten). The places are powers of two instead of powers of ten:

place values:  ... 16   8   4   2   1
                   2⁴  2³  2²  2¹  2⁰

Let's convert 1011₂ to decimal. (The little ₂ means "this is base 2," so you don't mistake it for one thousand eleven.) Read each digit against its place value and add up the ones that are switched on:

   1    0    1    1     ← binary digits
   8    4    2    1     ← place values
   ─    ─    ─    ─
   8 +  0 +  2 +  1  =  11

So 1011₂ equals 11 in decimal. A binary digit is called a bit, and a bit is a yes/no: is this place value included or not?

Going the other way: decimal to binary by repeated division

To turn a decimal number into binary, repeatedly divide by 2 and write down the remainder each time. The remainders, read bottom-to-top, are the binary digits. Let's convert 13:

13 ÷ 2 = 6  remainder 1   ← least significant bit (bottom)
 6 ÷ 2 = 3  remainder 0
 3 ÷ 2 = 1  remainder 1
 1 ÷ 2 = 0  remainder 1   ← most significant bit (top)

Read the remainders from bottom to top: 1101. Check it: 8 + 4 + 0 + 1 = 13. It works because each division strips off the smallest place value and asks "is it odd?" — and odd-or-even is exactly what the bottom bit records.

Hex (base 16): a compact shorthand for binary

Hexadecimal — "hex" — is base 16. That's a problem at first glance: we only have ten digit symbols (0–9), and base 16 needs sixteen. The fix is to borrow letters. After 9, hex keeps counting with A through F:

hex:      0 1 2 3 4 5 6 7 8 9 A  B  C  D  E  F
decimal:  0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

So A is ten, F is fifteen. The places are powers of sixteen. Convert 2F₁₆ to decimal:

   2          F
   ↓          ↓
   2×16¹  +  15×16⁰
   = 32   +  15
   = 47

So 2F₁₆ = 47. Going back uses repeated division by 16, the same trick as binary — but nobody does that by hand, because of the real reason hex exists, which is the next section.

Why these bases: hardware, and human eyes

Computers use binary because the physical hardware has two stable states. A transistor is either conducting or not; a wire is either at high voltage or low. Two clean states map perfectly onto 1 and 0 — no ambiguity, no in-between to misread. Everything a machine "knows" is built from billions of these on/off switches, combined by logic gates (the building blocks you'll meet properly in a hardware guide). Binary isn't a stylistic choice; it's what the silicon can physically hold.

Humans use hex because raw binary is exhausting to read. Eight bits look like 11111111 — easy to miscount. But here's the magic: one hex digit is exactly four bits. Four bits can represent 0 through 15, and so can one hex digit, so they line up perfectly. Group a binary string into chunks of four and translate each chunk to a single hex digit:

1111 1111   ← eight bits, split into two groups of four
  F    F    ← each group → one hex digit
=  FF

11111111₂ is FF₁₆. Hex is binary for human eyes: same information, four times shorter, far harder to miscount.

See it run

Python understands all three bases directly, which makes it a great place to check your hand-conversions. Run this:

print(0b1011)        # binary literal -> 11
print(0xFF)          # hex literal    -> 255
print(int("1011", 2))  # parse binary string
print(bin(11))       # decimal -> binary string
print(hex(255))      # decimal -> hex string

What just happened: The prefix 0b tells Python "the following digits are binary," so 0b1011 is evaluated as 8 + 2 + 1 = 11 and prints 11. The prefix 0x means hex, so 0xFF is 15×16 + 15 = 255 and prints 255. int("1011", 2) takes the string "1011" and the base 2, parsing it as binary — again 11. Going the other direction, bin(11) converts the decimal 11 into a binary string and prints 0b1011, and hex(255) converts 255 into a hex string and prints 0xff (Python writes hex letters in lowercase). Notice the round trips: 0b1011 and bin(11) are the same number seen from both sides, and so are 0xFF and hex(255).

For builders

A few things you'll bump into constantly once you're writing code:

• Literals. Most languages let you write numbers in binary with a 0b prefix and in hex with 0x. So 0b1010, 0xFF, and 255 can all describe the same or related values — they're only different spellings.
• A byte is 8 bits. It's the standard chunk of memory. One byte holds 256 distinct values, 0 through 255.
• 0xFF = 255. Two hex digits cover exactly one byte (4 bits + 4 bits), so hex is the natural way to write byte values. 0x00 is 0, 0xFF is 255.
• CSS colors are hex. A color like #FF8800 is three bytes — red FF (255), green 88 (136), blue 00 (0) — written as six hex digits. Now you can read them: #FFFFFF is all channels maxed (white), #000000 is all off (black).

⚠️ Gotcha: One hex digit is exactly four bits — never three, never five. That's the whole reason hex is convenient. When you read a binary string, mentally chop it into groups of four from the right, and each group becomes one hex digit. Grouping from the left instead will give you the wrong answer if the length isn't a multiple of four.

Recap

• Positional notation gives every digit a place value that's a power of the base; the base is how many digits you have before you carry.
• Binary is base 2 (digits 0,1; place values are powers of two). Convert to decimal by adding the place values that are on; convert from decimal by repeated division by 2, reading remainders bottom-up.
• Hex is base 16 (digits 0–9 then A–F for 10–15). Its superpower: one hex digit equals exactly four bits, so it's a compact, readable shorthand for long binary strings.
• Computers store binary (two stable hardware states); humans read hex because it's binary that's four times shorter and easier on the eyes.

Quick check before you move on:

[
  {
    "q": "What base is the binary number system?",
    "choices": ["Base 10", "Base 2", "Base 8", "Base 16"],
    "answer": 1,
    "explain": "Binary uses exactly two digits, 0 and 1, so it is base 2. Its place values are powers of two."
  },
  {
    "q": "What is the decimal value of the binary number 1010₂?",
    "choices": ["5", "8", "10", "12"],
    "answer": 2,
    "explain": "Place values from the right are 1, 2, 4, 8. The on bits are the 8 and the 2: 8 + 0 + 2 + 0 = 10."
  },
  {
    "q": "Why do people write binary values in hexadecimal?",
    "choices": [
      "Hex can store larger numbers than binary can",
      "Each hex digit is exactly 4 bits, so hex is a compact, readable shorthand for binary",
      "Computers can only understand hex, not binary",
      "Hex avoids the need for the digit zero"
    ],
    "answer": 1,
    "explain": "One hex digit maps to exactly four bits, so a long binary string becomes four times shorter and far easier to read without changing the underlying value."
  }
]

← Phase 1: The Families of Numbers · Guide overview · Phase 3: Modular Arithmetic: Clock Math →