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 Apr 2018

Programming Languages

1940s

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

1950s

  • 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

1960s

  • ALGOL (ALGOrithmic Language) 60: early high-level language standard; groups statements into nestable blocks; has lexical scope for variables
  • 1960COBOL (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

1970s

  • Pascal: educational language based on ALGOL 60; emphasizes structured programming rather than arbitrary GOTO control flow
  • 1972C: 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

1980s

  • 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
  • 1972C++: originallyC 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

1990s

  • Haskell: research language for lazy functional programming with static types
  • 1991Python: 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
  • 1995Java: 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

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

2010s

  • 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.

@rsnous

Topics

Keep in touch

Sign up for occasional email updates from Increment.

Thank you!

We’ll be in touch.

Continue Reading

Explore Topics

All Issues