Short Code

Short Code

Short Code was one of the first higher-level languages ever actually executed on a computer — a 1950 system for the UNIVAC I in which programmers wrote mathematical expressions instead of machine instructions, and an interpreter translated them into operations on the fly. It was called "automatic programming" at the time, and it ran roughly fifty times slower than hand-written machine code — the first concrete price tag ever put on abstraction.^[1]

The language's origin is a three-person relay that is easy to get wrong. John Mauchly proposed the idea in 1949, calling it Brief Code. William F. Schmitt coded a version for the BINAC that same year — though it was never debugged or tested. In 1950 Schmitt implemented the working version on UNIVAC I, now renamed Short Code (also "Short Order Code"), and in 1952 A. B. Tonik and J. R. Logan revised it for the UNIVAC II. Mauchly conceived it; Schmitt made it real; Tonik and Logan kept it alive.^[2]

Expressions packed into words

Short Code did not let you write algebra freely — the notation was a compromise with the hardware. Each element of an expression was encoded as a two-character code, and six such codes packed into one of the machine's 12-byte words. A programmer (or more often, an assistant) converted each expression by substitution before it could run. The canonical example, preserved in Schmitt's retelling:

a = (b + c) / b * c

 X3 =  (  X1 +  Y1 )  /  X1 * Y1   substitute variables
 X3 03 09 X1 07 Y1 02 04 X1   Y1   substitute operators and parens
 07Y10204X1Y1                      regroup into 12-byte words
 0000X30309X1

Multiplication was expressed by juxtaposition — adjacent variables meant multiply, exactly as in algebra — a tiny piece of mathematical notation smuggled into a vacuum-tube machine. Beyond arithmetic, Short Code supported branching and calls into a library of functions: a genuine, if minimal, language.^{a = (b + c) / b * c example, and the interpreted execution model">[3]}

Fifty times slower, and worth it anyway

The interpreter cost ~50× in speed — a figure that sounds ruinous until you remember what it purchased: a person could express a calculation without knowing the machine. Every high-level language since is a negotiation between that same cost and that same payoff; Short Code was the first time the trade was actually made on real hardware. It predates FORTRAN by seven years, COBOL by nearly a decade — and unlike those, it is lost: no implementation survives, and everything we know comes from Schmitt's 1988 retrospective and Mauchly's papers.

Where it sits

Short Code is the proof that the high-level-language idea — express the problem, let the machine handle the machine — was present at computing's birth, not discovered later. It ran before ALGOL was a committee's gleam, before Hopper's A-0 system had matured into FLOW-MATIC, on the same machines UNIVAC was still proving could work at all. The field's first interpreted language is also one of its first lost ones.

Check your understanding

• Who proposed Short Code, and who actually implemented the first working version?
• How were Short Code expressions physically encoded for the machine?
• What did interpretation cost in speed — and what did it buy?
• Why is Short Code classified as lost?