Text as Numbers

You now know computers only store numbers. But you're reading text right now, and you'll spend this whole course feeding text to language models. So somewhere, there must be an agreement that says which number means which character. That agreement is the story of this lesson: ASCII, then Unicode.

The problem

Early computing was chaos: every manufacturer invented its own character-to-number table. A file written on an IBM machine was gibberish on anything else. The fix, in 1963, was ASCII — the American Standard Code for Information Interchange: one shared table mapping 128 characters to the numbers 0–127.

Some anchors worth knowing:

'A' = 65    'B' = 66    ...   'Z' = 90
'a' = 97    'b' = 98    ...   'z' = 122
'0' = 48    '1' = 49    ...   '9' = 57
space = 32          newline = 10

Notice the design: the alphabet is contiguous, and lowercase is exactly uppercase + 32. That's not an accident — 32 is a single bit in binary, so early hardware could switch case by flipping one bit.

So the word Hi is stored as the numbers 72, 105 — which, from the last lesson, are stored as the bits 01001000 01101001.

Explore the table

Type into the explorer below and watch characters become numbers. Try your name. Try uppercase versus lowercase versions of the same letter and check the +32 pattern. Try a digit like 7 and notice its character code is not 7.

The problem with ASCII: it's American

128 slots covers English letters, digits, and punctuation — and nothing else. No é, no ñ, no Greek, Hindi, Arabic, Chinese, and certainly no 🎉. Through the 80s and 90s, every region bolted on its own incompatible extension for numbers 128–255, and cross-border text exchange became mojibake roulette (more on mojibake in the next lesson).

The fix was radical: one table for every character in every human writing system. Unicode.

Code points

A Unicode number is called a code point, conventionally written as U+ followed by the value in hexadecimal (base 16 — a compact way to write binary that you'll see everywhere in computing):

'A'  = U+0041   (decimal 65 — same as ASCII)
'é'  = U+00E9   (decimal 233)
'न'  = U+0928   (decimal 2344 — Devanagari na)
'中' = U+4E2D   (decimal 20013)
'🎉' = U+1F389  (decimal 127881)

Every language exposes this mapping:

ord('A')        # 65
ord('🎉')       # 127881
chr(127881)     # '🎉'

"A".codePointAt(0)        // 65
"🎉".codePointAt(0)       // 127881
String.fromCodePoint(127881)  // '🎉'

Why AI engineers care

Language models never see characters. Text is converted to numbers before anything else happens — and character encoding is step zero of that pipeline. Concretely:

• Tokenizers start from this. Modern LLM tokenizers typically operate on the UTF-8 bytes of your text. Odd model behavior with emoji, accents, or non-English text often traces straight back to how those characters map to numbers.
• String length is ambiguous. Is 🎉 one character? One code point? Four bytes? Two JavaScript "characters"? All of these answers are correct in different systems — and that ambiguity causes real bugs in context-length math and API payloads.

Build it yourself

Implement a Caesar cipher — the ancient trick of shifting each letter forward in the alphabet — using character codes:

def caesar(text, shift):
    out = ""
    for ch in text:
        code = ord(ch)
        if 65 <= code <= 90:              # uppercase A-Z
            out += chr((code - 65 + shift) % 26 + 65)
        elif 97 <= code <= 122:           # lowercase a-z
            out += chr((code - 97 + shift) % 26 + 97)
        else:
            out += ch                     # leave everything else alone
    return out

print(caesar("Hello, World!", 3))   # Khoor, Zruog!

Verify that caesar(caesar(s, 3), -3) returns the original. Then try feeding it "café 🎉" — notice the non-ASCII characters pass through untouched, because the code checks numeric ranges. That's character-code thinking in action.

Summary

• Computers store numbers, so text needs a shared character-to-number table.
• ASCII (1963) maps 128 English characters to 0–127; A = 65, and lowercase = uppercase + 32.
• Unicode extends this to every human language: each character gets a unique code point like U+1F389, and the first 128 match ASCII exactly.
• A code point is an abstract ID, not bytes in memory — encoding (UTF-8) is the next step.
• LLM tokenizers sit directly on top of this machinery; encoding quirks explain much odd model behavior with emoji and non-English text.