Timeline

Lines of influence

35 moments across eight languages, oldest to newest. Filter by language, or follow the threads of influence below.

1987 · OCaml - Caml - the ML descendant
OCaml's lineage traces to Robin Milner's **ML** (1973) for the LCF theorem prover. In 1985 Guy Cousineau and colleagues at INRIA designed **Caml** atop the Categorical Abstract Machine; the first **Caml** implementation appeared in **1987**.1987 · Perl - Perl 1.0 released
Larry Wall, a linguist by training, released **Perl 1.0** to the `comp.sources.misc` Usenet newsgroup on **18 December 1987**. Built to make practical extraction and reporting feel effortless, it fused `awk`, `sed`, the shell, and `C` into one text-slinging glue language.1990 · Haskell - Haskell created (Haskell 1.0)
The Haskell Committee published the first Haskell Report on April 1, 1990, defining a pure, lazy, statically typed functional language. Named after the logician Haskell Brooks Curry, it unified non-strict functional languages such as Miranda and Lazy ML into a common standard. Its core ideas: type classes for principled overloading, Hindley-Milner type inference, algebraic data types, and pattern matching: ```haskell data Tree a = Leaf | Node (Tree a) a (Tree a) size :: Tree a -> Int size Leaf = 0 size (Node l _ r) = 1 + size l + size r ```1991 · Python - Python 0.9.0 released
Guido van Rossum, having started the project over Christmas 1989 as a hobby, released **Python 0.9.0** to `alt.sources` on **20 February 1991**. It already had exceptions, functions, and the core types `list`, `dict`, and `str`. The name was a nod to *Monty Python's Flying Circus*.1991 · Perl - Perl 4 & the Camel Book
**Perl 4.000** shipped on **21 March 1991** and was the version documented by the first edition of O'Reilly's *Programming Perl*, the famous **"Camel Book"** (January 1991), which is why a dromedary became the language's mascot. It was a stabilization release rather than a redesign.1994 · Perl - Perl 5.000 - references & modules
**Perl 5.000** shipped on **17 October 1994** as a near-total rewrite. It introduced *references*, real *data structures*, lexically-scoped `my` variables, *packages* and *modules*, and a blessed-reference object system, making the language extensible for the first time.1995 · Perl - CPAN goes live
On **26 October 1995** the **Comprehensive Perl Archive Network (CPAN)** went live: the first large-scale open-source package archive and the spiritual ancestor of npm, RubyGems, PyPI, and Cargo.1996 · OCaml - Objective Caml (OCaml)
Modern **OCaml** emerged in **1996** when Didier Remy and Jerome Vouillon added an elegant object system to Caml Special Light, itself the bearer of a native-code compiler and a powerful module system. The result was *Objective Caml*: functional, imperative, and object-oriented in one.1999 · Haskell - Haskell 98 standardized
The Haskell 98 Report was published in February 1999 as a stable, minimal, portable language plus a standard library, intended for teaching and as a base for extensions. A corrected edition, the Revised Report, followed in January 2003. Haskell 98 codified the monadic IO and do-notation programmers still use: ```haskell main :: IO () main = do putStr "Name: " name <- getLine putStrLn ("Hello, " ++ name) ```2000 · Raku - Perl 6 announced
At the Perl Conference on **19 July 2000**, Larry Wall announced **Perl 6**: a community-designed, backward-incompatible redesign answering hundreds of RFCs. Wall framed it as a *sister language* to Perl, not a replacement, working through the requests in his famous *Apocalypses*.2000 · Python - Python 2.0
**Python 2.0** arrived on **16 October 2000**, adding list comprehensions, a cycle-detecting garbage collector, and Unicode support. It was developed in a more open, community-driven process than earlier versions.2005 · Raku - Pugs proves the design
Audrey Tang's **Pugs**, a Haskell-based Perl 6 interpreter started on **1 February 2005**, was the first implementation to run real Perl 6 code. It pulled functional-programming sensibilities, lazy lists, immutability, strong typing, deeper into the language while the design was still settling.2006 · Rust - Rust begins as a side project
**Rust** started in **2006** as a personal project of Mozilla engineer **Graydon Hoare**, aiming for memory safety without a garbage collector. Mozilla began officially sponsoring it in **2009**, drawing affine and substructural ideas from the ML family and Cyclone.2006 · Haskell - GHC becomes the de-facto compiler
The Glasgow Haskell Compiler (GHC), first released in 1992, grew into Haskell's de-facto implementation, an optimizing native-code compiler with a rich extension set, GHCi REPL, and the Cabal/Stack tooling plus Hackage package ecosystem. By the mid-2000s its language extensions (GADTs, type families, multi-param classes) drove the language's evolution. ```haskell {-# LANGUAGE GADTs #-} data Expr a where IntLit :: Int -> Expr Int BoolLit :: Bool -> Expr Bool Add :: Expr Int -> Expr Int -> Expr Int ```2008 · Python - Python 3.0 - the great break
**Python 3.0** shipped on **3 December 2008**: a deliberately backward-incompatible cleanup that made `print` a function, unified `str` on Unicode, and fixed long-standing warts. The 2-to-3 migration would dominate the community for over a decade.2009 · Go - Go announced
Conceived at Google in September 2007 by **Robert Griesemer, Rob Pike, and Ken Thompson** as an antidote to slow builds and tangled dependencies, **Go** was announced publicly on **10 November 2009** and open-sourced. Its mascot, the Gopher, arrived with it.2010 · Haskell - Haskell 2010 released
Haskell 2010, announced in late 2009 and published as a report in 2010, was the first revision from the ongoing Haskell Prime process succeeding Haskell 98. It folded in widely used features like the Foreign Function Interface, hierarchical module names, and pattern guards. ```haskell classify :: Int -> String classify n | n < 0 = "negative" | n == 0 = "zero" | otherwise = "positive" ```2012 · Go - Go 1.0 - the compatibility promise
**Go 1.0** shipped on **28 March 2012**, freezing the language and standard library with a famous *compatibility guarantee*: code written for Go 1 would keep compiling for the life of the Go 1 line.2012 · OCaml - OCaml 4.00 - GADTs
**OCaml 4.00** (July 2012) added **Generalised Algebraic Data Types (GADTs)** and first-class modules, sharply increasing the expressive power of the type system. The version-numbering scheme also switched to the now-familiar `4.xx`.2015 · Rust - Rust 1.0
**Rust 1.0** was released on **15 May 2015**, stabilizing the **ownership and borrow-checker** model: affine types enforcing memory and data-race safety at compile time with zero runtime cost.2015 · Python - async/await & type hints (3.5)
**Python 3.5** (13 September 2015) added native coroutines via `async def`/`await` (PEP 492) and the `typing` module for optional type hints (PEP 484), reshaping how large Python codebases are written and checked.2015 · Raku - 6.c "Christmas" release
On **Christmas Day, 25 December 2015**, the **6.c "Christmas"** release delivered the first official, versioned language specification with a conforming **Rakudo** implementation on **MoarVM**. This is the date Raku is generally said to have "appeared."2018 · Rust - Rust 2018 edition
The **2018 edition** (Rust 1.31, 6 December 2018) introduced the *edition* mechanism for opt-in, non-breaking language evolution, along with a cleaner module path system and non-lexical lifetimes (NLL) that made the borrow checker far more ergonomic.2019 · Go - Go modules become default
After years of `GOPATH` friction, **Go modules**, versioned dependency management with a minimal-version-selection algorithm, became the default in **Go 1.13 (3 September 2019)**, finally giving the ecosystem reproducible builds outside a single workspace.2019 · Raku - Perl 6 renamed Raku
In **October 2019**, Larry Wall approved renaming **Perl 6 to Raku**, ending years of brand confusion with its sister language. "Raku" nods to the **Rakudo** compiler and means roughly "comfort" or "ease" in Japanese; `use v6` stays valid.2019 · Rust - async/await stabilized
**Rust 1.39** (7 November 2019) stabilized `async`/`await` syntax, building zero-cost futures on the ownership model and unlocking high-performance asynchronous I/O ecosystems like Tokio.2020 · Python - Python 2 sunset
On **1 January 2020**, after 20 years, **Python 2.7 reached end of life**. By then Python 3.8 (Oct 2019) had brought the controversial walrus operator `:=`, and Guido van Rossum had stepped down as BDFL in favor of a Steering Council.2021 · Rust - Rust Foundation & 2021 edition
On **8 February 2021** the independent **Rust Foundation** was formed (with AWS, Google, Microsoft, Mozilla, and Huawei) to steward the language, followed by the **2021 edition** (Rust 1.56) in October. Rust has since become the first non-C language adopted into the Linux kernel.2021 · Haskell - GHC 9.0 brings Linear Types
GHC 9.0.1, released February 4, 2021, introduced the LinearTypes extension, letting the type system track that a value is used exactly once - useful for safe resource and memory management while staying pure and lazy. ```haskell {-# LANGUAGE LinearTypes #-} f :: a %1 -> (a, a) -- rejected: x used twice f x = (x, x) ```2022 · Go - Generics arrive (Go 1.18)
**Go 1.18** (15 March 2022) added **type parameters (generics)** with constraints and a `comparable` interface, the most significant language change since Go 1.0, and the most-requested feature for a decade.2022 · OCaml - OCaml 5.0 - multicore & effects
**OCaml 5.0.0** (16 December 2022) was a complete rewrite of the runtime: it removed the global GC lock for true **multicore parallelism** and introduced **effect handlers** via delimited continuations, enabling structured concurrency with no syntactic `async`/`await` coloring.2023 · Perl - Corinna object system (5.38)
A built-in, declarative object system, codenamed **Corinna**, landed experimentally in **Perl 5.38** (released **2 July 2023**) with `class`, `field`, `method`, and `ADJUST`, refined in **5.40 (June 2024)** with field accessor attributes like `:reader`. The stable line sits in the 5.40 / 5.42 range as of 2026.2026 · Guji - Guji is created
Work begins on Guji, an in-house compiled, statically-typed, functional-first language built for first-class text processing with regular expressions and PEG grammars. The first commit lays out the quest repository and the language specification that serves as the single source of truth. Bindings are immutable by default with sigils ($scalar, @list, %map), types are inferred, and match is exhaustive.2026 · Guji - Platform IO lands in Guji
Guji gains real platform IO. Programs can now read command-line arguments with args(), open files and the stdin handle, slurp a handle whole or stream its chomped lines as a channel, and report results through print to stdout and note to stderr. read_file and open return a Result, exit sets the process code, and the same surface works under both the reference interpreter and the native compiler. This replaces the earlier model where print was the only IO primitive.2026 · Guji - Guji v0.1-alpha is tagged
Guji reaches v0.1-alpha. It ships a reference tree-walking interpreter and a native ahead-of-time compiler that emits a real self-contained native binary, kept byte-identical by a differential test gate of 319 fixtures. The alpha includes generics over subs, classes, and enums, hatch-based concurrency with typed channels, Option and Result with ? propagation, and first-class regex and grammar support. Guji is no longer just a tree-walker, native codegen works.

Influence

Perl redesigned as RakuPerl informed the scripting style of PythonPerl lent text/regex pragmatism to GoPython inspired the readability ethos of GoPython contributed ideas to RakuOCaml shaped the type system of RustOCaml lent functional ideas to RakuOCaml modeled functional-first design for GujiRust informed single-binary compilation of GujiRaku inspired first-class grammars in GujiPerl shaped first-class regex of GujiGo modeled self-contained native output for GujiOCaml ML family, type inference HaskellHaskell type classes, ADTs, immutability Rust