Diff — Short Code

{{infobox

| title = Short Code

| designer = proposed by John Mauchly · implemented by William F. Schmitt · revised by A. B. Tonik & J. R. Logan

| first appeared = 1949 (BINAC, as Brief Code) · 1950 (UNIVAC I)

| paradigm = interpreted algebraic notation — "automatic programming"

| typing = fixed-point expressions on 12-byte words

| status = lost — no implementation survives

| influenced = the first practical demonstration that expressions, not instructions, could be run

}}

# Short Code

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.[[cite: [Short Code history](https://en.wikipedia.org/wiki/Short_Code_(computer_language)) and Schmitt 1988 — the proposal-to-implementation timeline across BINAC, UNIVAC I, and UNIVAC II]]

# 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.[[cite: Schmitt 1988 — the two-character encoding, the worked `a = (b + c) / b * c` example, and the interpreted execution model]]

# 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.

```fact

Short Code's interpreter made it one of the first languages to be *run* rather than *compiled* — the execution model [[BASIC]] and every scripting language would later take for granted, a quarter-century early.

```

# 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 [[Grace Hopper|Hopper]]'s A-0 system had matured into FLOW-MATIC, on the same machines [[UNIVAC I|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*?

```hide Show answers

1 — **John Mauchly** proposed it as "Brief Code" (1949); **William F. Schmitt** implemented the working UNIVAC I version (1950); **Tonik & Logan** revised it (1952).

2 — each expression element became a **two-character code**, six codes packed per 12-byte word — written as algebra, then hand-converted before running.

3 — about **50× slower** than machine code — and it bought abstraction: math expressed as math instead of as instructions.

4 — **no implementation survives** — the language is known only through Schmitt's 1988 retrospective and the project papers.

```

[[Category:Languages]]

[[Category:Programming]]

[[Category:History]]