Binary & ASCII — Full Reference Chart

A computer never stores the letter A. It stores the number 65, and only displays it as "A" because a shared table — almost always ASCII, or something built to stay compatible with it — says 65 means capital A everywhere. Binary is simply that same number written using only two digits, 0 and 1, instead of the ten digits (0-9) most people are used to. Understanding binary and ASCII together, rather than treating binary as its own mysterious code, is the fastest way to actually understand what's happening when text moves through a computer at all.

Binary Is Just Counting With Two Digits Instead of Ten

In decimal (base 10), each digit position is worth ten times the position to its right: ones, tens, hundreds. In binary (base 2), each position is worth exactly two times the position to its right: ones, twos, fours, eights, sixteens, and so on, doubling every step. The byte 01000001 reads, from left to right, as 0 sixty-fours, 1 sixty-four, 0 thirty-twos, 0 sixteens, 0 eights, 0 fours, 0 twos, 1 one — adding the "on" positions gives 64 + 1 = 65, which is exactly ASCII's code for capital A. There's no separate binary alphabet to memorize; it's the same numbers as always, just spelled with two digits instead of ten.

ASCII's Origin: A Committee, Not One Inventor

ASCII (American Standard Code for Information Interchange) began as a coordination problem, not an invention. Through the early 1960s, different computer and teleprinter manufacturers used incompatible character codes, so text created on one company's machine could come out as garbage on another's. The American Standards Association's X3.2 subcommittee, with representatives from the major computer makers of the era, took on the job of agreeing a single table, and the result — X3.4-1963 — was formally published on 17 June 1963. That first version was a 7-bit code (128 possible values) and, notably, didn't even include lowercase letters; those, along with several other refinements, were added in the 1967 revision once the committee had more real-world implementation experience to draw on.

Why 7 Bits Became an 8-Bit Byte

ASCII itself only strictly needs 7 bits (128 values) to cover its full character set — 26 uppercase letters, 26 lowercase, 10 digits, standard punctuation, and a set of non-printing control codes originally meant for controlling teleprinters and modems, like carriage return and line feed. Computer hardware, though, converged on an 8-bit byte as its basic unit of storage, one bit wider than ASCII strictly required. That spare 8th bit became a practical extension slot: various "extended ASCII" variants used it to add another 128 characters — accented letters, box-drawing symbols, currency signs — but different vendors filled that extra 128 differently, which recreated exactly the kind of incompatibility ASCII had been built to solve in the first place, just one level up.

The Character Table, Grouped by What It's For

• Codes 0-31 and 127: control codes — non-printing instructions like line feed, carriage return, tab and the original "delete" signal, inherited from teleprinter and early terminal hardware rather than meant to be read as text.
• Codes 32-47: space and punctuation — including the space character itself at 32, deliberately placed before any printable symbol so that sorting text numerically also sorts it in a sensible reading order.
• Codes 48-57: the ten digit characters '0' through '9', assigned consecutive codes specifically so a digit's ASCII value minus 48 gives its actual numeric value — a shortcut real code relies on constantly.
• Codes 65-90: uppercase A-Z, and codes 97-122: lowercase a-z — each letter's lowercase code is exactly 32 higher than its uppercase code, letting software convert case by flipping a single bit rather than a full lookup.

Why UTF-8 Had to Be Invented

128 or even 256 characters is nowhere near enough for the world's writing systems, let alone modern emoji. Unicode set out to assign a unique number to every character in every script, which by now covers well over 140,000 characters — far too many to fit in a single byte. UTF-8, designed in 1992 by Ken Thompson and Rob Pike (best known for their earlier work on Unix and the Go programming language), solved the transition problem elegantly: every one of ASCII's original 128 characters keeps the exact same single-byte value it always had, so any plain ASCII file is already valid UTF-8 with zero conversion needed, while every character outside that original range is automatically spread across two, three, or four bytes using a specific pattern of leading bits that marks a byte as "the start of" or "a continuation of" a multi-byte character. That backward compatibility is a large part of why UTF-8 became the dominant text encoding on the modern web rather than a competing, incompatible design.

Where a Naive Binary Converter Breaks

A tool that assumes one character always equals one byte works perfectly for plain English text and breaks the moment it meets an emoji, an accented letter, or most non-Latin script — because those characters are UTF-8 multi-byte sequences, not single ASCII bytes. Treating each of those bytes as if it were its own independent ASCII character produces exactly the kind of scrambled, unreadable output sometimes nicknamed "mojibake" — a real, well-documented failure mode any programmer working with international text runs into eventually, not a sign the tool is fundamentally broken, just a sign it's assuming a narrower character set than the actual input uses.

Hexadecimal as Binary's Shorthand

Because reading and typing long strings of 1s and 0s by hand is slow and error-prone, hexadecimal (base 16) is almost always used as a denser stand-in when a person, rather than a machine, needs to look directly at raw byte values — memory dumps, color codes, network packet inspection. Each hex digit represents exactly four binary digits, so a full byte converts cleanly to exactly two hex digits: 01000001 (65 in binary) is 41 in hex, a considerably shorter and less error-prone string to read, copy, or type correctly than eight binary digits.

Binary Shows Up in More Places Than Just Text

Character encoding is only one use of binary — the same base-2 counting shows up any time a system needs to store a fixed, limited set of on/off or numeric states efficiently. Unix and Linux file permissions are a direct, visible example: the familiar three-digit permission number (like 644 or 755) is actually three separate 3-bit binary groups, one each for owner, group and everyone else, where each bit independently controls read, write and execute access — which is why permission numbers only ever use the digits 0 through 7, never 8 or 9. Networking uses binary just as directly: an IPv4 address like 192.168.1.1 is really four 8-bit binary numbers (each one capped at 255, the largest value 8 bits can represent) written in decimal purely for human convenience, and "subnet masks" in networking are literally binary patterns marking which bits of an address are fixed versus assignable.

Control Codes Didn't Disappear — They Moved

ASCII's original non-printing control codes were built for physical teleprinters and modems, but a surprising number are still working quietly today in a different form. The "escape" character (code 27) that once told a teleprinter to switch modes is the same escape character that opens every modern terminal color and cursor-movement sequence — when a command-line tool prints colored text, it's sending an escape code followed by formatting instructions, a direct descendant of a 1963 control code repurposed for a use case that didn't exist yet when it was defined. The "bell" code (7), which once rang an actual physical bell on a teleprinter to get an operator's attention, still triggers a beep or a flashing taskbar icon in many terminal programs today — a 60-year-old design decision still doing recognizably the same job.

A Worked Example: "OK"

O is ASCII 79 (01001111 in binary, 4F in hex) and K is ASCII 75 (01001011 in binary, 4B in hex). "OK" becomes 01001111 01001011 in binary — two clean 8-bit bytes for two plain-ASCII characters, which holds exactly as long as every character involved stays inside ASCII's original 128 values.