Languages Pre-Fortran

There were many languages that pre-dated Fortran. This series is based on the white paper by Knuth and Pardo published in 1976, “The early development of programming languages”. In this paper the authors describe 20 languages, and use a generic program “TPK” described using ALGOL-60 to illustrate how each language would be formed.

  • 1945 – Plankalkül (Zuse)
    • Likely the first programming language developed, yet not implemented at the time.
  • 1946 – Flow Diagrams (Goldstine/von Neumann)
    • Proposed a pictorial representation involving boxes joined by arrows, calling it a “flow diagram”. These were the original flowcharts. Never implemented.
  • 1948 – Composition (Curry)
    • A notation for program construction more compact than flowcharts. It had aspects of structured programming, e.g. analyzing the computation into parts called divisions. The notation was somewhat eccentric and the work was left unfinished. Never implemented.
  • 1950 – Short Code (Mauchly et al.,)
    • Coded for the BINAC, and in 1950 for the UNIVAC. Mathematical equations could be solved just by writing them down, i.e. it was an algebraic interpreter. Earliest literature dates to 1952.
  • 1950 – Intermediate PL (Burks)
    • Showed how “machine programs” could be expressed at a higher level of abstraction.
  • 1951 – Superplan (Rutishauser)
    • A simple algebraic language with one non-sequential control structure (for), no conditionals or goto.
  • 1951 – Böhm’s Compiler (Böhm)
    • A language in which every statement was a special case of an assignment statement. Described a compiler that was defined in its own language. Considered his language “universal”, i.e. capable of computing any computable function.
  • 1952 – AUTOCODE (Glennie)
    • The first real compiler, as it was really implemented and used. It took algebraic statements and converted them to machine code. Simpler than machine code, but still machine-oriented.
    • Manchester Mark I, not algebraic, very machine dependent, fixed point
  • 1953 – A-2 (Hopper et al.,)
    • Primitive language, more like a compiling routine. Not algebraic, machine dependent, floating-point. Successor to A-0 and A-1.
  • 1953 Laning and Zierler
    • Algebraic pseudo coding implemented for Whirlwind computer, which contributed to FORTRAN for the 704. The programmer no longer needed to know much about the computer at all. Notation was easy to read.
    • Algebraic, machine independent, floating-point
  • 1954-57 – FORTRAN0 (Backus et al.,)
    • Fortran 0, 1954, a simpler version of Fortran 1. All things were formulas, even control structures – arithmetic formulas, DO formulas, GO TO formulas etc. The term compiler is never used, just a FORTRAN language and system. First rigorous attempt to define a programming language. BNF notation can be seen in early form here.
    • Fortran I (1957) included comments, arithmetic statement functions, I/O formatting, CONTINUE statement for loops, and three-way arithmetic IF statement.
  • 1954 – Mark I Autocode (Brooker)
    • A new type of Autocode for the Mark I. It was nearly machine independent and used floating-point arithmetic. One operation per line, few mnemonic names, and no user defined subroutines.
  • 1954 – ПП-2 (Kamynin/Liubimskii)
    • Early Russian systems were called Programming Programs, or ПП for short. Based on a notation for expressing programs developed by A.A. Liapunov in 1953. Built for the STRELA computer, and based on operator schemata.
  • 1955 – ПП (Ershov)
    • Improvement of ПП-2, built for BESM computer. Computers for both had no alphabetic input, so programs had to be converted to numeric codes.
  • 1955 – BACAIC (Grems/Porter)
    • Interpretive algebraic language developed at Boeing. A straight-line computation applied to various “cases” of data. Language too restrictive for general purpose computing.
  • 1955 – Kompiler 2 (Elsworth et al.)
    • University of California Radiation Laboratory, program to perform translation of algebraic equations into IBM 701 machine language – KOMPILER 1. It had individual formulas, no control statements, constants or I/O. KOMPILER 2 similar in flavour to ПП-2, but based on flow diagrams.
  • 1956 – ADES (Blum)
    • US Naval Ordinance Lab. ADES – Automatic Digital Encoding System. Mathematical in structure, based on the theory of recursive functions (but did not really include recursive procedures in the same sense of ALGOL-60). Produced an embryonic form of the conditional expressions introduced into LISP and ALGOL.
  • 1956 – IT (Perlis, et al.)
    • Purdue University Computing Laboratory. Built a compiler for the Burroughs 205 computer (Purdue Compiler Language). Perlis and Smith moved on to Carnegie IT and adapted their language to the IBM 650 – IT (Internal Translator). One of the first useful compilers. Contained a method of iteration and a conditional.
  • 1956-58 – MATH-MATIC (Katz, et al.)
    • Algebraic language, from UNIVAC, very readable. MATH-MATIC source was translated into A-3 (an extension of A-2), which produced inefficient programs.
  • 1956-58 – FLOW-MATIC (Hopper et al.)
    • Also from UNIVAC, using more English language words than MATH-MATIC. Released to UNIVAC customers in 1958. Had a significant influence on the design COBOL.
  • 1956-58 – Formula-Controlled Computer (Bauer/Samelson)
    • Designed a computer in which algebraic formulas were the machine language. Their patent (for a machine never built), included four levels of language.


Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

This site uses Akismet to reduce spam. Learn how your comment data is processed.