on 02-Nov-2017 (Thu)

• 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 – COBOL

• 1959 – RPG
• 1962 – APL
• 1962 – Simula
• 1962 – SNOBOL
• 1963 – CPL (forerunner to C)
• 1964 – Speakeasy (computational environment)
• 1964 – BASIC
• 1964 – PL/I
• 1966 – JOSS
• 1967 – BCPL (forerunner to C)

Before computer programming languages were made, paper tapes and punch cards which held complicated weaving patterns for the loom Tabulating Machine Company Looms by Jacquard in 1710

Charles Babbage started building a computing and the analytical Machine

In the 20th century, Herman Hollerith founded the Tabulating Machine. His machine tabulators were used to speed up the counting and sorting of punch cards.

In the early 1940s J. Presper Eckert and John W. Mauchly started building the ENIAC (Electronic Numerical Integrator and Calculator), which was completed by 1946.

FORTRAN, which stands for FORmula TRANslation

During a nine-month period in 1842–1843, Ada Lovelace translated the memoir of Italian mathematician Luigi Menabrea about Charles Babbage's newest proposed machine, the analytical engine. With the article she appended a set of notes which specified in complete detail a method for calculating Bernoulli numbers with the engine, recognized by some historians as the world's first computer program.^[1]

Herman Hollerith realized that he could encode information on punch cards when he observed that train conductors encode the appearance of the ticket holders on the train tickets using the position of punched holes on the tickets^[2]. Hollerith then encoded the 1890 American census data on punch cards.

Jacquard Looms and Charles Babbage's Difference Engine both had simple, extremely limited languages for describing the actions that these machines should perform. One can even regard the punch holes on a player piano scroll as a limited domain-specific language, albeit not designed for human consumption.

An early high-level programming language to be designed for a computer was Plankalkül, developed by the Germans for Z1 by Konrad Zuse between 1943 and 1945. However, it was not implemented until 1998 and 2000.^[3]

John Mauchly's Short Code, proposed in 1949, was one of the first high-level languages ever developed for an electronic computer.^[4] Unlike machine code, Short Code statements represented mathematical expressions in understandable form. However, the program had to be translated into machine code every time it ran, making the process much slower than running the equivalent machine code.

At the University of Manchester, Alick Glennie developed Autocode in the early 1950s. A programming language, it used a compiler to automatically convert the language into machine code. The first code and compiler was developed in 1952 for the Mark 1 computer at the University of Manchester and is considered to be the first compiled high-level programming language.^[5][6]

The second autocode was developed for the Mark 1 by R. A. Brooker in 1954 and was called the "Mark 1 Autocode". Brooker also developed an autocode for the Ferranti Mercury in the 1950s in conjunction with the University of Manchester. The version for the EDSAC 2 was devised by D. F. Hartley of 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 optimisation 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.

Another early programming language was devised by Grace Hopper in the US, called 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 programming language and implemented a prototype.^[11] The FLOW-MATIC compiler became publicly available in early 1958 and was substantially complete in 1959.^[12] Flow-Matic was a major influence in the design of COBOL, since only it and its direct descendent AIMACO were in actual use at the time.^[13]

Other languages still in use today include LISP (1958), invented by John McCarthy and COBOL (1959), 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").

The period from the late 1960s to the late 1970s brought a major flowering of programming languages. Most of the major language paradigms now in use were invented in this period:

• Speakeasy (computational environment), developed in 1964 at Argonne National Laboratory (ANL) by Stanley Cohen, is an OOPS (object-oriented programming, much like the later MATLAB, IDL (programming language) and Mathematica) numerical package. Speakeasy has a clear Fortran foundation syntax. It first addressed efficient physics computation internally at ANL, was modified for research use (as "Modeleasy") for the Federal Reserve Board in the early 1970s and then was made available commercially; Speakeasy and Modeleasy are still in use currently.
• Simula, invented in the late 1960s by Nygaard and Dahl as a superset of Algol 60, was the first language designed to support object-oriented programming.
• C, an early systems programming language, was developed by Dennis Ritchie and Ken Thompson at Bell Labs between 1969 and 1973.
• Smalltalk (mid-1970s) provided a complete ground-up design of an object-oriented language.
• Prolog, designed in 1972 by Colmerauer, Roussel, and Kowalski, was the first logic programming language.
• ML built a polymorphic type system (invented by Robin Milner in 1973) on top of Lisp,

[…]

1968 – Logo 1969 – B (forerunner to C) 1970 – Pascal 1970 – Forth 1972 – C

1972 – Smalltalk 1972 – Prolog 1973 – ML 1975 – Scheme 1978 – SQL (a query language, later extended)

1980 – C++ (as C with classes, renamed in 1983) 1983 – Ada 1984 – Common Lisp 1984 – MATLAB 1984 - FoxPro (as FoxBASE, later developing into Visual FoxPro 1985 – Eiffel 1986 – Objective-C

1986 – LabVIEW (Visual Programming Language) 1986 – Erlang 1987 – Perl 1988 – Tcl 1988 – Wolfram Language (as part of Mathematica, only got a separate name in June 2013) 1989 – FL (Backus)

• 1990 – Haskell
• 1991 – Python
• 1991 – Visual Basic
• 1993 – Ruby
• 1993 – Lua
• 1993 – R
• 1994 – CLOS (part of ANSI Common Lisp)

• 1995 – Ada 95
• 1995 – Java
• 1995 – Delphi (Object Pascal)
• 1995 – JavaScript
• 1995 – PHP
• 1997 – Rebol
• 1999 – D

Some notable languages developed during this period include:

2000 – ActionScript 2001 – C# 2003 – Apache Groovy 2003 – Scala 2005 – F# 2006 – Windows PowerShell 2007 – Clojure

2009 – Go 2010 – Rust 2011 – Dart 2011 – Kotlin 2012 – Julia 2014 – Swift