In the 1940s, the first recognizably modern electrically powered computers were created. The limited speed and
memory capacity forced programmers to write hand-tuned
assembly language programs. It was eventually realized that programming in assembly language required a great deal of intellectual effort. An early proposal for a
high-level programming language was
Plankalkül, developed by
Konrad Zuse for his
Z1 computer between 1942 and 1945, but not implemented at the time. The first functioning programming languages designed to communicate instructions to a computer were written in the early 1950s.
John Mauchly's
Short Code, proposed in 1949, was one of the first high-level languages ever developed for an
electronic computer. Unlike
machine code, Short Code statements represented
mathematical expressions in an understandable form. However, the program had to be
interpreted into machine code every time it ran, making the process much slower than running the equivalent machine code. In the early 1950s,
Alick Glennie developed
Autocode, possibly the first compiled programming language, at the
University of Manchester. In 1954, a second iteration of the language, known as the "Mark 1 Autocode", was developed for the
Mark 1 by
R. A. Brooker. Brooker, with the University of Manchester, also developed an autocode for the
Ferranti Mercury in the 1950s. The version for the
EDSAC 2 was devised by
Douglas Hartree of the
University of Cambridge Mathematical Laboratory in 1961. Known as EDSAC 2 Autocode, it was a straight development from Mercury Autocode, adapted for local circumstances, and was noted for its
object code optimization and source-language diagnostics, which were advanced for the time. A contemporary but separate thread of development,
Atlas Autocode was developed for the
University of Manchester Atlas 1 machine. In 1954,
FORTRAN was invented at IBM by a team led by
John Backus; it was the first widely used high-level general-purpose language to have a functional implementation, in contrast to only a design on paper. When FORTRAN was first introduced, it was viewed with skepticism due to bugs, delays in development, and the comparative efficiency of "hand-coded" programs written in assembly. However, in a hardware market that was rapidly evolving, the language eventually became known for its efficiency. It is still a popular language for
high-performance computing and is used for programs that benchmark and rank the world's
TOP500 fastest supercomputers. Another early programming language was devised by
Grace Hopper in the US, named
FLOW-MATIC. It was developed for the
UNIVAC I at
Remington Rand during the period from 1955 until 1959. Hopper found that business
data processing customers were uncomfortable with
mathematical notation, and in early 1955, she and her team wrote a specification for an
English language programming language and implemented a prototype. The FLOW-MATIC compiler became publicly available in early 1958 and was substantially complete in 1959. Flow-Matic was a major influence in the design of
COBOL, since only it and its direct descendant
AIMACO were in use at the time. Other languages still in use today include
LISP (1958), invented by
John McCarthy, and
COBOL (1960), created by the Short Range Committee. Another milestone in the late 1950s was the publication, by a committee of American and European computer scientists, of "a new language for algorithms"; the
ALGOL 60 Report (the "
ALGOrithmic
Language"). This report consolidated many ideas circulating at the time and featured three key language innovations: • nested block structure: code sequences and associated declarations could be grouped into
blocks without having to be turned into separate, explicitly named procedures; •
lexical scoping: a block could have its own private variables, procedures, and functions, invisible to code outside that block, that is,
information hiding. Another innovation, related to this, was in how the language was described: • a mathematically exact notation,
Backus–Naur form (BNF), was used to describe the language's syntax. Nearly all subsequent programming languages have used a variant of BNF to describe the
context-free portion of their syntax.
ALGOL 60 was particularly influential in the design of later languages, some of which soon became more popular. The
Burroughs Large Systems were designed to be programmed in an extended subset of ALGOL. ALGOL's key ideas were continued, producing
ALGOL 68: • syntax and
semantics became even more orthogonal, with anonymous routines, a recursive typing system with higher-order functions, etc.; • not only the context-free part, but the full language syntax and semantics were defined formally, in terms of
Van Wijngaarden grammar, a formalism designed specifically for this purpose. ALGOL 68's many little-used language features (for example, concurrent and parallel blocks) and its complex system of syntactic shortcuts and automatic type coercions made it unpopular with implementers and gained it a reputation for being difficult.
Niklaus Wirth actually walked out of the design committee to create the simpler
Pascal language. Some notable languages that were developed in this period include: • 1951 –
Regional Assembly Language • 1952 –
Autocode • 1954 –
IPL (forerunner to LISP) • 1955 –
FLOW-MATIC (led to COBOL) • 1957 –
FORTRAN (first compiler) • 1957 –
COMTRAN (precursor to COBOL) • 1958 –
LISP • 1958 –
ALGOL 58 • 1959 –
FACT (forerunner to COBOL) • 1959 –
RPG • 1960 –
COBOL • 1960 –
ALGOL 60 • 1962 –
APL • 1962 –
Simula • 1962 –
SNOBOL • 1963 –
CPL (forerunner to C) • 1964 –
Speakeasy • 1964 –
BASIC • 1964 –
PL/I • 1966 –
JOSS • 1966 –
MUMPS • 1967 –
BCPL (forerunner to C) • 1967 –
Logo (an educational language that later influenced
Smalltalk and
Scratch). • 1968 –
Algol 68 == Establishing fundamental paradigms ==