Section 03 — A History of Human Thought in Code

Through Time

From the punched cards of 1957 to the AI-native languages of 2023 — eight decades of humanity teaching machines to think. Each era reflects the hardware available, the problems being solved, and the ideas in the air.

1940s–50s 1960s 1970s 1980s 1990s 2000s 2010s 2020s
'40s
–'50s
1943 – 1959 ~12 languages born

The Dawn of High-Level Programming

The first computers filled entire rooms and were programmed in raw machine code — sequences of binary or hexadecimal numbers entered via switches or punched paper tape. Assembly language was a revolutionary abstraction: human-readable mnemonics for machine instructions.

The 1950s brought the first true high-level languages. Fortran (1957) proved that compiled code could match hand-optimized assembly — a heretical idea at the time. John McCarthy began work on Lisp, which would introduce recursion, garbage collection, and the lambda calculus to programming.

1957Fortran, first compiled HLL
1958Lisp, first functional language
1959COBOL, first business language
1943 PlankalkülKonrad Zuse The first high-level programming language ever designed — for the Z3 computer. Never implemented in Zuse's lifetime. Introduced assignment, subroutines, and iteration.
1947 AssemblyKathleen Booth Human-readable mnemonics for machine instructions. ARC assembly was one of the first. Still essential for OS kernels, bootloaders, and embedded firmware today.
1952 AutocodeAlick Glennie / Manchester One of the first compiled languages. Translated algebraic-style code to machine instructions — an early proof that compilers could work.
1957 Fortran HistoricJohn Backus / IBM Formula Translation — the first widely used high-level compiled language. Revolutionized science and engineering. Still runs weather models and nuclear simulations today.
1958 Lisp HistoricJohn McCarthy / MIT List Processing — invented garbage collection, recursion as a programming construct, and symbolic computation. The second-oldest high-level language still in use. Spawned Common Lisp, Scheme, Clojure, Racket, and Clojure.
1959 COBOLGrace Hopper, CODASYL Committee Common Business-Oriented Language. Readable English-like syntax for business data processing. Still processes an estimated $3 trillion in daily financial transactions worldwide.
1959 RPGIBM Report Program Generator. Designed for creating business reports on IBM mainframes. Still used extensively on IBM AS/400 (iSeries) systems in manufacturing and banking.
'60s
1960 – 1969 ~35 languages born

Structured Programming & the First Revolution

The 1960s saw an explosion of language experimentation. ALGOL 60 introduced block structure, lexical scoping, and the idea of a formal language specification — almost every language since descends from it. BASIC made programming accessible for the first time. SNOBOL pioneered pattern matching.

The decade ended with the famous "software crisis" — programs were becoming too complex to manage. This crisis would birth structured programming, software engineering, and a new generation of languages in the 1970s. Dijkstra declared "goto considered harmful."

1960 ALGOL 60 AncestorInternational Committee The ancestor of nearly all modern languages. Introduced block structure, lexical scoping, recursive procedures, and the BNF grammar specification. C, Pascal, Java, Python, and virtually every language since traces its lineage here.
1962 SNOBOLBell Labs String-Oriented Symbolic Language. Pioneer of pattern matching on strings, decades before regex became mainstream. Inspired by symbol manipulation needs in linguistics and AI.
1964 BASICKemeny & Kurtz / Dartmouth Beginner's All-Purpose Symbolic Instruction Code. Designed so non-science students could use computers. Launched the personal computing revolution — every home computer in the 1970s–80s shipped with BASIC.
1964 PL/IIBM Programming Language One. IBM's ambitious attempt to unify Fortran and COBOL into one universal language. Extremely rich feature set; influenced Ada, C, and PL/SQL.
1966 APL Paradigm ShiftKenneth Iverson / IBM A Programming Language. Used symbolic notation (∑, ⍋, ⍒) for array operations. Extraordinarily expressive — algorithms that take pages in other languages fit in one line. Pioneered the array paradigm and influenced MATLAB, NumPy, and J.
1966 MUMPSNeil Pappalardo / MGH Massachusetts General Hospital Utility Multi-Programming System. Hierarchical database-as-language hybrid. Still powers Electronic Health Record systems including the VA's VistA, used by millions.
1967 BCPLMartin Richards / Cambridge Basic Combined Programming Language. Typeless systems language that directly inspired B, which directly inspired C. The typelessness was deliberate — designed to write operating systems.
1967 Simula 67Nygaard & Dahl / Norway The world's first object-oriented language. Introduced classes, objects, inheritance, and subtyping to support simulation modeling. Alan Kay credited Simula as the primary inspiration for Smalltalk.
1967 LOGOPapert, Feurzeig, Solomon / BBN Educational language famous for "turtle graphics." Seymour Papert's constructionist learning philosophy in code. Introduced millions of children to programming through drawing.
1968 ALGOL 68Adriaan van Wijngaarden Radical redesign of ALGOL with orthogonal design principles and coercions. Extremely complex specification. Influenced C, Pascal, and Ada significantly.
1969 BKen Thompson / Bell Labs Simplified, typeless descendant of BCPL. Designed for the first UNIX system on the PDP-7. The direct predecessor of C — Dennis Ritchie added types and created C from B.
'70s
1970 – 1979 ~50 languages born

The Foundational Decade

The 1970s produced an extraordinary concentration of foundational ideas. C (1972) gave us portable systems programming. Pascal (1970) brought structured programming to education. Prolog (1972) invented logic programming. Smalltalk (1972) defined object-oriented programming. ML (1973) introduced Hindley-Milner type inference. SQL (1974) created relational data management.

This decade also brought Scheme (1975), which simplified and purified Lisp; Forth (1970), which pioneered the stack-based model; and the formalization of many ideas that still underpin programming language theory today.

1970 Pascal EducationNiklaus Wirth Designed to teach structured programming. Clean syntax, strong typing, and no goto. The dominant teaching language from the 1970s to 1990s. Delphi (Object Pascal) still used in enterprise apps.
1970 ForthCharles Moore Stack-based, interactive, and radically minimal. Invented by Moore aboard a research vessel. Runs in 4KB of RAM. Influenced PostScript, Factor, and WebAssembly's internal stack machine.
1972 C HistoricDennis Ritchie / Bell Labs Created to rewrite UNIX in a portable language. Combined low-level control with high-level structure. The most influential language in history — Linux, Windows, macOS, Python, Ruby, Perl, PHP all implemented in C.
1972 Smalltalk OOP OriginAlan Kay / Xerox PARC The purest expression of OOP. Everything is an object — including integers, classes, and the interpreter itself. Invented the IDE, the GUI, and refactoring tools. Alan Kay won the Turing Award for it.
1972 Prolog Logic OriginColmerauer & Roussel PROgramming in LOGic. Declare facts and rules; let unification find answers. The canonical logic programming language. Central to AI research in the 1980s and still used for NLP and constraint solving.
1973 ML Type TheoryRobin Milner / Edinburgh Meta Language — developed as the language of the LCF theorem prover. Invented Hindley-Milner type inference: the compiler infers types without annotations. Ancestor of OCaml, F#, Haskell, and Rust's type system.
1974 SQL HistoricChamberlin & Boyce / IBM Structured Query Language. Declarative relational data management. Fifty years later, nothing has displaced it. Every major database — PostgreSQL, MySQL, SQLite, Oracle, SQL Server — speaks SQL.
1975 SchemeSteele & Sussman / MIT Minimalist Lisp with proper tail calls, first-class continuations, and hygienic macros. Enormously influential in PL theory. The language behind SICP — the most famous CS textbook ever written.
1977 AWKAho, Weinberger, Kernighan Named after its three creators. Pattern scanning and text processing tool. One-liners replace pages of code for log analysis and data transformation. Still ubiquitous on Unix systems.
1978 Modula-2Niklaus Wirth Pascal's successor with modules, coroutines, and low-level access. Wirth's most complete language design. Influenced Ada and Oberon.
1979 REXXMike Cowlishaw / IBM Restructured Extended Executor. Human-readable scripting for IBM mainframes. Still used in z/OS. Influenced many subsequent scripting languages in its readable, English-like syntax.
'80s
1980 – 1989 ~120 languages born

The OOP Revolution & the Rise of Personal Computing

Home computers, C++, and the birth of the software industry. C++ (1985) brought OOP to systems programming. Objective-C (1984) would eventually run every Apple product. Ada (1980) formalized safety-critical programming for the U.S. Department of Defense. Erlang (1987) invented the actor model for telecom.

The decade also saw the Japanese Fifth Generation Project — a national bet on Prolog and logic programming that would transform AI. Haskell was being designed in committees. Miranda (1985) quietly laid the groundwork for pure functional programming.

1980 AdaJean Ichbiah / DoD Named for Ada Lovelace. Commissioned by the U.S. DoD for safety-critical embedded systems. Strong typing, concurrency via tasks, and design-by-contract. Still flies in aircraft, spacecraft, and trains.
1982 PostScriptAdobe Systems Stack-based page description language. Every laser printer manufactured since 1985 speaks PostScript. Enabled the desktop publishing revolution. Ancestor of PDF.
1983 C++ IndustryBjarne Stroustrup / Bell Labs "C with Classes," then templates, then the STL. The dominant systems language for decades. Powers game engines, databases, compilers, web browsers, and trading systems. A language of extraordinary power and complexity.
1983 VHDLU.S. DoD / IEEE VHSIC Hardware Description Language. Describes digital circuits for simulation and synthesis. Used worldwide for ASIC and FPGA design in defense, aerospace, and consumer electronics.
1984 MATLABCleve Moler Matrix Laboratory. Originally written in Fortran for teaching linear algebra. Now the dominant environment for engineering, signal processing, control systems, and academic research. Toolboxes for every field.
1984 Objective-CBrad Cox & Tom Love Smalltalk-style messaging on a C substrate. NeXT (Steve Jobs's company) adopted it as their primary language; when Apple acquired NeXT in 1997, Objective-C became the language of macOS and iOS for the next 30 years.
1985 MirandaDavid Turner / Kent First purely functional language with lazy evaluation and strong typing to achieve widespread use. Directly inspired the Haskell committee's work. Its influence on modern functional programming is immeasurable.
1985 EiffelBertrand Meyer Object-oriented language built on Design by Contract — preconditions, postconditions, and class invariants embedded in the language. Meyer's ideas on contracts influenced Java, C#, and Kotlin annotations.
1987 Erlang ConcurrencyJoe Armstrong / Ericsson Built for the telecom industry: massive concurrency, fault tolerance, hot code swapping, and distributed systems. The actor model and "let it crash" philosophy. Powers WhatsApp at 2 billion users. Nine nines uptime.
1987 PerlLarry Wall "Practical Extraction and Report Language." The duct tape of the internet — regex-native, flexible, and powerful for text processing. Ran the early web's CGI scripts and system administration tools.
1988 TclJohn Ousterhout / Berkeley Tool Command Language. Everything-is-a-string philosophy. Embeddable and extensible. Tk widget toolkit made GUI development accessible. Still powers many EDA tools and network device configuration.
1988 Wolfram LanguageStephen Wolfram The language of Mathematica. Symbolic computation as the core paradigm — everything is an expression that can be transformed by rules. Integrates mathematics, algorithms, data, and natural language.
1989 BashBrian Fox / GNU Project Bourne Again SHell. The default shell on Linux and macOS for 30+ years. Pipes, redirection, and scripting for system automation. Billions of shell scripts run worldwide daily.
'90s
1990 – 1999 ~200 languages born

The Internet Era & the Modern Mainstream

The decade that built the internet. Python (1991), Ruby (1995), Java (1995), JavaScript (1995), and PHP (1994) all emerged within a few years of each other — and still dominate programming today. Haskell (1990) gave the functional world its benchmark language.

The World Wide Web created new demands: languages needed to run in browsers, on servers, across heterogeneous networks. Java's "Write Once, Run Anywhere" JVM addressed portability. JavaScript (written in 10 days) would eventually conquer the browser entirely.

1990 Haskell Functional StandardFPCA Committee The benchmark pure functional language. Lazy evaluation, monads, typeclasses, and Hindley-Milner inference. Named for logician Haskell Curry. Pioneered ideas now in Rust, Scala, F#, Swift, and Kotlin.
1991 Python DominantGuido van Rossum Named after Monty Python. "Batteries included" philosophy. Readable, versatile, and beloved. Now the #1 language worldwide — dominant in AI/ML (PyTorch, TensorFlow), data science (Pandas, NumPy), web (Django, FastAPI), and education.
1991 Visual BasicAlan Cooper / Microsoft Brought Windows GUI development to millions of non-computer-science programmers. Event-driven, drag-and-drop forms. Enormously successful in enterprise and business automation through the 1990s–2000s.
1993 LuaIerusalimschy et al. / PUC-Rio Lightweight, embeddable, fast. Created in Brazil for configuring a petroleum engineering system. Now the scripting language of game engines (Roblox, LÖVE, World of Warcraft add-ons) and Neovim plugins.
1993 RRoss Ihaka & Robert Gentleman Open-source implementation of the S statistical language. The language of statisticians and data scientists. Rich ecosystem of packages (CRAN) for analysis, visualization (ggplot2), and machine learning.
1994 PHPRasmus Lerdorf "Personal Home Page" tools, later "PHP: Hypertext Preprocessor." Runs WordPress (40%+ of all websites), Facebook (originally), and hundreds of millions of web applications. The web's most-deployed server language.
1994 RacketPLT Inc. A Scheme designed as a "language laboratory." Its #lang directive lets you define entire new languages. Used heavily in PL research and the famous How to Design Programs curriculum.
1995 Java EnterpriseJames Gosling / Sun Write Once, Run Anywhere via the JVM. "Oak" → "Java." Dominated enterprise software for two decades. Powers Android, Spring, Hadoop, Kafka, and millions of enterprise backends. 3+ billion devices.
1995 JavaScript Web StandardBrendan Eich / Netscape Created in 10 days, originally called "Mocha." The only language natively supported by every browser. Has transcended the browser entirely: Node.js (servers), Electron (desktop), React Native (mobile). Inescapable.
1995 RubyYukihiro "Matz" Matsumoto "A language that makes programmers happy." Pure OOP, expressive syntax, and powerful metaprogramming. Ruby on Rails (2004) transformed web development and inspired countless frameworks in other languages.
1996 OCamlXavier Leroy / INRIA Objective Caml. Fast functional language with ML's type system plus OOP. Used at Jane Street (trading), Facebook (Hack compiler), and as the basis for Reason and F*. Famous for producing correct, performant code.
'00s
2000 – 2009 ~300 languages born

JVM Diversity, .NET, and Scripting's Golden Age

The 2000s saw established platforms — the JVM and .NET CLR — spawn new languages. C# (2000) gave Microsoft a modern OOP flagship. Scala (2004) and Groovy (2003) extended the JVM. F# (2005) brought functional programming to .NET.

Scripting languages exploded with the web boom. Clojure (2007) revived Lisp on the JVM. Go (2009) was Google's answer to C++ complexity at scale. The decade ended with a growing sense that the mainstream languages needed fundamental rethinking.

2000 C# MicrosoftAnders Hejlsberg / Microsoft Microsoft's response to Java. Clean OOP design with LINQ, async/await, pattern matching, and records. Powers .NET, ASP.NET, WinForms, WPF, and Unity game engine. One of the most complete mainstream languages.
2001 DWalter Bright / Digital Mars Systems language aiming to be a better C++. Garbage collection (optional), ranges, native strings, and design by contract built in. Hosts the influential DConf and has influenced many later languages.
2003 GroovyJames Strachan Dynamic scripting on the JVM. Full Java interoperability. Powers the Gradle build tool (used by Android Studio and millions of Java/Kotlin projects) and the Grails web framework.
2004 ScalaMartin Odersky / EPFL Scalable Language. Fuses object-oriented and functional programming on the JVM. Case classes, pattern matching, immutable collections. Powers Apache Spark, Kafka's tooling, and Twitter/LinkedIn backends.
2005 F#Don Syme / Microsoft Research Functional-first on .NET. Succinct, expressive, with type providers for data access and computation expressions for DSLs. Pioneered async workflows that influenced C#'s async/await. Used heavily in quantitative finance.
2007 Clojure Lisp RevivalRich Hickey A pragmatic, dynamically typed Lisp for the JVM. Persistent immutable data structures, software transactional memory (STM), and full Java interop. Hickey's talks on simplicity, complexity, and state are legendary in the field.
2009 Go Cloud EraPike, Thompson, Griesemer / Google Compiled, garbage-collected, and concurrent. Goroutines and channels for lightweight concurrency. Radical simplicity — no generics until 2022, few features. Now dominates cloud infrastructure: Docker, Kubernetes, Terraform all written in Go.
'10s
2010 – 2019 ~400 languages born

Safety, Types, and the Modern Systems Renaissance

The 2010s were defined by a search for safer, more expressive languages. Rust (2010) solved memory safety without garbage collection. Swift (2014) replaced Objective-C for Apple platforms. Kotlin (2011) became Android's preferred language. TypeScript (2012) brought types to JavaScript.

Functional programming went mainstream: Elixir (2012), Elm (2012), Julia (2012), and PureScript (2013) all appeared. The decade also saw blockchain languages (Solidity, 2014) and quantum computing languages (Q#, 2017).

2010 Rust Safety RevolutionGraydon Hoare / Mozilla Ownership and borrowing eliminate memory bugs at compile time — no garbage collector, no runtime. Six years running as the "most loved language" on Stack Overflow surveys. Entering the Linux kernel, Windows, and safety-critical domains.
2011 KotlinJetBrains Concise, safe, and expressive on the JVM. Null safety baked in. Google officially endorsed for Android in 2017. Also compiles to JavaScript and native code. Coroutines for structured concurrency.
2012 ElixirJosé Valim Functional, concurrent, built on the battle-tested Erlang VM. Phoenix web framework handles millions of WebSocket connections on a single server. The Discord backend serves 500M users on Elixir/Erlang.
2012 JuliaBezanson, Edelman, Karpinski, Shah / MIT Solves the "two-language problem" — prototype in Python, rewrite in C for speed. Julia is both. JIT-compiled with multiple dispatch. Dominant in numerical computing, differential equations, and scientific machine learning.
2012 TypeScript Web StandardAnders Hejlsberg / Microsoft JavaScript with an optional, gradual type system. Now the default choice for large-scale frontend (React, Angular, Vue) and backend (Node.js) projects. Hejlsberg also designed C# and Turbo Pascal — arguably the most influential language designer alive.
2014 SwiftChris Lattner / Apple Designed in secret at Apple to replace Objective-C. Safe, fast, and modern. Optionals instead of nil crashes, value types, protocol-oriented programming. Open-sourced in 2015; now also used on Linux servers.
2014 SolidityGavin Wood / Ethereum Contract-oriented language for the Ethereum Virtual Machine. Billions of dollars in DeFi protocols run on Solidity smart contracts. Statically typed with C++/JavaScript-influenced syntax.
2016 ZigAndrew Kelley Replacing C as the low-level foundation language. No hidden control flow, no hidden allocations. comptime metaprogramming. Cross-compilation as a first-class feature. The Zig toolchain can also build C and C++ projects.
2017 Q# (Microsoft)Krysta Svore / Microsoft Quantum-specific language targeting qubits and quantum gates. Integrates with the Azure Quantum platform. Designed for hybrid classical-quantum algorithms.
2017 WebAssemblyW3C / Browser Vendors A binary instruction format and stack-machine VM for the web. Lets C, C++, Rust, Go, and others run at near-native speed in browsers. The target compilation format for the web's future.
'20s
2020 – present ~150+ languages (ongoing)

AI-Native Languages & the Next Generation

The 2020s are defined by AI and machine learning reshaping what languages need to do. New languages are designed with hardware-awareness, tensor operations, and ML kernels as first-class concerns. Mojo (2023) aims to make Python 35,000× faster for AI workloads.

Google is developing Carbon as a C++ successor. Epic Games and Simon Peyton Jones created Verse for the metaverse. Vale and Roc explore new memory management models. The search for the perfect language continues.

2020 ValeEvan Ovadia Explores "generational references" — a new memory management approach that avoids both GC overhead and borrow-checker complexity. Fast, safe, and deterministic without Rust's learning curve.
2021 RocRichard Feldman Fast, friendly, purely functional language. Aims to be faster than Python, simpler than Haskell, and more practical than Elm. Platforms (not runtimes) define how Roc programs interact with the world.
2022 CarbonGoogle An experimental C++ successor exploring bidirectional interoperability. Designed to solve C++'s accumulated complexity while preserving its ecosystem. Still experimental but backed by Google's infrastructure team.
2022 UiuaKai Schmidt Array programming language with a unique stack-based evaluation model. Uses glyphs for operations; designed for terse, powerful data transformation. A modern evolution of the APL tradition.
2023 Mojo AI EraChris Lattner / Modular A superset of Python for AI systems programming. MLIR-based compilation, first-class SIMD and GPU targeting, ownership semantics. Claims 35,000× speedup over Python for AI kernels. Could unify AI research and production deployment.
2023 VerseEpic Games / Simon Peyton Jones Functional language designed for the Fortnite metaverse and UEFN (Unreal Editor for Fortnite). Designed by Haskell's lead designer. Brings rigorous functional programming to game scripting at unprecedented scale.
2024+ The FutureOngoing New languages targeting AI accelerators, quantum systems, distributed ledgers, and novel hardware architectures continue to emerge. The number of languages will continue to grow — the question is which ideas will endure.