Forget your toy languages, such as Python and JavaScript.
We’re grave robbing ten programming languages that have been dead for decades.
Like COBOL, which was born in 1960 when the US Department of Defense decided business software should all speak one language. The result? A committee-approved monstrosity designed to manage payroll, inventory, and crush the souls of programmers.
At a time when FORTRAN and ALGOL only had arrays, it introduced record data structures—the precursor to structs.
It died because academia hated it; it was massive and slow, and no one wanted to build on top of it.
Yet, COBOL still runs a shocking amount of global finance, insurance, and government systems. Your bank statement probably comes from a “dead” language older than your parents.
ALGOL, released in 1960, was supposed to be pseudocode you could actually run. And it invented half of modern programming: lexical scoping, structured programming, nested functions, formal specs, block comments—the works.
It’s the reason most modern languages look the way they do. C? Java? JavaScript? All ALGOL descendants.
It died because they forgot to include I/O. You couldn’t use it for… you know… anything practical.
Instead, people made “ALGOL-like” languages with actual features—like BCPL, which inspired C, which inspired everything else. ALGOL’s kids buried it alive.
APL came out in 1962 and looked like someone spilled a math textbook on your keyboard.
Seriously—you needed a special keyboard just to type it. But under the cryptic symbols was a revolutionary idea: array programming. No more looping through lists—just tell the computer to operate on the whole thing at once.
APL’s DNA runs through R, NumPy, pandas, MATLAB, and most of modern data science.
It died because of the keyboard, for one. Also, it only worked well with homogeneous data, so no fancy dataframes.
BASIC arrived in 1964 to make computers accessible to “non-engineers”, meaning kids, hobbyists, and small businesses.
One the 1970s microcomputers it was the language—you could cram a BASIC interpreter into just 2 KB of RAM.
BASIC gave us real-time interpreters and an entire generation of self-taught programmers. Eventually, it evolved into Visual Basic, the language behind countless Office macros.
It died, because people looked down on it as a “toy” language. Once cheap hardware could run C, BASIC was pushed aside.
In 1966, IBM tried to merge FORTRAN and COBOL into a single “super language” for both science and business. They created PL/I—the Swiss Army knife of the 60s.
It had structured types before C, pointers before C, constants, function overloading—you name it.
It died because everyone hated it for different reasons. FORTRAN people thought it was too COBOL-like, COBOL people thought it was too FORTRAN-like, and everyone else thought IBM was trying to lock them in.
SIMULA 67, born in Norway, started as a simulation language but became the first real object-oriented programming language—complete with classes, subclassing, virtual methods, and protected attributes.
It inspired C++, CLU, ML, and basically every OOP textbook ever written.
It died because it was painfully slow. Like, “hope you’re running on a mainframe” slow. People stole its ideas and reimplemented them in faster, more practical languages.
Niklaus Wirth created Pascal in 1970 as a clean, simple alternative to the overly complicated ALGOL-68. It became the teaching language of the 70s and 80s—structured, readable, and widely adopted in universities.
It died, because it just… slowly faded. C became cooler, Java took over academia, and Pascal became that nice guy you remember fondly but never call.
CLU, from 1975, was basically the hipster of programming languages—full of ideas no one appreciated until decades later: abstract data types, iterators, generics, checked exceptions.
It died because no one cared about its concepts at the time; therefore, CLU quietly slipped into history.
ML started in 1976 as the language for the LCF proof assistant. It introduced type inference, meaning you didn’t have to write out all your types—the compiler just knew.
It also championed typed functional programming, algebraic data types, and modularity.
It died, because it stayed niche. By the time Standard ML arrived, Haskell was stealing the functional programming spotlight. Its descendants live on in OCaml and F#.
Smalltalk evolved from 1972 to 1980 and was the first language to make everything an object.
It defined much of how we think about OOP and directly inspired modern IDEs and UI frameworks.
It died because of the “Javapocalypse.” In the 90s, Java stormed in with its C-like syntax, better C interop, and massive corporate backing.
But actually, none of these languages is truly gone. Their DNA is everywhere—in the languages you use today!
Top comments (0)