Every Programming Language You Know Has Grandparents — Here's the Complete Family Tree

Key Takeaways

• •Four root languages: FORTRAN (1957), LISP (1958), COBOL (1959), ALGOL (1960)
• •C syntax (curly braces, semicolons) is used by C++, Java, C#, JavaScript, Go, Rust, and Swift
• •LISP's ideas — garbage collection, closures, recursion — took 40 years to become mainstream
• •Python (Coding), JavaScript (Web), Java (Enterprise), C (Systems) — the four pillars of modern programming

Source: Major languages per decade

Timeline

Every programming language has parents. And grandparents. And if you trace the family tree far enough back, you always end up at the same four ancestors.

The story of programming languages is the story of ideas being stolen, remixed, and reinvented across decades. No language is truly original. Every one borrows from the ones that came before. Understanding these connections helps you see why languages are the way they are — and why their quirks are actually fossils from 60 years ago.

The four root languages — the ones that introduced truly original ideas — all appeared within four years of each other.

There are only about four truly original ideas in programming language design. Everything since 1960 has been recombining those ideas in new ways.

FORTRAN (1957) was the first high-level programming language. Created at IBM by John Backus, it proved that computers could translate human-readable code into machine instructions without significant performance loss. Before FORTRAN, all programming was done in assembly language or machine code. FORTRAN's idea — that programming should be about math, not hardware — spawned the entire field.

LISP (1958) was created by John McCarthy at MIT. It introduced ideas so radical that the mainstream wouldn't adopt them for 40 years: garbage collection (automatic memory management), first-class functions (functions as values), recursion (functions calling themselves), and the concept that code and data could be the same thing. Every functional programming language — Haskell, Clojure, Erlang, F#, Elixir — descends from LISP. JavaScript's closures are LISP's closures.

COBOL (1959) was designed by a committee led by Grace Hopper, the legendary Navy rear admiral who believed programming languages should look like English. COBOL was verbose and bureaucratic — and it worked perfectly for business logic. Banks, insurance companies, and governments adopted it instantly. As of 2026, COBOL still processes an estimated $3 trillion in daily transactions.

ALGOL 60 is the most influential language almost no one has used. Its syntax — if/else, for loops, block scope — is in every language you write today.

ALGOL 60 (1960) is the most influential language you've probably never heard of. Created by an international committee, ALGOL introduced structured programming: if/else statements, for loops, block scope, nested functions, and the formal grammar notation (BNF) used to define every language since. ALGOL's syntax DNA flows through Pascal, C, C++, Java, C#, JavaScript, Python, Go, Rust, and Swift.

From these four roots, the family tree branches:

The C branch: BCPL (1966) → B (1969) → C (1972) → C++ (1979) → Objective-C (1984). C's curly-brace syntax became the default for systems programming and later spread everywhere.

The Java branch: C++ inspired Java (1995), which inspired C# (2000) and Kotlin (2011). Java cleaned up C++'s complexity and ran everywhere via the JVM.

The scripting branch: Perl (1987) → PHP (1995) → Ruby (1995). Python (1991) evolved independently from ABC. JavaScript (1995) borrowed from Scheme, Self, and Java simultaneously.

The functional branch: LISP → Scheme (1975) → ML (1973) → Haskell (1990) → Scala (2004). These languages prioritized mathematical purity and immutability.

The modern systems branch: C → Rust (2015) and Go (2009). Both attempt to solve C's problems — Rust focuses on memory safety, Go focuses on simplicity and concurrency.

The mobile branch: C → Objective-C → Swift (2014). Java → Kotlin (2011). These power the apps on your phone.

Some languages defy easy categorization. TypeScript (2012) is JavaScript with types — fixing a 10-day-old design decision. Zig (2016) is trying to be what C should have been. Mojo (2023) wants to be Python-speed-of-C for AI.

The pattern is always the same: a language appears, succeeds, reveals its limitations, and a new language appears to fix those limitations — while introducing new ones of its own. C fixed assembly's portability problem. C++ fixed C's lack of abstraction. Java fixed C++'s complexity. Rust fixed C's memory safety. Each generation stands on the last.

In 2026, the landscape looks like this: Python dominates AI and education. JavaScript dominates the web. Java dominates enterprise. C dominates embedded systems. TypeScript is replacing JavaScript in large projects. Rust is replacing C in security-critical code. Go is the default for cloud infrastructure.

But all of them — every single one — trace back to those four languages from the late 1950s. FORTRAN's computation. LISP's abstraction. COBOL's business logic. ALGOL's structure.

The roots run deep. They always do.

How did this make you feel?

Recommended Gear

Keep Reading

Coding

Python Is Named After a Comedy Show, Not a Snake — and It Was Designed to Be Boring

6 min read

Coding

JavaScript Was Created in 10 Days — and Now It Runs the Entire Internet

6 min read

Coding

'Hello, World' — The Two-Word Tradition That Every Programmer Follows but Nobody Remembers Why

3 min read