Programming Language Atlas

A structured reference to language families, paradigms, and implementations

Timeline

Seven decades of general-purpose language design, grouped by the pressure that produced each wave. Dates are first public release or publication.

The shape of the record

Three views of the same dataset before the narrative: when entries appeared, how the index accumulated, and how long each period's concerns stayed live.

1957Fortran: the compiler1960ALGOL 60: block structure1972C: portable systems code1995Java: a shared runtime2010Rust: ownership2024Swift 6: checked isolation
Figure 1. Six turning points, chosen because each one changed what a later language could assume rather than because of the language's own reach. Positions are ordinal: the axis orders the events and does not scale the intervals between them.
0101928381950s1960s1970s1980s1990s2000s2010s2020sCumulative · 1950s: 33Cumulative · 1960s: 77Cumulative · 1970s: 1111Cumulative · 1980s: 1717Cumulative · 1990s: 2626Cumulative · 2000s: 3131Cumulative · 2010s: 3838Cumulative · 2020s: 3838CumulativeNew entries · 1950s: 33New entries · 1960s: 44New entries · 1970s: 44New entries · 1980s: 66New entries · 1990s: 99New entries · 2000s: 55New entries · 2010s: 77New entries · 2020s: 00New entriesentries
Figure 2. New entries per decade against the running total. The rate peaks in the 1990s and has fallen since; the cumulative line flattening is the same fact stated the other way. Source: this atlas's index.
19571975199220092026Machine independence — 1957 onwardMachine independence1957 onwardStructure and grammar — ALGOL to PascalStructure and grammarALGOL to PascalPortable systems code — still activePortable systems codestill activeObject orientation — peak 1985-2005Object orientationpeak 1985-2005Managed runtimes — still activeManaged runtimesstill activeFunctional revival — still activeFunctional revivalstill activeCompile-time safety — currentCompile-time safetycurrentData-race safety — currentData-race safetycurrent
Figure 3. How long each period's central concern stayed the active one. The bars overlap because periods do not end: portability outlived the 1970s, and object orientation is still the default organising idea in most of the index. Spans are editorial readings of the record, not measurements.

Back to top

Periods

1950s

Escaping the machine.

Fortran (1957), Lisp (1958), COBOL (1959)

1960s

Structure and abstraction.

ALGOL 60 (1960), APL (1962), BASIC (1964), Simula 67 (1967)

1970s

Systems and reasoning.

Pascal (1970), C (1972), Prolog (1972), SQL (1974)

1980s

Objects and scale.

Smalltalk-80 (1980), Ada (1980), Objective-C (1984), C++ (1985), Erlang (1986), Perl (1987)

1990s

The scripting and web wave.

Haskell (1990), Python (1991), Lua (1993), R (1993), Java (1995), JavaScript (1995), Ruby (1995), PHP (1995), OCaml (1996)

2000s

Managed platforms and functional revival.

C# (2000), Scala (2004), F# (2005), Clojure (2007), Go (2009)

2010s

Safety without a collector.

Rust (2010), Kotlin (2011), Elixir (2012), Julia (2012), TypeScript (2012), Swift (2014), Zig (2016)

2020s

Consolidation.

Swift 6 (2024), Rust editions, Java and C# release cadence

Back to top

Period detail

Each period is followed by a note on the problem the wave was responding to.

Period Theme Entries
1950s Escaping the machine Fortran (1957), Lisp (1958), COBOL (1959)
The first languages that let a program be written in something other than the machine's own instruction set. Fortran established the compiler as a practical tool, Lisp established symbolic computation, and COBOL established that a language could be designed for a business domain.
1960s Structure and abstraction ALGOL 60 (1960), APL (1962), BASIC (1964), Simula 67 (1967)
Block structure, formal grammar description, and the first object model. ALGOL supplied the notation that nearly every later language borrowed; Simula supplied classes and inheritance.
1970s Systems and reasoning Pascal (1970), C (1972), Prolog (1972), SQL (1974)
C made a portable operating system possible and fixed the syntax of the next fifty years. Prolog and SQL demonstrated that useful programs could be written declaratively.
1980s Objects and scale Smalltalk-80 (1980), Ada (1980), Objective-C (1984), C++ (1985), Erlang (1986), Perl (1987)
Object orientation moved from research to industry, driven by the need to organise programs too large for one author. Erlang answered a different question: how to keep running through failure.
1990s The scripting and web wave Haskell (1990), Python (1991), Lua (1993), R (1993), Java (1995), JavaScript (1995), Ruby (1995), PHP (1995), OCaml (1996)
Networked deployment rewarded portability and fast iteration. Four of the languages that still dominate the web appeared within a single year.
2000s Managed platforms and functional revival C# (2000), Scala (2004), F# (2005), Clojure (2007), Go (2009)
Virtual machines became platforms in their own right, hosting several languages each. Multi-core hardware renewed interest in immutability and message passing.
2010s Safety without a collector Rust (2010), Kotlin (2011), Elixir (2012), Julia (2012), TypeScript (2012), Swift (2014), Zig (2016)
The decade's common theme is checking more at compile time: ownership in Rust, optionals and value semantics in Swift, gradual types over JavaScript in TypeScript, nullability in Kotlin.
2020s Consolidation Swift 6 (2024), Rust editions, Java and C# release cadence
Rather than new general-purpose languages, the period is marked by established languages adopting each other's features: data-race checking, pattern matching, and structured concurrency became broadly available.

Sources: language specifications, official histories, and release announcements. Grouping by theme is editorial; the dates are not.

Back to top

Entries by decade

Decade Entries Languages
1950s 3 COBOL, Fortran, Lisp
1960s 4 ALGOL 60, APL, BASIC, Simula 67
1970s 4 C, Pascal, Prolog, SQL
1980s 6 Ada, C++, Erlang, Objective-C, Perl, Smalltalk-80
1990s 9 Haskell, Java, JavaScript, Lua, OCaml, PHP, Python, R, Ruby
2000s 5 C#, Clojure, F#, Go, Scala
2010s 7 Elixir, Julia, Kotlin, Rust, Swift, TypeScript, Zig
2020s 0 — no entry meets the inclusion criteria

Counts describe this atlas's 38 indexed entries and reflect its inclusion criteria, not the rate at which languages were created.

Back to top

Longevity

Language adoption changes far more slowly than language creation. Of the entries here, those written in the 1950s through 1970s — Fortran, Lisp, COBOL, C, SQL — remain in production use, in most cases through successive standard revisions rather than replacement. The practical implication is that a language's design decisions outlive the hardware and the organisation that prompted them, which is the argument for recording them precisely.

The Swift version history shows the modern counterpart: a language whose syntax changed substantially through version 3 and then deliberately stabilised, first at the source level and later at the binary interface.

Back to top