Teaching Machines to Understand Us

By the early 1950s, the machines from Issue 2 existed — rooms full of humming metal and blinking lights, capable of thousands of calculations per second.

There was just one problem: talking to them was a nightmare.

These machines spoke only one language — machine code. Raw sequences of binary digits. To tell the machine "add these two numbers," you wrote something like 00010110 01010000 01100001. And you had to get every single bit right.

Programming was translation work. Humans think in words and concepts. Machines think in electrical signals — on or off, 1 or 0. Somebody had to bridge that gap.

Just how bad was programming in binary? Let's look at what it actually took to tell an early computer to do one simple thing.

Programmers spent up to 90% of their time finding and fixing errors, not writing new logic. The machine was fast, but the humans were the bottleneck.

By the late 1940s, programmers created shorthand. Instead of binary codes, they assigned short mnemonics — tiny abbreviations a human could remember. ADD instead of 0010. LOAD instead of 0001.

This was assembly language. A simple program called an assembler translated these mnemonics back into binary. One line of assembly = one machine instruction.

But assembly had serious limitations: it was machine-specific (code for one computer was gibberish to another), and still tedious — even simple tasks required hundreds of instructions.

Assembly was a Band-Aid on a broken arm. The real fix would require a much bolder idea.

What if a computer could understand something closer to actual English? One woman thought it could. Almost nobody believed her.

In 1952, Hopper wrote what is widely regarded as the first compiler — a program called A-0 that translated mathematical notation into machine code. Instead of a human translating each instruction by hand, a program would do it automatically.

"I had a running compiler," Hopper later recalled, "and nobody would touch it. They told me a computer could only do arithmetic."

Hopper kept building. A-0 led to A-2, then to B-0 (FLOW-MATIC), which could understand commands like: MULTIPLY PRICE BY QUANTITY GIVING TOTAL.

Hopper was also famous for handing out 11.8-inch pieces of wire during lectures — the distance light travels in one nanosecond — to make abstract computing concepts tangible.

John Backus hated the tedium of programming. In 1953, he proposed to IBM: build a language where scientists could write formulas that looked like actual math. FORTRAN — FORmula TRANslation — was released in April 1957.

Skeptics said no automatic translator could match hand-optimized code. Backus's team proved them wrong: FORTRAN programs ran within 10-20% of hand-written assembly speed. Within a year of release, over half of all new IBM code was in FORTRAN.

In May 1959, the CODASYL committee at the Pentagon — organized by Mary Hawes and including key contributors like Jean Sammet (IBM) — designed a single language for business computing. The result was COBOL — the COmmon Business-Oriented Language. Hopper's FLOW-MATIC was a primary influence.

COBOL was designed so programs should be readable by managers, not just programmers.

Critics called COBOL verbose and inelegant. But that verbosity was the point — COBOL was designed to be clear, not clever.

A critical factor in COBOL's rise: the U.S. Department of Defense told computer manufacturers that to sell machines to the government — the world's largest computer buyer — they had to provide a COBOL compiler. This mandate drove COBOL from specification to dominance virtually overnight.

By the mid-1960s, COBOL was the most widely used language in the world. By some estimates, there are still over 200 billion lines of COBOL in active production, processing an estimated 95% of ATM transactions.

Abstraction means hiding complexity behind a simpler interface. You don't need to understand how an engine works to drive a car. Each layer of programming technology abstracts away the details beneath it.

The essential insight: no rung replaces the ones below it. Your browser still runs on machine code. The abstraction ladder is not a replacement chain — it's a stack.

In the summer of 1956, McCarthy organized a workshop at Dartmouth College — the Dartmouth Summer Research Project on Artificial Intelligence. The gathering was informal: researchers came and went over the summer, with no single eureka moment. But it gave the field its name and brought together the people who would define it.

In 1958, McCarthy unveiled LISP (LISt Processing). Where FORTRAN dealt with numbers and COBOL dealt with records, LISP dealt with symbols and lists. It could manipulate code as data — and introduced garbage collection, dynamic typing, and recursive functions, ideas decades ahead of their time.

Here's a remarkable twist: when McCarthy published LISP's theoretical definition, he intended it as pure mathematics — not something to actually build. His graduate student Steve Russell looked at it and said, "Why don't I just program this?" McCarthy was skeptical. Russell built it anyway. Theory became working software.

Keller worked at Dartmouth College — which at the time did not normally admit women — where an exception was made for her in recognition of her talent. There she contributed to the development of BASIC (Beginner's All-purpose Symbolic Instruction Code), created by Kemeny and Kurtz in 1964. BASIC was designed to give students who were not science majors a way to use computers.

BASIC was the language that would later power the personal computer revolution of the 1970s and 1980s, putting programming within reach of millions.

Keller once said: "We're having an information explosion, and it's certainly obvious that information is of no use unless it's available."

By the late 1960s, scientists wrote in FORTRAN, businesses ran on COBOL, AI researchers dreamed in LISP, students learned in BASIC. Meanwhile, an international committee designed ALGOL — a language that was never commercially dominant but whose innovations (block structure, formal grammar, lexical scoping) would influence virtually every programming language that followed, including C, Java, and Python.

But every program ran on one machine. Code for an IBM was gibberish to a UNIVAC. Two revolutions were coming: an operating system called Unix, built on the philosophy that small tools should chain together for complex tasks, and a programming language called C that would make software portable for the first time.

Next: two engineers at Bell Labs build an operating system in a closet-sized room — and create a philosophy that still drives software fifty-five years later. Issue 4: "Small Tools, Big Ideas."