ASCII : Java Glossary

Introduction

• If I said, "That word processing file is vanilla ASCII ", it means it contains no formatting characters — just the control characters, letters A to Z, digits 0 to 9 and punctuation
• If I said "That file is ASCII not EBCDIC", it means your file encodes the letter A as the number 65, B as 66 etc., rather than some other method.
• If I said "That file is pure ASCII , no high bit characters" it means the file contains just the ordinary characters — no accented letters or line drawing set.
• If I said "I’m going to send this to you in raw ASCII protocol" it means I will be just sending you the raw characters, with nothing extra to help detect or correct errors — just the raw keystrokes.
• You might wonder why '0' is not assigned binary code 0. Back in the days of paper tape, blank tape was binary code 0000000, which was sloughed over. So 0 had to be assigned the null control code. Further, you could erase tape by punching out all the holes, so binary 1111111 had to be assigned the control code del.

ASCII has been expanded in many different ways with codes 128 to 255. The most common is called Latin-1. A number of new entities have been added since I wrote the list part of the HTML Cheat Sheet.

ASCII and Latin-1 Character Table

^A means control-A, the code you generate by holding down the Ctrl key and tapping A.

If the left hand column does not render properly, it means your browser is ignoring the Latin-1 charset command

or you don’t have a font installed that can display the Latin-1 characters.

Memorising ASCII Ordering

Since ASCII ordering is so common, it helps to memorise the order: Here are a few rules to help you remember:

• Digits come before upper case letters, which come before lower case letters. This parallels the order they were invented. Control characters come before everything with one DEL control character at the very end. The DEL oddity is a legacy of paper tape, where you could erase a character by poking out all the holes, i.e. binary 1111111 hex 7F.
• < = > occur in natural order.
• Space comes after the control characters, before the visible characters since it is a printable but not visible character.
• @, circled a, comes just before A.
• There are four groups of punctuation chars:
  1. before the digits (arithmetic and friends) ! " # $ % & ' ( ) * +, -. /

     You can think of this group as further broken into three groups:

     1. The punctations starts off the with a bang (!).
     2. There is a commercial group # $ % & (as in Abercrombie & Fitch), sandwiched between " and '.
     3. There is the group for doing arithmetic () + , - . /. The order within the group makes no sense.
  2. before the upper case letters (comparison and friends) : ; < = > ? @
  3. before lower case letters (square brackets and friends) [ \ ] ^ _ `
  4. after lower case letters (curly braces and friends) { | } ~

To help you remember, you might create Dymo labels for the four groups of punctuation and stick them on your keyboard. Unfortunately, they bear little resemblance to the punctuation order on the keyboard itself. Or print this summary on a sticky label for your keyboard:

ASCII does not have a Start Of Message of End Of Message character.

History

I remember having a conversation with Verne Detwiler (later of McDonald Detwiler fame) at UBC (University of British Columbia) about the character set of our new IBM (International Business Machines) 7044 computer. Back then every site devised its own character set and had printers designed to print it. He was showing us a new character set called ASCII that was the coming thing. Back then how you encoded it on punch cards was also important. Lower case was exotic.

ASCII’s Warts

ASCII has some strange warts:

• The punctuation is broken into four groups. It should have been contiguous.
• The control char ranges are broken into two. DEL had to be all ones, since it was used in paper tape code to erase by poking out all the holes.
• _ is a sort of space. It should sort right after space.
• [ and ] are not contiguous as ( and ) are.
• { and } are not contiguous as ( and ) are.
• The arithmetic operators should be contiguous. They are interrupted by , and .

At at least 0-9, A-Z and a-z are separately contiguous.