low rungs
Close to the metal. Fast, total control, brutal to write. You think like the machine.
A programming language is an invented thing — someone designed its grammar the way someone designs an alphabet. And every single one was built because the one before it hit a wall. This is that climb, rung by rung, from the first algorithm down to the metal and back up — with the real code, and the exact wall that forced each change.
No language is handed down by nature. Each one is a human invention — and inventions only appear when something breaks.
So the cleanest way to understand the whole history isn't a list of names and dates. It's a chain of failures: this language could not do that, so someone built the next one to fix it — and then that one broke too. Read it as a ladder. The bottom is the bare machine. Every rung up is a step away from the transistors and toward human meaning. Nothing on the ladder replaces what's beneath it; it sits on top of it.
The idea of a machine following written instructions is older than electronics. Two inventions set the stage — one made of wood and thread, one that existed only on paper.
Weaving a patterned fabric meant a human pulling the right threads, by hand, for every single row — slow, and the pattern lived only in the weaver's head. There was no way to store a design and run it again.
Jacquard punched the pattern into stiff cards: a hole meant "lift this thread," no hole meant "leave it." The loom read the cards and wove the design automatically. The pattern was now outside a human head — written down, reusable, executable by a machine.
No one called it a program. But the shape is exactly right: instructions, encoded as holes (the original binary — hole / no-hole), fed to a machine that obeys them in order. Every line of code you will ever write is a descendant of a punched card.
Charles Babbage designed a mechanical computer — the Analytical Engine — that could calculate. But a machine that can follow instructions is useless until someone writes the instructions. No one had ever written a non-trivial set of steps meant to be executed by a machine.
Translating an article about Babbage's engine, Ada Lovelace added her own notes — longer than the original article. In Note G she wrote out, step by step, how the engine could compute the Bernoulli numbers: a loop, with variables changing on each pass. It is the first published algorithm designed to be run by a machine. She also saw further than Babbage — that such a machine could manipulate not just numbers but any symbol: music, language, anything you could encode.
# the first algorithm: compute a Bernoulli number set result = 0 for each term in the series: compute the term result = result + term # the variable changes each pass — a loop return result
When real electronic computers arrived in the 1940s, programming meant speaking the machine's own language — which turned out to be nearly impossible for humans. The first "languages" were just thin layers of mercy on top of raw numbers.
At the bottom of the ladder there is no language at all — just numbers. The processor understands only patterns of bits (1s and 0s), where each pattern means one tiny operation: load this number, add these two, store the result here. Early programmers wrote these by hand and set them with physical switches or punched cards.
10110000 01100001 # put the number 97 into a register 00000100 00000101 # add 5 to it 11110100 # halt
It works, and it is the only thing the chip truly understands — but no human can write or read this at scale. One wrong bit is a silent catastrophe. A program of any size is unmaintainable. The machine's native tongue is unspeakable by people.
Humans can't hold binary in their heads. So: give each machine operation a short name a person can remember and read.
Assembly language replaces each numeric instruction with a mnemonic — MOV, ADD, JMP. A small program called an assembler translates those names back into the exact machine code. It is a one-to-one map: still the machine's way of thinking, but now writeable.
MOV AL, 97 ; put 97 in register AL ADD AL, 5 ; add 5 HLT ; halt
Two fresh problems. First, you still think in single machine steps — writing a × b + c takes a dozen lines. Second, and worse: assembly is different for every kind of chip. Code written for one machine is gibberish to another. You rewrite everything to move it.
The 1950s broke the deadlock. Instead of one instruction at a time in the chip's own dialect, you'd write something close to mathematics or English — and a far more ambitious translator, a compiler, would turn a whole program into machine code for you. This is the great climb.
Scientists wanted to write equations, and assembly forced them to hand-translate every formula into dozens of machine steps, per chip. Most believed a machine could never translate human-style math into code as efficiently as a human could. The wall was a belief: that high-level code was impossible or hopelessly slow.
FORTRAN — Formula Translation — let you write the math almost as you'd write it on paper, and its compiler produced machine code fast enough to win the skeptics over. It is widely called the first successful high-level language. Suddenly a formula was one line, and the same line could (with a different compiler) run on a different machine.
PROGRAM ADDER INTEGER X X = 97 + 5 PRINT *, 'HELLO, WORLD' END
FORTRAN was built for numbers. But people wanted computers to do things that aren't arithmetic — reason about symbols, process lists, handle language, run business records in plain English. One language shaped for math couldn't be shaped for everything.
The new field of artificial intelligence needed to manipulate symbols and lists — words, logical statements, trees of ideas — and to define functions that call themselves (recursion). FORTRAN's number-grid couldn't bend that way.
LISP (LISt Processor) made the list the fundamental thing, and code itself was written as lists — so a LISP program could read and write other LISP programs. It introduced ideas decades early: recursion, functions as values, automatic memory management. Much of it looks strange (so many parentheses) because it's close to raw mathematical logic.
(defun factorial (n) (if (= n 0) 1 (* n (factorial (- n 1))))) ; it calls itself
Business — payroll, banking, inventory — was a huge new use for computers, but the people who understood the business weren't mathematicians. Math-notation code was unreadable to them. Programs needed to look like English so non-specialists could check what they did.
COBOL (Common Business-Oriented Language) was deliberately verbose and English-like. Grace Hopper had already proven the key idea — that a compiler could accept near-English and produce machine code — and championed making code readable to the business, not just the engineer.
MULTIPLY HOURS-WORKED BY PAY-RATE GIVING GROSS-PAY. DISPLAY "HELLO, WORLD".
Every language had its own ad-hoc grammar, and there was no clean, formal, machine-independent way to write down an algorithm and share it between researchers and machines. The field needed a rigorous common notation.
ALGOL (Algorithmic Language) is the most influential language most people have never heard of. It introduced block structure (code grouped in begin … end), nested scope, and was defined by a precise formal grammar (BNF) — the idea that a language's rules can themselves be written down exactly. Almost every language since — C, Java, Python, JavaScript — inherited its shape.
begin integer x; x := 97 + 5; print(x) end
Computers were spreading, but every existing language assumed you were a scientist or a professional programmer. Ordinary students and beginners had no way in.
BASIC (Beginner's All-purpose Symbolic Instruction Code) was designed so a student could sit down and make the machine do something in an afternoon. It later shipped on millions of home computers in the 1980s — for a whole generation, BASIC was the first taste of code.
10 PRINT "HELLO, WORLD" 20 GOTO 10 REM loops forever
By the 1970s two new walls appeared. High-level languages were too far from the metal to build operating systems — but assembly was too painful and unportable. And programs had grown so large that even good code became an unmanageable tangle. Two answers reshaped everything.
To build an operating system you need fine control over the machine's memory — which meant assembly, which meant rewriting the entire system for every new computer. High-level languages hid the machine too much to do the job; assembly chained you to one chip. There was no portable language for systems.
C sat exactly in the gap: structured and readable like a high-level language, but with direct access to memory like assembly. Its masterstroke — the Unix operating system was rewritten in C, so moving Unix to a new machine meant writing a C compiler, not rewriting Unix. C became the language the modern world is built on: operating systems, databases, other languages' own compilers.
#include <stdio.h> int main(void) { printf("Hello, world\n"); return 0; }
C's power is also its danger: it trusts you completely with memory, so a single mistake corrupts data or crashes — or becomes a security hole. And as programs grew to millions of lines, C's flat style of functions-and-data became a tangle no one could hold in their head.
As programs ballooned, the old style — a pile of functions all reaching into shared data — became spaghetti: change one thing, break five others. Largeness itself was the wall. Code needed a way to stay organized as it grew.
Smalltalk made everything an object: a self-contained bundle of data and the behavior that acts on it, talking to other objects by sending messages. This is object-oriented programming in its purest form — model the program as a society of small responsible parts. The idea would soon flow into nearly every mainstream language.
Transcript show: 'Hello, world'. "send 'show:' to the Transcript object"
C was fast and close to the metal but had no objects, so big C programs tangled. Smalltalk had objects but was slower and a world apart. You had to choose between speed and structure — and large systems needed both.
C++ added objects (and much more) on top of C, keeping C's speed and machine access. You could write low-level, fast code and organize it into objects in the same language. It became the workhorse for things that must be both big and fast: game engines, browsers, trading systems.
#include <iostream> int main() { std::cout << "Hello, world" << std::endl; return 0; }
Power piled on power: C++ grew enormous and intricate, and it kept C's memory dangers. Writing correct C++ took deep expertise. Most programmers didn't need maximum speed — they needed to stop crashing and ship faster.
By the 1990s, computers were fast and cheap enough to spend some of that speed on the programmer instead of the machine. The new walls weren't about capability — they were about human cost: too hard to write, too easy to crash, too tied to one computer. The answers prioritized the person.
C and C++ made you write a lot of ceremony — type declarations, memory management, braces and semicolons — before you could do anything simple. For everyday tasks that was too much friction; the language got in the way of the idea.
Python optimized ruthlessly for readability and speed-of-writing. It hides memory management, needs little ceremony, and uses indentation to show structure so the code looks clean. Compare it to C's hello world — the whole program is one line, and a beginner can read it aloud.
print("Hello, world")
C++ programs had to be recompiled — often rewritten — for every kind of computer, and its memory bugs caused endless crashes. The dream was "write once, run anywhere" with the memory dangers removed.
Java's trick was an invented, fake machine — the Java Virtual Machine (JVM). Your code compiles not to any real chip's code, but to bytecode for the JVM. Then a JVM built for each real platform runs that bytecode. Compile once, run on any machine that has a JVM. Java also took memory management out of your hands (automatic "garbage collection"), removing a whole class of crashes — and kept the object structure from the C++/Smalltalk line.
public class Hello { public static void main(String[] args) { System.out.println("Hello, world"); } }
Hello.java → your text (a designed grammar) ↓ javac bytecode → the JVM's language (an invented machine) ↓ JVM + JIT machine code → the real chip's language (also a design) ↓ transistors → the only layer that isn't a language
The early web was paper: pages you could read but not do anything with. There was no way to make a page react — respond to a click, check a form, change without reloading.
JavaScript was built (famously, in about ten days) to run inside the browser and make pages interactive. Despite a rushed birth and many quirks, it became one of the most-used languages on Earth simply because it owns the one place everyone goes: the web page. This very document runs a little of it to reveal each section as you scroll.
function greet() { alert("Hello, world"); // pops up when you click }
The newest walls are old ones, refused. For decades the deal was fixed: low rungs gave speed but danger; high rungs gave safety but cost speed. The modern question is whether that trade was ever truly necessary — or just unsolved.
C and C++ give you raw speed and control, but their memory bugs cause the majority of serious software crashes and security vulnerabilities — decades of them. The two usual fixes both cost something: write in C/C++ and accept the danger, or use a "garbage-collected" language (like Java/Python) and accept the slowdown. The wall: nobody had safety and bare-metal speed together.
Rust's idea is a compiler that proves your memory use is safe before the program ever runs — a strict set of ownership rules checked at compile time, with no run-time garbage collector slowing things down. If it compiles, a whole category of crashes is impossible. It's harder to satisfy the compiler, but the payoff is C-level speed without C's most dangerous bugs.
fn main() { println!("Hello, world"); }
The clearest way to feel seventy years of climbing: watch the same instruction — "say hello" — across every rung. Same job. Each time, less ceremony, more human, further from the metal.
The bits at the top and the println at the bottom do the identical thing on the identical hardware. Everything between them is invented language — each one a rung someone built so a human wouldn't have to stand on the one below.
Strip away the names and the same handful of pressures forced almost every rung. New languages don't appear randomly — they appear when one of these breaks.
Seventy years of programming languages is not a march toward one perfect language. It's a chain of refusals. Each language is someone looking at a wall — too slow, too dangerous, too tied to one machine, too hard for humans to read — and saying no, build the next rung.
And the deepest thing under all of it: a programming language is a constructed language, an invented grammar with a translator beneath it that turns it into the grammar below, and the one below that, down to the only layer that isn't a design — the voltage in the silicon. To learn to program is to learn to write in one of these invented tongues. To design a language is to add a rung of your own.
You started this paper asking how to print one line. The honest answer is: you were learning to speak one invented language, on a ladder of invented languages, every rung of which exists because a human refused the wall on the rung below.