Language index

Every language indexed by this atlas, with its five axis values recorded in the same order throughout. The table below is the complete index; the sections that follow group the same entries by family.

Complete index¶

Figure 1. When each family was producing new entries: the bar runs from its earliest indexed language to its latest. A family stopping does not mean its languages stopped — C, Lisp and Prolog are all still in use — only that the tradition has not produced a new general-purpose entry since. Source: the index below.

Ordered by first public appearance. The metric column stays fixed while the table scrolls horizontally.

Language	First appeared	Family	Paradigm emphasis	Typing	Memory	Execution	Primary domain	Designers
Fortran	1957	Array and statistical	Imperative, procedural, array	Static, strong	Static/manual	AOT compiled	Numerical and scientific computing	John Backus, IBM
Lisp	1958	Lisp family	Functional, metaprogramming	Dynamic, strong	Tracing GC	Interpreted or compiled	Symbolic computation, AI research	John McCarthy
COBOL	1959	C family	Imperative, procedural	Static, weak	Static allocation	AOT compiled	Business and transaction processing	CODASYL, Grace Hopper (influence)
ALGOL 60	1960	C family	Imperative, structured	Static	Stack-based	AOT compiled	Algorithm publication, language research	ALGOL committee
APL	1962	Array and statistical	Array, functional	Dynamic	Tracing GC	Interpreted	Array mathematics, finance	Kenneth E. Iverson
BASIC	1964	Dynamic scripting	Imperative, procedural	Dynamic, weak	Interpreter-managed	Interpreted	Teaching, early microcomputers	Kemeny and Kurtz
Simula 67	1967	C family	Object-oriented, simulation	Static	Tracing GC	AOT compiled	Discrete-event simulation	Dahl and Nygaard
Pascal	1970	C family	Imperative, structured	Static, strong	Manual	AOT compiled	Teaching, early application software	Niklaus Wirth
Prolog	1972	Logic and declarative	Logic, declarative	Dynamic	Tracing GC	Interpreted or compiled	Symbolic reasoning, NLP, scheduling	Colmerauer and Roussel
C	1972	C family	Imperative, procedural	Static, weak	Manual	AOT compiled	Operating systems, embedded, runtimes	Dennis Ritchie
SQL	1974	Logic and declarative	Declarative, relational	Static, dialect-dependent	Engine-managed	Query planner	Data definition and query	Chamberlin and Boyce
Smalltalk-80	1980	Dynamic scripting	Pure object-oriented, message passing	Dynamic, strong	Tracing GC	Bytecode VM	GUI research, live environments	Alan Kay, Dan Ingalls, Adele Goldberg
Ada	1980	Systems and ownership	Imperative, concurrent, contract-based	Static, strong	Manual, pooled	AOT compiled	Avionics, defence, safety-critical	Jean Ichbiah, US DoD
Objective-C	1984	C family	Object-oriented over C, message passing	Static core with dynamic dispatch	Manual then ARC	AOT compiled	NeXTSTEP, macOS, iOS	Brad Cox and Tom Love
C++	1985	C family	Multi-paradigm, generic, object-oriented	Static, partly weak	Manual with RAII	AOT compiled	Systems, games, high-performance	Bjarne Stroustrup
Erlang	1986	ML and functional	Concurrent, functional, actor-based	Dynamic, strong	Per-process GC	Bytecode VM (BEAM)	Telecoms, fault-tolerant services	Joe Armstrong, Ericsson
Perl	1987	Dynamic scripting	Multi-paradigm, text processing	Dynamic, weak	Reference counting	Interpreted	System administration, text munging	Larry Wall
Haskell	1990	ML and functional	Purely functional, lazy	Static, strong, inferred	Tracing GC	AOT compiled	Research, compilers, finance	Haskell committee
Python	1991	Dynamic scripting	Multi-paradigm, imperative	Dynamic, strong	Refcount with cycle collector	Interpreted	Scripting, data analysis, machine learning	Guido van Rossum
Lua	1993	Dynamic scripting	Imperative, prototype-based	Dynamic, weak	Incremental tracing GC	Bytecode VM	Embedded scripting, games	PUC-Rio
R	1993	Array and statistical	Array, functional, statistical	Dynamic	Tracing GC	Interpreted	Statistics and data visualisation	Ihaka and Gentleman
Java	1995	Managed runtimes	Object-oriented, class-based	Static, strong	Tracing GC	Bytecode + JIT	Enterprise services, Android	James Gosling, Sun Microsystems
JavaScript	1995	Dynamic scripting	Multi-paradigm, prototype-based	Dynamic, weak	Tracing GC	JIT	Web front end, servers, tooling	Brendan Eich
Ruby	1995	Dynamic scripting	Object-oriented, dynamic	Dynamic, strong	Tracing GC	Bytecode VM	Web applications, scripting	Yukihiro Matsumoto
PHP	1995	Dynamic scripting	Imperative, object-oriented	Dynamic, weak	Refcount with cycle collector	Bytecode VM	Server-side web	Rasmus Lerdorf
OCaml	1996	ML and functional	Functional, imperative, object-oriented	Static, strong, inferred	Generational GC	AOT compiled or bytecode	Compilers, verification, finance	INRIA
C#	2000	Managed runtimes	Multi-paradigm, object-oriented	Static, strong, partly inferred	Tracing GC	Bytecode + JIT/AOT	Application and game development	Anders Hejlsberg, Microsoft
Scala	2004	Managed runtimes	Functional and object-oriented	Static, strong, inferred	Tracing GC (JVM)	Bytecode + JIT	Data engineering, backend services	Martin Odersky
F#	2005	ML and functional	Functional-first, multi-paradigm	Static, strong, inferred	Tracing GC (.NET)	Bytecode + JIT	Analytics, backend services	Don Syme, Microsoft Research
Clojure	2007	Lisp family	Functional, Lisp, immutable data	Dynamic, strong, optional specs	Tracing GC (JVM)	Bytecode + JIT	Data-oriented backend services	Rich Hickey
Go	2009	C family	Imperative, CSP concurrency	Static, strong	Concurrent tracing GC	AOT compiled	Network services, infrastructure	Griesemer, Pike, Thompson
Rust	2010	Systems and ownership	Multi-paradigm, functional-leaning	Static, strong, inferred	Ownership and borrowing	AOT compiled (LLVM)	Systems, tooling, embedded	Graydon Hoare, Mozilla
Kotlin	2011	Managed runtimes	Object-oriented and functional	Static, strong, inferred	Tracing GC (JVM)	Bytecode + JIT, native AOT	Android, backend services	JetBrains
Elixir	2012	ML and functional	Functional, concurrent, actor-based	Dynamic, strong	Per-process GC	Bytecode VM (BEAM)	Distributed and real-time services	José Valim
Julia	2012	Array and statistical	Multiple dispatch, array, scientific	Dynamic with type annotations	Tracing GC	JIT (LLVM)	Scientific and numerical computing	Bezanson, Karpinski, Shah, Edelman
TypeScript	2012	Dynamic scripting	Multi-paradigm, structural typing	Static, erased at runtime	Tracing GC (host)	Transpiled to JavaScript	Large-scale web and tooling	Anders Hejlsberg, Microsoft
Swift	2014	Systems and ownership	Protocol-oriented, multi-paradigm	Static, strong, inferred	Automatic Reference Counting	AOT compiled (LLVM)	Apple platforms, server-side	Chris Lattner and Apple Inc.
Zig	2016	Systems and ownership	Imperative, compile-time metaprogramming	Static, strong	Manual, explicit allocators	AOT compiled (LLVM)	Systems, C toolchain replacement	Andrew Kelley

38 entries. Sources: language specifications and reference implementation documentation. Dates are first public release or publication, not the start of internal development.

Static checked before execution Dynamic checked during execution GC automatic, collector-driven Manual programmer-directed Ownership/ARC compile-time or refcount discipline Unspecified varies by implementation

C family¶

Curly-brace syntax and an imperative core, descending from ALGOL through C. The tradition most later languages either extend or explicitly react against.

COBOL

Imperative, procedural.

1959 · Static, weak · Static allocation

ALGOL 60

Imperative, structured.

1960 · Static · Stack-based

Simula 67

Object-oriented, simulation.

1967 · Static · Tracing GC

Pascal

Imperative, structured.

1970 · Static, strong · Manual

C

Imperative, procedural.

1972 · Static, weak · Manual

Objective-C

Object-oriented over C, message passing.

1984 · Static core with dynamic dispatch · Manual then ARC

C++

Multi-paradigm, generic, object-oriented.

1985 · Static, partly weak · Manual with RAII

Go

Imperative, CSP concurrency.

2009 · Static, strong · Concurrent tracing GC

ML and functional¶

Algebraic data types, exhaustive pattern matching, and inference-driven typing. The source of most type-system features adopted by mainstream languages since 2010.

Erlang

Concurrent, functional, actor-based.

1986 · Dynamic, strong · Per-process GC

Haskell

Purely functional, lazy.

1990 · Static, strong, inferred · Tracing GC

OCaml

Functional, imperative, object-oriented.

1996 · Static, strong, inferred · Generational GC

F#

Functional-first, multi-paradigm.

2005 · Static, strong, inferred · Tracing GC (.NET)

Elixir

Functional, concurrent, actor-based.

2012 · Dynamic, strong · Per-process GC

Lisp family¶

Code represented as data, macros as the primary extension mechanism, and a preference for interactive development.

Lisp

Functional, metaprogramming.

1958 · Dynamic, strong · Tracing GC

Clojure

Functional, Lisp, immutable data.

2007 · Dynamic, strong, optional specs · Tracing GC (JVM)

Dynamic scripting¶

Late binding and rapid iteration, usually paired with a large package ecosystem and an interpreter or JIT.

BASIC

Imperative, procedural.

1964 · Dynamic, weak · Interpreter-managed

Smalltalk-80

Pure object-oriented, message passing.

1980 · Dynamic, strong · Tracing GC

Perl

Multi-paradigm, text processing.

1987 · Dynamic, weak · Reference counting

Python

Multi-paradigm, imperative.

1991 · Dynamic, strong · Refcount with cycle collector

Lua

Imperative, prototype-based.

1993 · Dynamic, weak · Incremental tracing GC

JavaScript

Multi-paradigm, prototype-based.

1995 · Dynamic, weak · Tracing GC

Ruby

Object-oriented, dynamic.

1995 · Dynamic, strong · Tracing GC

PHP

Imperative, object-oriented.

1995 · Dynamic, weak · Refcount with cycle collector

TypeScript

Multi-paradigm, structural typing.

2012 · Static, erased at runtime · Tracing GC (host)

Systems and ownership¶

Predictable performance without a tracing collector, achieved through ownership, borrowing, or reference counting checked at compile time.

Ada

Imperative, concurrent, contract-based.

1980 · Static, strong · Manual, pooled

Rust

Multi-paradigm, functional-leaning.

2010 · Static, strong, inferred · Ownership and borrowing

Swift

Protocol-oriented, multi-paradigm.

2014 · Static, strong, inferred · Automatic Reference Counting

Zig

Imperative, compile-time metaprogramming.

2016 · Static, strong · Manual, explicit allocators

Managed runtimes¶

Languages targeting a shared virtual machine and inheriting its collector, threading model, and library surface.

Java

Object-oriented, class-based.

1995 · Static, strong · Tracing GC

C#

Multi-paradigm, object-oriented.

2000 · Static, strong, partly inferred · Tracing GC

Scala

Functional and object-oriented.

2004 · Static, strong, inferred · Tracing GC (JVM)

Kotlin

Object-oriented and functional.

2011 · Static, strong, inferred · Tracing GC (JVM)

Array and statistical¶

Whole-array operations as the primary abstraction, with vectorised semantics in place of explicit element loops.

Fortran

Imperative, procedural, array.

1957 · Static, strong · Static/manual

APL

Array, functional.

1962 · Dynamic · Tracing GC

R

Array, functional, statistical.

1993 · Dynamic · Tracing GC

Julia

Multiple dispatch, array, scientific.

2012 · Dynamic with type annotations · Tracing GC

Logic and declarative¶

Programs stated as relations or constraints, with the runtime searching for satisfying answers.

Prolog

Logic, declarative.

1972 · Dynamic · Tracing GC

SQL

Declarative, relational.

1974 · Static, dialect-dependent · Engine-managed