Alphanumeric Code

Table of Contents
1. Alphanumeric Codes
2. Types of Alphanumeric Code
3. Morse Code
4. Baudot Code
5. Hollerith Code
6. American Standard Code for Information Interchange (ASCII)
7. Extended Binary Coded Decimal Interchange Code (EBCDIC)
8. Unicode
9. Comparison and Practical Notes
View more

Alphanumeric Codes

Earlier computers were used primarily for numerical calculations. Modern digital computers, however, must represent and process non-numeric information such as names, addresses, descriptions and punctuation. Such information is called alphanumeric data and is represented inside a computer as sequences of binary digits (0 and 1). The mapping between characters (letters, digits, punctuation and control symbols) and binary patterns is provided by alphanumeric codes, also called character codes. These codes make it possible to interface input/output devices such as keyboards, displays and printers with the internal binary representation used by a computer.

Many coding techniques have been developed to represent characters as sequences of bits. Early well-known codes include Morse code and the Hollerith punched-card code. Today the most widely used schemes are ASCII and EBCDIC, and a more recent universal scheme is Unicode. Each code has its historical context, advantages and limitations.

Types of Alphanumeric Code

Morse Code

The Morse code was invented in 1837 by Samuel F. B. Morse for telegraphy. It represents letters, numerals and some punctuation by standardized sequences of short and long signals (commonly called dots and dashes). A dash is treated as the time duration of three dots; letters are separated by short gaps and words by longer gaps.
For example, the letter A is represented by dot-dash and the digit 5 by five dots in succession. Because Morse characters have variable lengths, the code is not directly suitable for automated fixed-length digital circuits and is largely superseded in electronic systems by fixed-length binary codes. Morse code is still used in specialised telegraph and radio applications and retains limited use in aviation and amateur radio.

Baudot Code

The Baudot code was developed by the French engineer Émile Baudot around 1870. It is a fixed-length 5-unit code (five bits) in which every symbol has equal duration. Baudot allowed efficient teleprinter transmission of letters, numerals and some control functions by using character-shift mechanisms (for example, separate letter and figure states).

Hollerith Code

Herman Hollerith developed punched-card tabulating equipment in the late 19th century; the punched cards and their coding are commonly referred to as Hollerith cards. A Hollerith card used 12 possible punch rows (often numbered 12, 11, 0, 1, 2, ..., 9) and combinations of punches in those rows encoded characters and numeric fields. Hollerith encoding uses combinations of punches in 12 rows; this can be mapped to a 12-bit binary pattern for modern representation, but it was not originally a binary code.
When Hollerith data were printed or transferred to character devices, various mapping conventions were used. One such convention maps the 12 bits into two 6-bit groups (each sometimes represented inside an ASCII or other character with added control bits) so the 12-bit Hollerith pattern could be carried through systems expecting smaller character widths. With the disappearance of punched cards, Hollerith encoding is now mostly of historical interest.

American Standard Code for Information Interchange (ASCII)

The American Standard Code for Information Interchange (ASCII, pronounced "as-kee") is a character encoding that originated from telegraphic codes and was standardised in the 1960s. The original standard defines a 7-bit code, allowing 128 distinct code points. These include 95 printable characters (26 uppercase letters A-Z, 26 lowercase letters a-z, 10 digits 0-9 and various punctuation and symbols) and 33 control characters (for device control and text formatting).
The 7-bit ASCII code assigns to each character a pattern X₆ X₅ X₄ X₃ X₂ X₁ X₀ where each X is 0 or 1. For human readability the bits are often grouped when shown; for example the letter D is represented as 1000100 and the letter A has X₆ X₅ X₄ = 100 and X₃ X₂ X₁ X₀ = 0001, giving 1000001 in 7-bit form. The digit 9 has X₆ X₅ X₄ = 011 and X₃ X₂ X₁ X₀ = 1001, giving 0111001.

An 8-bit form of ASCII (often called ASCII-8 or extended ASCII) became common because most computers organise data in 8-bit bytes. In many systems the eighth bit was used as a parity bit for simple error detection on communication lines or set to 0 when parity was unused. When the eighth bit is used only as parity, the 7-bit ASCII pattern still determines the character value and the eighth bit is used for error checking.

Examples

Example 1: With an ASCII-7 keyboard, each keystroke produces the ASCII equivalent of the designated character. Suppose that you type PRINT X. What is the output of an ASCII-7 keyboard?
Solution:
The ASCII-7 equivalent of P = 1010000
The ASCII-7 equivalent of R = 1010010
The ASCII-7 equivalent of I = 1001001
The ASCII-7 equivalent of N = 1001110
The ASCII-7 equivalent of T = 1010100
The ASCII-7 equivalent of space = 0100000
The ASCII-7 equivalent of X = 1011000
Concatenating these bit patterns yields the output binary string 10100001010010100100101001110101010001000001011000. The hexadecimal byte values (ASCII-8 with MSB = 0) are 50 52 49 4E 54 20 58.

Example 2: A computer sends a message to another computer using an odd-parity bit. Here is the message in ASCII-8 code. Assuming MSB is parity and remaining 7 bits are ASCII.
10110001
10110101
10100101
10100101
10101110
Solution
Translating the 8-bit numbers to ASCII characters gives the sequence Q U E E N.
Therefore the received message decodes to QUEEN.

Extended Binary Coded Decimal Interchange Code (EBCDIC)

The Extended Binary Coded Decimal Interchange Code (EBCDIC, pronounced "ee-bee-see-deck") is an 8-bit character encoding developed by IBM. Numerals 0-9 in EBCDIC are related to the 8421 BCD representation preceded by a prefix pattern in the high bits; the full 8-bit space allows up to 256 distinct code points.

EBCDIC does not use a simple sequential binary order for letters and symbols as ASCII does. Instead characters are arranged in blocks in the 8-bit space. When reading tables it is common to separate the eight bits into two groups of four (high nibble and low nibble) and represent each nibble in hexadecimal, so each EBCDIC code can be expressed as two hexadecimal digits. For example, in a common EBCDIC table the letter A is represented by the 8-bit pattern 11000001 and B by 11000010. Other characters such as '=' and '$\prime havetheirownEBCDICcodes(forexample\prime =\prime \to 01111110inthetableshown,\prime \text{'}\; have\; their\; own\; EBCDIC\; codes\; (for\; example\; \text{'}=\text{'}\; \to \; 01111110\; in\; the\; table\; shown,\; \text{'}$′havetheirownEBCDICcodes(forexample′=′→01111110inthetableshown,′' → 01011011).

EBCDIC remains in use on many IBM mainframe and midrange systems; ASCII-based encodings dominate personal computers and most modern systems, but conversion utilities are commonly used when data pass between these platforms.

Unicode

Both ASCII and EBCDIC (and many vendor-specific extensions) suffer two important limitations:

• They provide too few code points to encode the full range of world scripts, symbols and specialised technical glyphs, limiting multilingual processing.
• They are mutually incompatible in some code positions (the same numeric code can represent different characters in different encodings), complicating data interchange.

To overcome these limitations the Unicode standard was developed by the Unicode Consortium in cooperation with the International Organization for Standardization (ISO). Unicode defines a universal set of character code points and assigns each a unique number called a code point. Early Unicode was designed around a 16-bit space (allowing 65,536 code points), but the standard has since been extended to cover over a million code points to accommodate all modern and historic scripts, musical notation, emoji and many technical symbols.

To represent Unicode code points in storage and transmission, a number of encodings exist:

• UTF-8 - a variable-length encoding using 1 to 4 bytes per code point; backward compatible with 7-bit ASCII for the first 128 characters and widely used on the Web.
• UTF-16 - uses 2 or 4 bytes per code point; compatible with early 16-bit Unicode usage and used by many operating systems and programming environments.
• UTF-32 - uses 4 bytes per code point and provides fixed-width representation (less space-efficient but simpler indexing).

Unicode has a number of practical uses:

• It is used for internal processing and storage of text by many operating systems and runtimes (for example, Windows and many language runtimes support UTF-16 internally).
• It is the recommended character set for World Wide Web documents and is widely adopted in HTML and XML.
• Unicode defines multiple line-separator characters, but platform-specific line-ending conventions (CR, LF, CRLF) still exist and must be handled by software."

Major software vendors and standards bodies have adopted Unicode; it enables reliable multilingual text interchange and simplifies internationalisation of applications.

Comparison and Practical Notes

• Morse and Baudot are historical telegraphic codes; Morse is variable length while Baudot is fixed-length (5 bits).
• Hollerith (punched-card) encodings are largely obsolete but important historically for early data processing and tabulation.
• ASCII is simple, compact (7-bit) and widely used in personal computing; extended 8-bit forms and parity conventions arose because hardware commonly uses 8-bit bytes.
• EBCDIC is an 8-bit IBM encoding still found on mainframes; conversion between EBCDIC and ASCII is often required in heterogeneous environments.
• Unicode is the modern universal standard addressing multilingual and technical symbol needs, with UTF-8 being the dominant encoding on the Internet.

Concluding remark: Choosing a character encoding depends on the application context-legacy systems, storage efficiency, backwards compatibility with ASCII, or the need to support many languages. Understanding ASCII, EBCDIC and Unicode and how they are encoded (7-bit, 8-bit, variable-length) is essential for reliable text processing and data interchange.