The History of Programming Languages

By Victor Hoang · Updated Oct 21, 2026

In the early 1950s, writing a program meant writing the machine's own instructions by hand. John Backus led the team behind FORTRAN, short for Formula Translation. According to IBM's history of the language, he called that work "hand-to-hand combat with the machine." He said the machine usually won.

Programming languages began in the 1940s and 1950s, when people replaced strings of numbers with words and formulas a machine could translate. The idea is older: a French loom followed punched cards in 1801, and in 1843 Ada Lovelace described steps for a machine that didn't yet exist. In FORTRAN, a task of about a thousand hand-coded instructions could shrink to 47. Each new layer sat closer to the human, and the result split into families for science, business, systems work and beginners. For the machines themselves, see The History of Computers.

Timeline at a Glance

The Loom and the Notes (1801-1944)

Cards and a countess describe programs before machines exist

Picture a silk workshop in Lyon in 1801, where a chain of cards punched with holes passes through a loom. The Computer History Museum says Joseph Marie Jacquard demonstrated that year a loom that let unskilled workers weave complex patterns, because the holes decided which threads were lifted on each pass of the shuttle. Nobody called this a language. It was a pattern stored on a card, a precursor to what came later and not the thing itself.

Charles Babbage took the idea into calculation. The same Museum page says he described plans in 1837 to use punched "number cards" to input programs and data into his Analytical Engine. In 1843, Ada Lovelace published a translation of an article about the engine with notes about three times its length. Those Notes, per the Museum's Babbage history, described the steps the engine would take to solve certain problems, "procedures we would now call programs." She also speculated that the machine could manipulate symbols according to rules, not only numbers. The engine was never built in Babbage's lifetime, so her programs were instructions for a machine that existed only in drawings.

That is the right place to draw the line between the practice and the concept. Cards and notes could describe a sequence of operations. They didn't give anyone a notation that a machine would read and translate into its own instructions. That step took the better part of another century.

For teams today: the first idea to arrive was separating instructions from the worker who executes them. Every runbook, macro and automation you write is a descendant.

The Compiler Idea (1945-1956)

Words replace numbers, and Grace Hopper shows it can work

By the 1940s, electronic machines were being programmed in their own numbers. In 1945, Konrad Zuse, who had already built the Z1 and Z3 computers, began work on Plankalkul. The Computer History Museum's software timeline calls it "the first algorithmic programming language," aimed at laying a theoretical foundation for solving general problems. It is a milestone of design, ahead of the machines that could run it.

The practical breakthrough came on the UNIVAC I. In 1952, Grace Hopper completed A-0, which the same timeline says let users give instructions with "English-like words instead of numbers" and had several features of a modern compiler. A compiler is a program that translates a human-readable program into machine instructions, and it is the idea every later language rests on. The problem it solved was drudgery and error. The problem it created was trust: would a translation program produce code as good as a person's?

FORTRAN was the test. According to IBM's history, Backus was given a budget in 1953 to hire a small team and see whether the idea was feasible. The team was an unusual mix, including a chess wizard, a crystallographer and a cryptographer. The effort was planned as six months and took about three years. Backus said of it, "everyone told us it couldn't be done." The Museum notes that skeptics doubted it could match hand-coded programs, but that it produced efficient code.

For teams today: the person closest to the work usually distrusts the translation layer first. The way past that is a side-by-side comparison on a real task, not a pitch.

The First Families (1957-1968)

Science, business, logic and beginners each get a language

This is where the single idea splits, and the splits follow the audience. FORTRAN, which debuted in 1957 with the first compiler for the IBM 704 following soon after, served scientists and engineers. Business had a different problem: payroll and billing needed records and readable instructions. Hopper's group finished FLOW-MATIC in 1957, which the Museum calls the first English-language business data processing compiler.

Then business tried to stop each manufacturer inventing its own. On May 28, 1959, according to the Computer History Museum, a committee formed to develop COBOL, with members "drawn from several computer manufacturers and the Pentagon." The group wanted programs to read easily and not depend on one machine. Its specifications drew heavily on FLOW-MATIC, and the Museum's timeline dates the language to 1960. One programmer, Howard Bromberg, made a tombstone for COBOL, believing it had no future. The Museum's page says the tombstone is now in its collection. A 1997 study cited by the Museum estimated more than 200 billion lines of COBOL still existed.

A third family came from mathematics. John McCarthy's paper "Recursive Functions of Symbolic Expressions and Their Computation by Machine," published in Communications of the ACM in April 1960, is the original paper on LISP. And a fourth effort aimed at a common standard. The ALGOL conference met in Zurich from May 27 to June 3, 1958, and its preliminary report said the language "represents a compromise." After a Paris meeting on January 11 to 16, 1960, the report on ALGOL 60, edited by Peter Naur, was published in Communications of the ACM in May 1960. Naur adopted Backus's notation for describing syntax, which he called "a highly valuable tool," and it turned a language definition into something other people could check.

Then the audience widened again. At 4 a.m. on May 1, 1964, in the basement of College Hall at Dartmouth, John Kemeny and a student programmer typed RUN on neighboring terminals. Both got correct answers, and BASIC (Beginner's All-purpose Symbolic Instruction Code) and the college's time-sharing system were running. The goal was to "open computer access to all at Dartmouth," with Thomas Kurtz building the language alongside Kemeny and a group of undergraduates. The Museum adds that most early personal computers later shipped with a version of BASIC.

The era solved who a language was for. It created a problem the rest of the century would keep reopening: with rival languages for rival audiences, the same company ended up maintaining several.

For teams today: different jobs wanted different languages, and they still do. The strongest early languages were built around one audience's real task, such as a scientific formula, a payroll record or a student's first program.

The C Era (1969-1988)

A small language rides Unix onto every machine

The setting was Bell Labs in the late 1960s, when, as Dennis Ritchie recounts in The Development of the C Language, the company was pulling out of the Multics project. Ritchie writes that C "came into being in the years 1969-1973," in parallel with the early development of Unix, and that the most creative period was 1972. It was devised as a system implementation language for the new operating system and derived from the typeless BCPL, by way of Ken Thompson's B. Ritchie describes B as "BCPL squeezed into 8K bytes of memory," a reminder of how tiny the machines were.

By early 1973 the essentials of modern C were done, and that summer the team rewrote the Unix kernel for the PDP-11 in C. The consequence was portability, a turn traced from the operating system side in the history of operating systems. Ritchie says the success of Unix was the most important factor in C's spread, and that Unix's use of C and its resulting portability helped Unix succeed. The Museum's timeline makes the same point: rewriting Unix in C made it easy to move to other computers. The language also stayed small. Ritchie calls it "a simple and small language," translatable with simple and small compilers.

A different tradition ran in parallel at Xerox PARC. Alan Kay's Early History of Smalltalk tells how a challenge to define "the most powerful language in the world" in "a page of code" led to Smalltalk-72, which Dan Ingalls quickly got running on a NOVA. Kay calls Smalltalk-76 "the first modern Smalltalk." His group's core principle was that "everything is an object," and his Learning Research Group taught the language to children as part of a vision of a personal dynamic medium. Smalltalk and C came from different worlds, one built for learning, the other for system building.

Bjarne Stroustrup joined the two. By his own account, he started work in 1979 on what became "C with Classes," and the first version of C++ was used internally at AT&T in August 1983. Rick Mascitti suggested the name, first used in December 1983, and the first commercial implementation shipped in October 1985, the month the first edition of The C++ Programming Language was published. Stroustrup took classes, derived classes and virtual functions from Simula, as Smalltalk did, and he wanted to write efficient systems programs in the style Simula encouraged. He credits having Ritchie nearby, and C itself, as essential.

The era solved speed and portability. It created risk: C trusted the programmer, and larger programs built on it needed more structure, which is why objects mattered.

For teams today: a small, portable core travels farther than a clever one. The case for C was not elegance but that the same code could move to the next machine.

The Web Years (1989-2020)

Scripting and portability follow the browser

The next wave aimed at making programmers more productive and programs portable. Guido van Rossum, working at the Dutch research institute CWI, began Python during the 1989 Christmas holidays. The Python FAQ says he wanted a better way to do system administration than writing C programs or Bourne shell scripts, and that he posted it to USENET in February 1991. He built on ABC, a teaching language he had helped create in the early eighties. In his foreword, he says ABC never caught on with Unix and C programmers largely because it was a closed system, and that he decided not to repeat that mistake. He named the language after the BBC comedy Monty Python's Flying Circus.

In 1995 two more languages arrived, and they were designed for different jobs despite the name. The Museum's timeline records that Sun Microsystems introduced Java 1.0 that year, with a "Write Once, Run Anywhere" model that let programs run on any system, succeeding the Oak language James Gosling created in 1991. The Museum's May 23 entry places the unveiling of Java alongside the HotJava browser at SunWorld '95. The same timeline says Brendan Eich developed JavaScript at Netscape Communications, and that despite the shared name it is entirely different from Java. It was widely used on both client and server sides.

The era solved reach and reuse. Programmers wrote less to do more, and a program could follow the user onto the web. It created a new kind of sprawl: dozens of languages for dozens of platforms, each with its own libraries and habits. Much of that code soon ran on rented servers rather than owned ones, the shift told in the history of cloud computing.

For teams today: language choice is often a hiring and maintenance decision more than a technical one. The languages that lasted from this period were the ones that gave people a reason to adopt them and a way to leave their old tools behind.

The Prompt Age (2021-present)

Plain language becomes a way to write code

The newest step reopens the oldest question: how close to ordinary language can instructions get? In July 2021, a team led by Mark Chen published Evaluating Large Language Models Trained on Code. It describes Codex, a GPT language model fine-tuned on public code from GitHub, and says a production version powers GitHub Copilot. On the authors' HumanEval benchmark of programs written from descriptions, Codex solved 28.8% of problems, while GPT-3 solved 0% and GPT-J 11.4%. With 100 attempts per problem, Codex solved 70.2%.

Those numbers describe a research system from 2021 and are not a measure of today's tools. What matters for this history is the direction. The description of the task, in plain language, became the first draft of the program. The practice of steering a model with loose, conversational instructions has its own name, covered in What is Vibe Coding?, and the longer story of the models themselves is in The History of AI. It is the same move Hopper made in 1952, one level up: the person states the intent, and a program translates it.

It also brings back the old trust problem. Skeptics in 1957 asked whether a compiler could match a person. The 2021 results suggest a different question for any team: a draft appears fast, and the review of that draft is where the expertise goes.

For teams today: treat generated code the way early teams treated compiled code. Compare it with what an expert would write, and decide who owns the review.

Key People

Key Facts

Key Facts: Programming Languages

• A task that took about a thousand instructions by hand shrank to 47 in FORTRAN, which debuted in 1957 after a project planned for six months took three years.
• The COBOL committee formed on May 28, 1959 with members drawn from several computer manufacturers and the Pentagon.
• BASIC first ran at 4 a.m. on May 1, 1964, in the basement of Dartmouth's College Hall.
• C was developed in 1969-1973, and the Unix kernel was rewritten in it in the summer of 1973.
• A 1997 study cited by the Museum estimated more than 200 billion lines of COBOL still existed.
• In 2021, Codex solved 28.8% of HumanEval problems, against 0% for GPT-3.

The Pattern Behind the History

Across six eras, the same five moves repeat. We call the sequence the Abstraction Ladder. It's our synthesis of the milestones above, not a research finding.

1. Drudgery starts it. Hand-coding, hand-weaving and hand-computing each prompted someone to write a layer that did the tedious part.
2. A skeptic gate follows. FORTRAN faced doubts that it could match hand code, and COBOL got a tombstone. Each language had to prove itself on real work.
3. The idea forks by audience. Science, business, logic, beginners and systems work each got their own family.
4. Portability decides survival. COBOL aimed to be machine independent, C moved Unix between machines, and Java promised to run anywhere.
5. Old layers stay. New languages arrive, but a 1997 study estimated more than 200 billion lines of COBOL still existed.

What It Teaches Teams Today

• Separate the instruction from the executor. Every language on this page began by moving instructions out of the worker's head and onto something a machine could read.
• Pick the language for the audience. The families that lasted were built around one group's real task, not around the language alone.
• Count portability as a feature. The languages that spread were the ones that could move to the next machine or platform.
• Plan for the old layer. Code written decades ago keeps running, so a migration plan matters more than a favorite language.
• Expect the trust gate with AI. Plain-language prompts will go through the same doubt compilers did. Set up the comparison and the review before you scale the tool.

Programming languages are a history of conversations getting easier. Each step let more people tell a machine what they wanted, and each one left a smaller group to check what the machine produced. For the machines themselves, start with the computer timeline, the generations of computers and who invented the computer. The network that carried the languages is in The History of the Internet.