ASCII
The code approved on 17 June 1963 had no small letters in it. Not a shortage of them: none. When the 1967 revision put them in, it placed every one directly below its capital, and that decision is the reason your keyboard's Shift and Ctrl keys are bit operations rather than software.
A character, its row, and the bits that pick the column
Type any character. The table is seven bits wide: three choose the column and four choose the row, so the eight characters below share their low four bits and differ only in the top three.
Row 11. Every one of these is 1011 in its low four bits.
- position
- 4/11
- seven bits
- 100 1011
- with Ctrl
- VT, at 0/11
- with Shift
- k, at 6/11
- in the 1963 code
- yes
Ctrl clears the top two bits and Shift clears the next one down. Neither key looks anything up.
What 1963 did not have
The first ASCII was approved on 17 June 1963 with twenty-eight positions left deliberately empty, reserved for later standardisation. Two whole columns of the table, the ones a small letter would need, were among them. A teleprinter of that year printed capitals and that was the alphabet.
Turn on the 1963 view above and the table thins out. What is missing is not decoration; it is half the letters anybody writes.
What 1967 did with the space
The revision could have put the small letters anywhere. It put each one in the same row as its capital, two columns to the right, which means one bit apart. All twenty-six pairs, the same bit every time. That is not a coincidence to admire, it is a specification choosing to make a later problem cheap.
The consequence is everywhere and mostly invisible. Case folding is an XOR with a single value. A keyboard's Shift key, for a letter, clears one bit on its way out. Control clears the two above it, which is why Ctrl and a letter lands you in the control column of the same row: hold Ctrl and press K and what a terminal receives is the character at 0/11, which is VT, vertical tab.
Put that against Baudot, ninety years earlier, and the thread finishes itself. Baudot also needed more characters than his bits allowed, and he bought them with a shift character: a code sent down the wire that changed what every following code meant, until something cancelled it. It cost a whole character, and it stayed in effect, so a lost shift corrupted everything after it. ASCII moved the same idea inside the character, where it costs nothing and cannot be lost.
What is real here, and what is not
The structure is derived, not tabulated
There is no table of characters in this page's code except the thirty-two control names, which are names and cannot be computed from a number. Everything else is arithmetic on one sentence from the standard: the top three bits give the column, the bottom four give the row. The row of eight, the positions, the effect of each modifier, all of it falls out of that. The test checks the derivation against the code chart in the archived copy of RFC 20, cell by cell.
Shift is only shown for letters, on purpose
The bit that turns a capital into a small letter does something to every other character too, and it is usually nonsense: applying it to 4 gives t. A page that showed that as "Shift" would be describing a keyboard nobody has. So the readout says nothing for characters where the operation is not what the key does.
The 1963 view is a simplification, and here is its edge
The page shows the 1963 code as the first six columns. That is right about the letters, which is what the page is about, and it is rough at the margins: the 1963 standard did assign a few positions in the last two columns and left others open, and several punctuation marks moved between the two revisions. If you want the exact 1963 chart, the annotated history linked below reproduces it. This page's claim is narrower than that chart and is the one it can support: in 1963 there were no small letters.
Nothing here is a terminal
Pressing Ctrl on your own keyboard while this page is open will do whatever your browser does. The page is showing you what the code says those keys mean, not intercepting them, and it deliberately does not capture keystrokes: a page about a control character that swallowed Ctrl-W would be a bad joke on anyone who tried to close it.
Seven bits, and where the eighth went
ASCII is seven bits and 128 codes. It is almost always carried in an eight-bit byte, and what the spare bit did varies: parity on a teleprinter line, a second half of the character set later, or nothing at all. RFC 20's own instruction for the ARPANET was to embed the seven bits in a byte whose high order bit is always 0
. That is one choice among several and this page does not model any of them.
Sources
- RFC 20, ASCII format for Network Interchange, Vint Cerf, October 1969, which reprints the code chart of USAS X3.4-1968 in full and is itself an internet standard, STD 80. Everything structural on this page is checked against this document: the complete table, and the sentence defining it, that the column is bits b7 b6 b5 and the row is b4 b3 b2 b1.
- IEEE Milestone: ASCII, 1963, for the approval date of 17 June 1963.
- Tom Jennings, An annotated history of some character codes, which reproduces the 1963 chart and the 1967 one and walks through what moved between them. The place to go for the margins this page rounds off.
- Baudot, on this site, for the shift that cost a whole character and stayed in effect until cancelled.