When I was a boy, not so long ago, there was a thing called the cent sign.  It looked like this: ¢

It was the dollar sign's little brother, and lived on comic books covers and in newspaper advertisements and on pay phones and wherever anything was being sold for less than a buck.  It was a popular punctuation symbol—no question mark, or dollar sign, certainly, but just behind the * in popularity, and I daresay well ahead of #, &, and the now Internet-hot @.  It owned an unshifted spot on the typewriter keyboard, just to the right of the semicolon, and was part of every third grader's working knowledge.

In the late 1990s, you don't see many cent signs.  Why?  Because hardly anything costs less than a dollar anymore? Actually, the demise of the cent sign has little to do with inflation, and everything to do with computers.  And therein lies a tale.

In the 1960s a disparate group of American computer manufacturers (basically, everyone but IBM) got together and agreed on an encoding standard that became known as ASCII ("ass-key"—The American Standard Code for Information Interchange).   This standard simply assigned a number to each of the various symbols used in written communication (e.g., A-Z, a-z, 0-9, period, comma).  A standard made it possible for a Fortran program written for a Univac machine to make sense to a programmer (and a Fortran compiler) on a Control Data computer.  And for a Teletype terminal to work with a Digital computer, and so on.

So-called text files, still in widespread use today, consist of sequences of these numbers (or codes) to represent letters, spaces, and end-of-lines.  Text editors, for example, the Windows Notepad application, display ASCII codes as lines of text on your screen so that you can read and edit them.  Similarly, an ASCII keyboard spits out the value 65 when you type a capital 'A,' 65 being the ASCII code for 'A.'

The committee decided on a seven bit code; this allowed for twice as many characters as existing six bit standards, and permitted a parity bit on eight bit tape. So there were 128 slots to dole out, and given the various non-typographic computing agendas to attend to, it was inevitable that some common symbols, including several that had always been on typewriter keyboards, wouldn't make the cut.  (The typewriter layout had certain obvious failings in computer applications, for example: overloading the digit 1 and lower case L, so it couldn't be blindly adopted.)

Three handy fractions were cut:  ¼  ½  ¾.  This makes sense, especially when you consider that the ASCII committee was composed of engineers.  I'm sure they thought, in their engineer's way, "Why have ¼ but not 1/3?  And if we have 1/3, then why not 1/5?  Or 3/32?" Similarly, the committee apparently found $0.19 an acceptable, if somewhat obtuse, way of expressing the price of a Bic pen.  At any rate, the popular and useful cent sign didn't make it.

And so the cent sign was off keyboards, terminals, and printers.  Not that many people noticed right away.  The companies behind ASCII sold big, expensive computers that were used to run businesses, and few cared that there wasn't a cent sign character on one's new line printer.  Heck, if your printer could handle lower-case letters, you were state of the art.

But when personal computers began to appear in the late 1970s, the primary application driving their adoption was word processing.  These new small computers used the ASCII standard—after all, that's what standards are for.  By the millions, typewriter keyboards (with ¢) were traded in for Apple IIs and IBM PCs (without ¢).  While it's true that the cent sign was ultimately made part of other larger encoding standards, and is possible to create at modern PCs with a little effort—the damage had been done.  Without a cent key in front of them, writers of books, newspapers, magazines, and advertisements made do without. And over time, $0.19 began to look like the right way to say 19¢.  In another few years the cent sign will look as alien as those strange S's our forefathers were using when they wrote the constitution.

Appendix S

With a little effort, ASCII can express more than words.  Presented for your amusement: Bart, Homer, and Marge Simpson.

|      |
|      |
| (o)(o)
C      _)
| ,___|
|   /

   /       \
 \/\/      |
  |   (o)(o) 
  C    .---_)
   |  |.___|
   |   \__/
  /______/ \
        ,_C     (##)
       /____,   (##)
         \     (#)
          |    |

Appendix E    ASCII Printable Character Set

The cent sign's omission was especially unfair when you go down the list and consider the characters that did get in, including several that had never had a role in our language.  For example, backslash: \—just like a slash, only backwards.  That's not confusing at all.  Hell no.  Then there's the accent characters that represented ASCII's half-hearted effort to support European languages:  The grave: ` (backward accent).  The tilde: ~  The circumflex: ^ And six slots went to the exotic parentheses sets, beloved by programmers but hardly anyone else:  [ ],   { }, <>.  When was the last time you saw one of these symbols in the newspaper?

Here's what the ASCII committee came up with.  I've skipped slots 0-31, because they're "control characters"--codes without a printable equivalent.  I will say that there's lots of waste in the first 32 positions—-many made ancient printers and communications devices jump through obscure hoops. A few are still in use, including the tab (code 9) and end-of-line characters (10 and 13)*. 

Value Character


The good old space!  Often overlooked, and hard to draw (except maybe with a Lindy pen), butwithoutitstuffwouldbeveryhardtoread.
33 ! Without the exclamation point, email and chat rooms would be quieter places.   Should be a law about using more than one per paragraph, and I think there is a law about using more than one in a row!!!
34 " Thanks, but it would've been even nicer to have true open and close double quotes.  There don't seem to have been any typographers on the committee.
35 # Pound sign gets in and cent sign doesn't? A miscarriage of justice.
36  $ No way was this power symbol going to be left out.
37  % Had it made the cut, perhaps ¢ would have gone right here, right next to the dollar sign.
38  & Ma Bell was part of the committee, so ampersand was a given.
39  ' Again, it would have been nice to have open and close single quotes. The ASCII apostrophe is functional, but ugly.
40 (
41  )
42  *
43  +
44  , The comma, punctuation superstar
45  - The hyphen a.k.a. minus sign.  Would've been nice to have an em-dash too.
46   . The period, a.k.a. decimal point, a.k.a. dot, punctuation megastar.
47   / The handy, work-a-day slash.  Not to be confused with its evil twin, backslash.
48   0 The decimal digits are in order (the Committee may have blown it on the cent sign, but they weren't dummies). Subtract 48 from an ASCII digit and you have its value. 
49   1
50   2
51   3
52   4
53   5
54   6
55   7
56   8
57   9
58   : Did the Committee foresee Emoticons?  : )
59   ; . . . I doubt it.    ;  )
60   < Angle brackets.  Useless to most, crucial to programmers for expressing greater than/less than numerical relationships.  --> They also make cool arrowheads. <--
61   =
62   >  
63   ?
64   @ The at sign—90s email superstar, 60's nobody.  You had to shift the cent key to get @ on typewriters.
65   A The 26 uppercase alphabetic characters begin here; the order is unsurprising.  Lowercase begins 32 (not 26) codes later.  This is why simple-minded sort code places words in caps ahead of lowercase, e.g.,   "CAT" < "DOG" < "cat" < "dog"
66   B
67   C
68   D
69   E
70   F
71   G
72   H
73   I
74   J
75   K
76   L
77   M
78   N
79   O
80   P
81   Q
82   R
83   S
84   T
85   U
86   V
87   W
88   X
89   Y
90   Z
91   [ Square brackets. 
92   \ The infamous backslash.  What were they thinking? 
93   ]
94   ^ When was the last time you typed this character?  Admittedly, it's handy for drawing up-arrows, but since there's no down arrow, why bother?
95   _ The underscore.  Handy in forms, and programmers_Use_It_To_Create_An_Illusion_Of_Space where the language doesn't permit a real space.
96   ` Grave (backward) accent.  In this country, obscure in the extreme.
97   a The lower case alphabet starts at 97; each letter has the same value as its uppercase counterpart plus 32.  In binary form, they're identical, except for a single bit. 
98   b
99   c
100   d
101   e
102   f
103   g
104   h
105   i
106   j
107   k
108   l
109   m
110   n
111   o
112   p
113   q
114   r
115   s
116   t
117   u
118 v
119   w
120   x
121   y
122   z
123   { Curly braces.  Another programmer-mostly ASCII-ism.  Can't get far in C or its derivatives without them.
124   | The vertical bar.  A waste of a slot.  You can make perfectly good boxes with exclamation points.
125   }


~ The tilde.  Generally only used by programmers looking for obscure characters to exploit.
127   DEL Committee member AT&T required this last slot,  111 1111 in binary, be a control character.  You won't see this character in text files, but it's what a keyboard spits out when you press the delete key.

*60's workhorse Teletype printers required two control characters to start a new line: a carriage return (ASCII code 13) to return the print head to the left margin, and a line feed (ASCII code 10) to roll the paper up a smidge.  Over time, Unix computers standardized on line feed as its text file line delimiter; Macintosh computers went with carriage return.  PC text files usually contain a matched CR/LF pair.  Sigh.

Back Home Up Next

www.CharlieAnderson.com  •  Since 1998, Your Home for Charlie Anderson Information  •  Send me email: info@charlieanderson.com 

All Content © 1998-2002 Charles R. Anderson  •  This page was last modified on 11/13/2003