Programming Languages

Assembly language

by Kathleen Booth

Assembly language turns raw machine code into readable mnemonics. Its roots go back to Kathleen Booth in 1947 and EDSAC in 1949, and it still matters in kernels and embedded systems.

ImperativeUnstructured

Plankalkül

by Konrad Zuse

Konrad Zuse designed Plankalkül between 1942 and 1945, the first known high-level programming language. It stayed on paper for decades, yet anticipated ideas later found in ALGOL.

ProceduralImperative

Short Code

by John Mauchly

Short Code, proposed by John Mauchly in 1949, let programmers write equations instead of machine instructions. It ran on the BINAC and UNIVAC I as an interpreter.

ImperativeInterpreted

Autocode

by Alick Glennie

Autocode began with Alick Glennie's 1952 compiler for the Manchester Mark 1 and grew into a family of British languages, from Mark 1 Autocode to Atlas Autocode.

ProceduralImperative

FLOW-MATIC

by Grace Hopper

FLOW-MATIC, led by Grace Hopper at Remington Rand from 1955, was the first English-like data processing language and a direct model for COBOL.

ProceduralImperative

IPL (Information Processing Language)

by Allen Newell, Cliff Shaw, Herbert A. Simon

IPL, created in 1956 by Allen Newell, Cliff Shaw and Herbert Simon, introduced list processing and powered the Logic Theorist, one of the first AI programs.

List processingProcedural

Fortran

by John Backus

Fortran was created by John Backus and a small IBM team and released in 1957 for the IBM 704. Nearly 70 years later it still runs much of scientific computing.

ProceduralImperative

ALGOL

by International committee

ALGOL began as an international committee language in 1958. ALGOL 60 introduced block structure and BNF and shaped Pascal, Simula, C and most languages since.

ProceduralImperative

Lisp

by John McCarthy

John McCarthy designed Lisp at MIT in 1958. It introduced S-expressions, garbage collection and code-as-data, and lives on in Common Lisp, Scheme, Racket and Clojure.

FunctionalProcedural

COBOL

by CODASYL committee

COBOL was designed by the CODASYL committee in 1959 for business data processing. It still runs core systems at banks, insurers and government agencies.

Procedural

JOVIAL

by Jules Schwartz

JOVIAL, created by Jules Schwartz at System Development Corporation from 1959, became the U.S. Air Force's standard language for avionics and command systems.

ProceduralImperative

Simula

by Ole-Johan Dahl, Kristen Nygaard

Simula, created by Ole-Johan Dahl and Kristen Nygaard in Oslo, gave the world classes, objects and inheritance. This is how it happened and why it matters.

Object-orientedImperative

SNOBOL

by David J. Farber, Ralph E. Griswold, Ivan P. Po…

SNOBOL was a string-processing language created at Bell Labs in 1962. Its pattern matching, refined in SNOBOL4, was decades ahead of its time.

ImperativeString processing

BASIC

by John G. Kemeny, Thomas E. Kurtz

BASIC was created at Dartmouth in 1964 so that every student, not just scientists, could use a computer. It went on to define the home computer era.

PL/I

by IBM and the SHARE Language Development Committee

PL/I was IBM's 1964 attempt at one language for both science and business on System/360. It was ambitious, influential and still runs on mainframes today.

ImperativeProcedural

APL

by Kenneth E. Iverson

APL began as Kenneth Iverson's mathematical notation and became an IBM time-sharing language in 1966. Here is why it is written in symbols and who still uses it.

ArrayFunctional

BCPL

by Martin Richards

BCPL was Martin Richards' small, typeless systems language from 1967. It shaped B, and through B, the C language that still runs the world.

ImperativeProcedural

Logo

by Wally Feurzeig, Seymour Papert, Cynthia Solomon

Logo was created in 1967 to help children think mathematically. Its turtle graphics turned geometry into something kids could program and see.

FunctionalProcedural

B

by Ken Thompson, with Dennis Ritchie

B was Ken Thompson's small, typeless language for early Unix, created around 1969. It lasted only a few years but led directly to C.

ImperativeProcedural

Forth

by Charles H.

Forth is Chuck Moore's tiny, stack-based language from around 1970. It runs on almost nothing and still controls embedded hardware today.

ConcatenativeStack-based

Pascal

by Niklaus Wirth

Niklaus Wirth released Pascal in 1970 to teach structured programming clearly. It went on to power classrooms, Turbo Pascal, the early Mac and Delphi.

ImperativeStructured

C

by Dennis Ritchie

Dennis Ritchie created C at Bell Labs around 1972 to rewrite Unix. Five decades later it still runs operating systems, databases and embedded devices.

ImperativeProcedural

Prolog

by Alain Colmerauer, Philippe Roussel, Robert Kow…

Prolog grew out of a French question-answering project in 1972 and became the best-known logic programming language, still used for rules, parsing and symbolic AI.

LogicDeclarative

Smalltalk

by Alan Kay, Dan Ingalls, Adele Goldberg

Smalltalk, created at Xerox PARC in the 1970s, treated everything as an object. It shaped GUIs, object-oriented design and modern IDEs.

Object-orientedReflective

ML

by Robin Milner and colleagues at the University…

ML began in 1973 as the scripting language of an Edinburgh theorem prover and introduced practical type inference, shaping OCaml, F#, Haskell and Rust.

FunctionalImperative

SQL

by Donald D. Chamberlin, Raymond F. Boyce

SQL began as SEQUEL at IBM in 1974, built on Codd's relational model, and became the standard language for querying relational databases.

DeclarativeDomain-specific

Scheme

by Guy L. Steele Jr., Gerald Jay Sussman

Scheme was created at MIT in 1975 as a tiny, lexically scoped Lisp. Its minimalism made it a favourite for teaching and for research into language design.

FunctionalImperative

AWK

by Alfred Aho, Peter Weinberger, Brian Kernighan

AWK was created at Bell Labs in 1977 for quick text processing. Its pattern-action model still makes it one of the handiest tools on any Unix system.

ScriptingProcedural

Modula-2

by Niklaus Wirth

Modula-2 was designed by Niklaus Wirth at ETH Zurich around 1978 as a modular successor to Pascal, and was used to write the entire software of the Lilith workstation.

ImperativeStructured

Ada

by Jean Ichbiah

Ada grew out of a US Department of Defense competition won by Jean Ichbiah's 'Green' design in 1979. It remains a leading language for safety-critical software.

StructuredImperative

Objective-C

by Brad Cox, Tom Love

Objective-C added Smalltalk-style messaging to C in the early 1980s. Adopted by NeXT and then Apple, it powered Mac OS X and the first generation of iPhone apps.

Object-orientedReflective

MATLAB

by Cleve Moler

MATLAB began in the late 1970s as Cleve Moler's matrix calculator for students and became, from 1984, the commercial standard for numerical computing in engineering.

ArrayImperative

Common Lisp

by Scott Fahlman, Richard P. Gabriel, David A. Mo…

Common Lisp was created in the early 1980s to merge competing Maclisp successors into one portable language, standardised by ANSI in 1994.

FunctionalProcedural

C++

by Bjarne Stroustrup

C++ started in 1979 as 'C with Classes' at Bell Labs and became a standard systems language behind browsers, game engines, databases and trading systems.

ProceduralObject-oriented

Eiffel

by Bertrand Meyer

Eiffel, released in 1986 by Bertrand Meyer, made preconditions, postconditions and class invariants part of the language, an idea known as Design by Contract.

Object-orientedClass-based

Erlang

by Joe Armstrong, Robert Virding, Mike Williams

Erlang was designed at Ericsson in 1986 to run telephone switches that never stop. Its processes and supervisors now power messaging, queues and Elixir.

FunctionalConcurrent

Perl

by Larry Wall

Larry Wall released Perl in 1987 to tame text reports. A decade later it was holding the early web together, one CGI script at a time.

ProceduralObject-oriented

Tcl

by John Ousterhout

John Ousterhout built Tcl at Berkeley in 1988 as a reusable command language for tools. Its radical rule that everything is a string still shapes how it works.

ImperativeEvent-driven

Haskell

by Haskell committee

Haskell was designed by a committee to unify lazy functional languages. They named it after logician Haskell Curry, whose work underpins the whole idea.

Purely functionalLazy

Visual Basic

by Alan Cooper

Visual Basic launched in 1991 and let millions draw a Windows interface and attach code to it. Its drag-and-drop core began as Alan Cooper's prototype.

Event-drivenObject-based

Python

by Guido van Rossum

Guido van Rossum released Python in 1991, borrowing indentation-based blocks from ABC. That choice still defines how Python code looks and reads.

Object-orientedProcedural

Lua

by Roberto Ierusalimschy, Luiz Henrique de Figuei…

Lua was created in 1993 at PUC-Rio in Brazil as a small embeddable language. Its size and speed made it the scripting layer of choice for game engines.

ImperativeProcedural

R

by Ross Ihaka, Robert Gentleman

R began at the University of Auckland in 1993 as a free take on the S statistics language. Its one-letter name nods to both its creators and S.

FunctionalArray

Delphi (Object Pascal)

by Anders Hejlsberg

Borland launched Delphi in 1995, pairing Object Pascal with a visual designer and native compiler. Its name was a joke about talking to the Oracle.

ImperativeStructured

Java

by James Gosling

Java began in 1991 as Oak, a language for consumer devices at Sun. A trademark clash forced a new name just before its 1995 debut on the web.

Object-orientedClass-based

JavaScript

by Brendan Eich

In May 1995 Brendan Eich built the first JavaScript prototype at Netscape in about ten days. That rushed language now runs on nearly every web page.

Event-drivenFunctional

PHP

by Rasmus Lerdorf

PHP started in 1995 as Rasmus Lerdorf's Personal Home Page Tools. It grew into the server language behind WordPress, Wikipedia and much of the web.

ImperativeObject-oriented

Ruby

by Yukihiro Matsumoto

Yukihiro Matsumoto released Ruby in Japan in 1995 with an unusual goal: make programmers enjoy their work. Rails later carried that idea worldwide.

Object-orientedFunctional

OCaml

by Xavier Leroy, Jérôme Vouillon, Damien Doligez,…

OCaml grew out of INRIA's Caml research in 1996. Its type system and native speed won over theorem provers, compiler writers and a famous trading firm.

FunctionalImperative

C#

by Anders Hejlsberg

C# began as Microsoft's answer to losing control of Java. Here is how Anders Hejlsberg's team built it, how it evolved, and where it runs today.

Object-orientedImperative

D

by Walter Bright, Andrei Alexandrescu

D is what a veteran C++ compiler writer built when he started over. A look at its origins, features, compilers and real-world users.

ImperativeObject-oriented

Groovy

by James Strachan

Groovy started as a friendlier scripting language for Java developers and ended up running countless CI/CD pipelines. Here is how that happened.

Object-orientedImperative

Scala

by Martin Odersky

Scala brought functional programming to the JVM without giving up objects. A look at Martin Odersky's design, Scala 3 and where Scala runs today.

FunctionalObject-oriented

F#

by Don Syme

F# took the ML family of languages and made it a first-class citizen on .NET. Its origins, features, influence on C# and where it is used now.

FunctionalImperative

Clojure

by Rich Hickey

Clojure is a Lisp that chose the JVM on purpose. Why Rich Hickey made that choice, what makes the language different, and where it runs today.

FunctionalLisp

Go

by Robert Griesemer, Rob Pike, Ken Thompson

Go was born from frustration with slow builds and complex code at Google. How three veteran engineers designed it and why it now runs the cloud.

ImperativeConcurrent

Dart

by Lars Bak and Kasper Lund

Dart was built to replace JavaScript in the browser and nearly faded away. Then Flutter arrived. Here is the full story of Google's comeback language.

Object-orientedImperative

Kotlin

by Andrey Breslav and the JetBrains team

JetBrains wanted a better Java for its own huge codebase, and Scala compiled too slowly. Here is how Kotlin came to be and why Android made it mainstream.

Object-orientedFunctional

Julia

by Jeff Bezanson, Stefan Karpinski, Viral B. Shah…

Scientists used to prototype in Python or MATLAB and rewrite in C or Fortran. Julia was built at MIT to end that split. Here is how it works and who uses it.

Multiple dispatchFunctional

Elixir

by José Valim

A Rails core developer frustrated with concurrency built a friendlier language on Erlang's battle-tested VM. Here is how Elixir came to power Discord and Phoenix.

FunctionalConcurrent

TypeScript

by Anders Hejlsberg

TypeScript won by refusing to replace JavaScript. Here is why Microsoft designed it as a typed superset, how it spread, and what the Go-based compiler changes.

Object-orientedFunctional

Swift

by Chris Lattner, with Doug Gregor, John McCall,…

Swift started as Chris Lattner's side project in 2010 and became Apple's main language in 2014. Here is why Apple moved on from Objective-C and what Swift does well.

Protocol-orientedObject-oriented

Rust

by Graydon Hoare

Rust gives C-level control with compile-time memory safety. How ownership works, where Rust came from, and why Linux, Windows and Android adopted it.

ImperativeFunctional

Gleam

by Louis Pilfold

Gleam brings static types to the Erlang VM with a tiny, friendly language. Here is where it came from, how it compares to Elixir, and what is still missing.

FunctionalConcurrent

Zig

by Andrew Kelley

Zig aims to be a better C, not a bigger one. Here is why Andrew Kelley started it, how comptime and explicit allocators work, and what pre-1.0 really means.

ImperativeProcedural

Carbon

by Chandler Carruth, with Kate Gregory, Richard S…

Carbon is an experimental language meant to do for C++ what Kotlin did for Java. Here is why Google engineers started it, how it works and how far along it is.

ImperativeObject-oriented

Mojo

by Chris Lattner and the Modular team

Mojo looks like Python but compiles like a systems language. Here is who built it, why, how it works with Python, and what is still experimental.

ImperativeObject-oriented