A snapshot of programming language history

Programming languages have evolved in incredible and innovative ways. Here’s a quick look at just some of the languages that have sprung up over the decades.
Part of
Issue 5 April 2018

Programming Languages


  • Plankalkül: proposal for first high-level programming language; never implemented


  • Short Code: first runnable language that was not machine code; mathematical expressions as statements, run by an interpreter

  • A-0 (Arithmetic Language 0) system: proto-compiler; could link subroutines and call them with arguments

  • IPL (Information Processing Language): assembly language supporting lists, higher-order functions, and recursion

  • FORTRAN (FORmula TRANslation): first high-level language with an optimizing compiler; introduces assignments, nested expressions, conditionals, and loops

  • FLOW-MATIC: arithmetic language with English-like syntax and a formal “data description” facility

  • LISP (LISt Processor): list-processing language, oriented around symbols instead of numbers; garbage collection; conditional expressions; self-interpreter


  • ALGOL (ALGOrithmic Language) 60: early high-level language standard; groups statements into nestable blocks; has lexical scope for variables

  • 1960—COBOL (COmmon Business-Oriented Language): high-level language designed for portability and human readability

  • FORMAC (FORmula MAnipulation Compiler): early computer algebra language, extending FORTRAN

  • APL (A Programming Language): array processing language with special graphical notation; concise chains of operators act on arrays

  • SNOBOL (StriNg Oriented and symBOlic Language): built around string-matching patterns; eventually supplanted by regular expressions

  • BASIC (Beginner’s All-purpose Symbolic Instruction Code): general-purpose language designed for ease of use by non-technical users; would become popular on home computers

  • PL/I (Programming Language One): unified ALGOL-style language for all IBM users; part of IBM System/360 project; introduces variable storage classes and exception handling

  • Simula 67: first object-oriented programming language, intended for simulations; extension of ALGOL 60; includes classes, subclasses, inheritance, coroutines

  • Logo: educational language using “turtle graphics” to teach programming and mathematical concepts; dialect of Lisp

  • ALGOL 68: new standard includes expression-oriented syntax, type system, and support for operator overloading; never fully implemented or adopted

  • GRAIL (GRAphical Input Language): early visual programming system; programmers draw flowcharts and hand-write code on RAND Tablet


  • Pascal: educational language based on ALGOL 60; emphasizes structured programming rather than arbitrary GOTO control flow

  • 1972—C: systems programming language with static types and good facilities for raw memory manipulation; implementation language of Unix, as well as much systems software up to the present day

  • Prolog: one of the first logic programming languages; programs made up of relations rather than statements or expressions

  • Smalltalk: early object-oriented programming language; built around message passing and late binding; all entities in the language are objects, no passive data

  • ML (Meta Language): introduces Hindley-Milner type inference, modules, and “applicative” (functional) style with static types; ancestor of Haskell, F#, OCaml

  • Scheme: Lisp descendant; adds ALGOL’s lexical scope; also adds tail call elimination

  • Mesa: systems programming language from the Xerox Palo Alto Research Center; typed module system; first supported the monitor synchronization construct; had powerful exception handling

  • Ada: procedural programming language, commissioned by the U.S. Department of Defense for safety-critical work; complex, with strong typing and full concurrency support


  • Common Lisp: attempt to unify various Lisp dialects; settles on lexical variable scope as in Scheme; Common Lisp and Scheme become the two major Lisp families

  • PostScript: Adobe’s page description language; stack-based, so all data lives on stacks; used by printers and in graphics tools; pioneering vector graphics model

  • 1972—C++: originally “C with Classes”; adds low-cost abstractions to C for generic programming and object-oriented programming

  • Erlang: language for concurrent and fault-tolerant software, built out of many lightweight processes; used in telecommunications

  • Objective-C: adds Smalltalk-style object-oriented programming with message passing to C; would be adopted by NeXT and then Apple for Mac and iOS

  • Perl: general-purpose scripting language with powerful string manipulation tools

  • Tcl: simple, embeddable scripting language for “gluing” larger components together


  • Haskell: research language for lazy functional programming with static types

  • 1991—Python: scripting language in similar niche to Perl; clean design, whitespace syntax, and list comprehensions

  • Visual Basic: BASIC descendant with drag-and-drop interface for making GUIs; integrated development environment

  • PHP: begins as preprocessor for embedded code in web pages; becomes a way to build dynamic web applications

  • 1995—Java: object-oriented programming language with automatic memory management; combination of ideas from C++ and Smalltalk; originally meant for the web, but grows to dominate enterprise software

  • JavaScript: the web frontend programming language; Scheme-like semantics underneath Java-like syntax

  • Ruby: scripting language; humanizes metaprogramming concepts from Smalltalk and Lisp; would become popular for web programming in the 2000s


  • C#: object-oriented language, originally similar to Java; part of Microsoft’s then-new .NET framework

  • Scala: statically typed functional programming language; runs on Java virtual machine and interoperates with Java, but supports functional programming and has more expressive types in ML tradition

  • Clojure: Lisp variant that interoperates with Java; like most Lisps, dynamically typed; emphasizes functional programming and immutable data

  • Go: developed at Google for “large systems”; simple static types, built-in concurrency, garbage collection, and fast compilation


  • Rust: systems programming language; meant to compete with C++ for low-level and high-performance software, while improving safety and concurrency; multi-paradigm (object-oriented, functional, and procedural features)

  • Swift: multi-paradigm Apple language for iOS and Mac development and more; safer and more expressive type system than Objective-C, drawing ideas from languages like Haskell and C#

About the author

Omar Rizwan is the author of Screenotate, a tool for taking searchable screenshots, and Cruncher, a calculating notepad. He likes computers, cities, and the future.


Artwork by

Ola Niepsuj



Buy the print edition

Visit the Increment Store to purchase print issues.


Continue Reading

Explore Topics

All Issues