The first computers were programmed in numeric codes that corresponded directly to the machine's operations. Each instruction was a string of digits, and the programmer had to know memory addresses, registers and hardware details. A one-digit error could change the meaning of an instruction. Programs were long, hard to read and hard to correct, and they were tied to one specific machine: if the computer changed, everything had to be rewritten. The difficulty was one of communication between people and machines, and the answer was to build layers of language between the two.
How it works
A programming language is a set of rules for writing instructions so that a computer can carry them out. The computer itself understands only machine language, sequences of bits (zeros and ones) that trigger processor operations. Translator programs bridge the gap between what a person writes and what the machine understands.
The first level above machine code is assembly language, which replaces numbers with short mnemonics such as "add" or "move." A program called an assembler converts them into machine code. One step further is the high-level language, whose statements resemble mathematical notation or technical English. A compiler translates a whole program into machine code before it runs, while an interpreter translates and executes it piece by piece. With an appropriate compiler, the same program can run on different machines, a property called portability.
First steps, 1940s and early 1950s
On the earliest stored-program computers, assembly language arose almost naturally. On the EDSAC at Cambridge, David Wheeler and colleagues developed a small initial loader and the idea of reusable routines gathered in a library, which Maurice Wilkes, Wheeler and Stanley Gill described in a programming textbook published in 1951.
Before that, Konrad Zuse had designed a language called Plankalkül between 1942 and 1945, with features advanced for its time. Isolated by the war, he did not publish it widely until 1972. The first partial implementation is usually credited to Joachim Hohmann's 1975 dissertation, and researchers at the Free University of Berlin produced further implementations around 1998 to 2000. The language is therefore a case of conceptual priority without direct influence on later languages.
In 1951 and 1952 Grace Hopper, a mathematician and naval reserve officer then working on the UNIVAC at Remington Rand, wrote the A-0 system, a program that assembled sub-routines called by numeric code. It is often cited as an early compiler, although it worked more like a linker or loader that stitched stored routines together than like a modern compiler. Hopper argued that programs should be written in terms closer to human vocabulary, and her group's later systems, including FLOW-MATIC, moved in that direction.
The next landmark was FORTRAN, from IBM, whose name comes from "formula translation." A team led by John Backus issued a preliminary specification in November 1954, a programmer's manual appeared in October 1956, and the first compiler, for the IBM 704, began shipping in April 1957. The challenge was persuading programmers that automatically generated code could be as efficient as hand-written code. The team put great effort into optimization, and the language came to dominate scientific and engineering computation.
Diversification, late 1950s and 1960s
In 1958 John McCarthy at MIT created LISP, aimed at list processing and artificial intelligence problems and inspired by the lambda calculus, a formal notation for functions. It introduced ideas such as automatic memory reclamation, which became widespread only decades later. LISP is the ancestor of a whole branch, functional programming.
An international committee proposed ALGOL 58 and, in 1960, ALGOL 60, a reference language for describing algorithms, with block structure and a formally defined syntax. It was rarely used commercially on a large scale but influenced nearly every later language.
In 1959, after meetings called by the U.S. Department of Defense with a committee of manufacturers, universities and users (known as CODASYL), work began on COBOL, aimed at business administration, with English-like syntax. Grace Hopper's work on FLOW-MATIC influenced it, but COBOL was a collective effort rather than one person's design. The first compilers appeared in 1960, and the language spread through banks, insurers and government agencies.
In 1964 John Kemeny and Thomas Kurtz at Dartmouth College created BASIC so that students in many fields could program using time-sharing, in which many users work on one computer at the same time. During the same decade Kristen Nygaard and Ole-Johan Dahl at the Norwegian Computing Center created Simula, whose 1967 version introduced objects and classes, the basis of object-oriented programming.
The software crisis and structured programming
As programs grew, projects ran late, overran budgets and failed. A NATO conference on software engineering held in Garmisch, Germany, in October 1968 helped popularize the phrase "software crisis." In March 1968 Edsger Dijkstra had published a letter in Communications of the ACM whose title criticized the "go to" jump statement, and structured programming, built on blocks, loops and conditionals, became a goal of teaching and design. Niklaus Wirth of ETH Zurich designed Pascal, whose first compiler became operational in 1970, as a teaching language in that spirit.
The 1970s through the 1990s
At Bell Labs, Dennis Ritchie developed C in the early 1970s, with the most creative period in 1972, building on earlier work by Ken Thompson; by 1973 the Unix kernel had been rewritten in it. Close control of hardware combined with portability made C a foundation for operating systems and for many later languages. In the early 1970s Alain Colmerauer and colleagues created Prolog, oriented toward logic. In the same decade Smalltalk, developed at Xerox PARC by a team that included Alan Kay, brought object orientation to interactive graphical environments.
Bjarne Stroustrup began work in 1979 on an extension of C with classes, named C++ in 1983. In 1991 Guido van Rossum released the first public version of Python, which emphasized readability. In 1995 Sun Microsystems publicly introduced Java, which promised to run the same program on different systems through a virtual machine. JavaScript also appeared in 1995, from Netscape, designed to run inside web browsers (see the creation and expansion of the Web).
These languages illustrate paradigms, ways of organizing a program's reasoning. The imperative style describes a sequence of commands. The functional style treats computation as applying functions. The object-oriented style organizes data and operations into entities. The declarative style, as in Prolog, describes what is wanted and leaves the system to find the solution. Almost no real language is pure, and newer ones mix paradigms.
Impact and limitations
High-level languages greatly increased the number of people who could program and allowed larger, longer-lived programs. They also have costs. Programs still contain errors, or bugs, and languages that give extensive control over memory, such as C, allow security flaws that are hard to anticipate. Older systems written in COBOL and other languages still run in banks and public agencies, and maintaining or replacing this legacy software is a recurring challenge, because few professionals know the code in detail and documentation is not always available.
Connections to other technologies
Languages make sense only in relation to machines that execute instructions, the subject of the first computers. The cost reductions brought by integrated circuits meant machine time stopped being the most expensive resource, which favored languages that were more comfortable for people. The personal computer brought BASIC to millions of users, and computational intelligence used LISP and Prolog in its early experiments.