Dead programming languages

A dead programming language is one you can no longer use in earnest: its last implementation is unmaintained, the platform it ran on is gone, its vendor has abandoned it, or its community has dissolved. There is no registrar of deaths — software rarely dies cleanly, and many languages called "dead" continue to compile, ship, and pay salaries for decades after the obituary is written. But the distinction is real, and it matters to anyone who chooses a language, inherits old code, or wants to understand where the living ones came from.

Jean Sammet documented roughly 120 programming languages in her 1969 survey Programming Languages: History and Fundamentals, and the majority of them are already gone.^[1] Catalogs that attempt completeness today list thousands of designs; the languages an ordinary programmer can still name and use number in the dozens. Most programming languages ever designed are already dead — and the industry's working memory rarely holds more than a few dozen names at once.

This is the story of how they died, which ones the obituaries got wrong, and the handful that came back.

The causes of death

Programming languages die a limited number of ways, and the autopsy almost always names one of these:

• Extinction — no maintained implementation exists anywhere. You can read the manuals; you cannot run the code. MAD survived inside the Michigan Terminal System, and when the University of Michigan shut down its last MTS machine in June 1996, the language effectively died with it.
• Frozen — the implementation still ships but the language has stopped evolving. Microsoft's 2020 announcement was unusually blunt: "we do not plan to evolve Visual Basic as a language."^[2] VBScript was formally deprecated by Microsoft in October 2023, marked for removal from future Windows releases.^[3]
• Platform death — the language was healthy; the thing it ran on died. ActionScript was the web's second scripting language until Adobe ended Flash Player on December 31, 2020.^[4] NewtonScript died on February 27, 1998, the day Apple discontinued the Newton. occam died with the transputer, the CPU built to run it.
• Vendor abandonment — the vendor walked away while users were still productive. Visual FoxPro's extended support ended January 13, 2015.^[5] Borland's Kylix, Apple's Dylan, and Taligent's CommonPoint died the same way — as products, not as ideas.
• Supersession — a better or better-backed language took the niche. QUEL was arguably the better relational query language; IBM's backing made SQL the standard anyway. B existed only until it was rewritten as C. CPL was absorbed through BCPL into B and then C.^[6]
• Committee death — the language was killed in committee before or after release. ALGOL 68 was stillborn in the marketplace, torn apart by the famous minority report that dissented from its own standard.
• Ecosystem absorption — the language's ideas were copied into the survivor, and users moved on. CoffeeScript's features — arrow functions, classes, destructuring — were adopted wholesale into ES6, and the language quietly went dormant.^[7]

The death certificates

A handful of languages died on a documented day — a discontinued product, a shutdown announcement, an end-of-support date. This is the shortest and most verifiable table in the article:

The list is short because most deaths are undocumented. Languages rarely get an end-of-life notice; they get a last release, a quiet archive, and a generation that never learned the name.

The mechanics

Beneath the causes there is a deeper pattern — languages die because the thing that sustained them stops, and the sustaining things are almost never technical. A language is sustained by a sponsor (a vendor's balance sheet, a research lab's budget, a standards body's charter), a platform (the machine or OS it was built for), and a community (people who choose it when they don't have to). Remove one pillar and the others wobble; remove two and the language is dead within a decade.

Single-sponsor languages are the most fragile — one corporate strategy meeting can retire a million lines of working code. Platform-bound languages are next — occam had no way to survive the transputer. Languages with genuinely independent implementations die slowest: C and COBOL are implemented by a dozen vendors and a dozen compilers, which is part of why they are still here and most of their contemporaries are not.

Committees make elegant designs and bad products; dictators make shippable languages that die with the dictator. ALGOL 68 is the famous committee corpse — intellectually magnificent, commercially stillborn. Miranda shows the inverse: a single author produced a beautiful language, and the market picked the free committee version instead. There is no safe structure — only different ways to be fragile.

The inheritance pattern is the one saving grace: almost every dead language was digested rather than destroyed. The class from Simula, the iterator from CLU, the channel from CSP, the arrow function from CoffeeScript — the survivors ate the dead, which is why the industry barely notices how many languages it has buried.

The first dead

The earliest programming languages died young because almost everything about them was experimental. Short Code (1949) — arguably the first implemented high-level language — worked by expanding each symbolic statement into a call to a hand-coded subroutine; programs ran at a fraction of machine speed, and the language was obsolete within years. Grace Hopper's A-0 and A-2 "compilers" — subroutine linkers in modern terms, not translators — and her MATH-MATIC (AT-3, 1957) were milestones the industry stepped over on the way to FORTRAN and COBOL.^[10]

Hopper's FLOW-MATIC (B-0, 1957) died into COBOL: its English-like statement forms, its data-description structure, and several of its people went into the CODASYL committee that replaced it. The other commercial contenders of the late 1950s lost the same election — COMTRAN (IBM's business-language answer), FACT (Honeywell), and AIMACO (the Air Force Materiel Command's) were all superseded by the COBOL standard within a few years.

At Bell Labs, COMIT (1957) became the first string-processing language — Victor Yngve's tool for linguistics research — and was superseded within Bell Labs itself by SNOBOL, built by people who had used COMIT and knew exactly where it failed. IPL-V (1957), the Newell–Shaw–Simon list-processing language that ran the Logic Theorist and the General Problem Solver, was displaced by LISP 1.5 within five years.

JOSS — the JOHNNIAC Open Shop System at RAND, 1961 — deserves more than a footnote: it was the first language built around a conversational teletype session, the direct ancestor of every interactive prompt since. Its users experienced what everyone now takes for granted — type a statement, get an answer — on a machine the size of a room. MAD — the Michigan Algorithm Decoder, 1959 — was the other interactive pioneer: an ALGOL-58 relative built for teaching, ported to the Michigan Terminal System as GOM ("Good Old MAD"), and kept alive on university time-sharing systems for three decades. When the last MTS machine shut down in June 1996, MAD went with it — the longest-lived of the first generation, finally extinct.

The survival irony of the era is that the oldest major high-level language ever shipped is also the one that never died: FORTRAN is older than every corpse in this section and still being re-standardized — a reminder that "dead" is a claim about a language's continued life, not its age.

Then there is the strangest corpse of the era — the language that died before it was born. Konrad Zuse designed the Plankalkül between 1942 and 1945 — the first complete high-level language design anywhere, hidden in a wartime Bavarian village — and no implementation existed until the Free University of Berlin built one for a course in 2000, fifty-five years later.^[11] It was born dead and resurrected as an exhibit.

The languages that died unborn

Plankalkül is not the only design that never had a living implementation in its own era. CPL — the grand Cambridge–London collaboration of Barron, Strachey, and colleagues — was too large to implement fully; its workable subset escaped as BCPL, and even its name died (whether it stood for "Cambridge" or "Combined" depended on which of the two cities you asked).^[12] ALGOL X and ALGOL Y, the interim designs proposed while the committee argued over what became ALGOL 68, were abandoned in the argument. The Fifth Generation project produced entire families — KL1, GHC, Parlog, Strand88 — that died when ICOT's mandate ended in 1992, leaving behind nothing but papers and a cautionary tale about designing a national flagship in a committee room.

The ALGOL diaspora

ALGOL is the largest graveyard in the family plot. ALGOL 60 gave the world block structure and recursion and was gone from production use within twenty years — absorbed into Pascal, C, and the structured-programming mainstream it had invented. Its committee successor, ALGOL 68, produced computing's most famous schism: a minority report signed by Dijkstra, Hoare, and others dissenting from the standard they had helped write, followed by a language so orthogonal and so formally specified — van Wijngaarden two-level grammars — that working implementations took years. ALGOL 68-R at the Royal Radar Establishment ran in 1970; by then the industry had already chosen simpler tools. The language was intellectually magnificent and commercially stillborn.^[13]

JOVIAL — the Air Force's ALGOL dialect — outlasted almost all of them. Written by Jules Schwartz's team at SDC in 1959–60, it was adopted across radar, missile-warning, and air-traffic systems — SACCS, BMEWS, AWACS, the avionics of entire fighter fleets — and survived forty years before the DoD's migration to Ada and then to C finished it. NELIAC — the Navy's own ALGOL dialect from the Naval Electronics Laboratory — died earlier and quieter. Coral 66, RTL/2, and the services' other official dialects died the same institutional death when their ministries standardized on Ada.

Simula 67 died young but left the largest inheritance on this list — classes, objects, coroutines, the direct ancestors of object orientation in every mainstream language.^[14] Its two Norwegian authors, Kristen Nygaard and Ole-Johan Dahl, received the 2001 Turing Award for it — and then both died within weeks of each other in June and August 2002, a posthumous honor followed by a double funeral.

The collateral dead tell the same story from the other side. ALGOL W — Wirth and Hoare's rejected proposal, implemented anyway at Stanford in 1966 — was the ALGOL X that never became the standard, and its simplification, Euler (1965–66), died as a teaching vehicle; the same ideas, ruthlessly reduced, became Pascal. S-algol at St Andrews carried the ALGOL name into the eighties; PS-algol and Napier88 explored persistence before the idea found its home in mainstream object databases. The graveyard's population is mostly ALGOL's children — proof that a language can be everywhere and dead at the same time.

The strangest ALGOL descendant is the one that never quite died: Burroughs wrote its operating systems in an ALGOL dialect — ESPOL, then NEWP — and Unisys still sells ClearPath Forward MCP systems whose systems code descends from that 1960s ALGOL line. ALGOL is dead; its most specialized descendant is still being sold as a product.

CPL   (Cambridge + London, 1963)   never fully implemented
  |
  v
BCPL  (Richards, 1967)             the workable escape
  |
  v
B     (Thompson, Bell Labs, 1969)  types stripped for the PDP-7
  |
  v
C     (Ritchie, 1972)              types back in, PDP-11
  |
  +--> C++  (Stroustrup, 1983)     still alive
  +--> Objective-C (1984)          dying — absorbed by Swift

The wide-open seventies and eighties

The 1970s produced the largest crop of influential corpses — the era when every research university and industrial lab rolled its own. BCPL and B exist today only as waypoints on the road to C. BLISS was DEC's systems language and died with DEC's platforms. CLU (Liskov, 1974) was a research vehicle that gave the world abstract data types, parametric polymorphism, and iterators — the cluster, the coroutine-shaped generator, the exception — and was never meant to be a product.^[15]

Mesa and Cedar — Xerox PARC's modular systems languages — died when Xerox walked away from the workstation business; their ideas (modules, strong types, garbage collection as a systems feature) moved into the next generation anyway. Euclid was Toronto's verification language, designed so programs could carry proofs — a pure research vehicle that closed in a few years. Alphard did the same for data abstraction at CMU. SETL — Schwartz's very-high-level set-theoretic language at NYU — kept a small following into the eighties and then faded; its ideas surfaced later in ABC and Python. Lucid (Ashcroft & Wadge, 1976) and the dataflow family — Id, SISAL, pH — were built for machines that never shipped commercially, and died waiting for hardware that was always five years away.

occam deserves its own paragraph because it died the purest death in the catalog: INMOS designed it as the native language of the transputer — a CPU built around communicating sequential processes — and when SGS-Thomson discontinued the transputer line in the mid-1990s, occam had nowhere else to live. Almost no other language has ever been so literally welded to a chip.

Self is the seventies' successor story that nobody talks about. David Ungar and Randall Smith's prototype-based language — no classes, objects cloning objects — was Sun Labs' radical answer to inheritance. The language died commercially, but its adaptive JIT team spun out into Animorphic Systems, which Sun acquired — and that technology became Java's HotSpot. The most influential dead language in the world is running inside every Java VM.^[16]

Refal — the Soviet Union's distinctive entry — took a different route to obscurity: Valentin Turchin's supercompilation-based functional language never got a Western vendor, and although it has occasional revivals, it remains one of the deadest living languages on the books. The Fifth Generation's logic family — KL1, GHC, Parlog, Strand88 — died with ICOT's mandate in 1992.

Wirth's own middle period is a miniature of the whole story. After Pascal's explosion, Modula-2 added modules and concurrency — dormant until its 2013 resurrection into GCC — while Modula-3 (DEC SRC's more ambitious industrial successor) died with its sponsor. Oberon carried the line forward in Wirth's own lab and is still alive in the tiny "Project Oberon" world; the main line is a string of graves with a live flame at the end. The lesson is the one this whole article keeps making: the Wirth line's ideas are in every modern language — the language names are museum labels.

Miranda shows a subtler mechanism: David Turner's lazy functional language was proprietary, and Haskell — designed in 1987–90 precisely because the research community needed a free lazy language — made it unnecessary. Miranda still runs; its users moved on.^[17]

The vendor graveyard

The largest single collection of documented corpses belongs to Microsoft — a record that is at least honest. Visual Basic 6's IDE support ended in April 2008; in 2005 a petition of thousands of VB6 developers had already asked Microsoft to keep or open-source the language, and Microsoft declined — the 2020 "we do not plan to evolve Visual Basic" statement only formalized a death that had been announced a dozen years earlier. VBScript was deprecated in October 2023. Visual FoxPro support ended January 2015. JScript died with Internet Explorer 11 in 2022. J++ was abandoned after the 2001 Sun settlement — Microsoft's Java dialect died in a courtroom — and its replacement, J#, was itself dropped from Visual Studio 2008. A vendor can kill a language as surely as obsolescence can, and the paper trail is refreshingly legible.

The VB6 case deserves a footnote of its own, because it shows the community refusing the death sentence. When Microsoft announced it would not continue the classic Visual Basic line, thousands of working developers signed the "Petition to Microsoft" asking Redmond to keep or open-source VB6 — and the petition circulated for years. Microsoft did not budge, but it also did not kill the runtime: VB6-compiled programs are still officially supported under "It Just Works" compatibility. The language is dead; the programs are immortal. That asymmetry is the point of this section — the vendor's language is dead, but the vendor's runtime cannot be allowed to die.

Borland's arc is the vendor story in miniature. Turbo Pascal (1983) — Anders Hejlsberg's $49.95 compiler that broke the industry's pricing model — was itself a living product until Delphi absorbed it: the language kept evolving under a new name and is still sold today, making Turbo Pascal the rare corpse with a living heir. Kylix — the Linux version — was quietly let die around 2005. Delphi Prism (the later .NET attempt) died into RemObjects' Oxygene line. Same company, three different kinds of death.

Apple's graveyard is smaller but older: HyperTalk faded when HyperCard was withdrawn around 2004; NewtonScript ended when the Newton was cancelled in 1998; Dylan was killed before its commercial release in the mid-1990s — its descendant survives only as the open-source Open Dylan zombie. Adobe added ActionScript and Lingo (Director) to the pile.

Taligent — the Apple–IBM joint venture that was supposed to produce the operating system of the future — was folded back into IBM and dissolved in 1998; its CommonPoint frameworks and Pink/TalOS went with it. General Magic's Telescript — the mobile-agent language that tried to send programs, not data, across networks — died with the company in 2002. The bet was that programs would travel as agents; Java's applets made the same bet cheaper, and the market chose Java.

Killed by their platforms

The cruelest category: languages that did nothing wrong. occam is the purest example — it died when the transputer died. The Amiga took an entire ecology down with it: AREXX — the Rexx dialect wired into the OS as the standard inter-application port — Amiga E (Wouter van Oortmerssen's systems language), AMOS and STOS (the game-creation BASICs that shipped real commercial games), GFA-BASIC, and Blitz BASIC all died with the platform; the Amiga's 1994–96 collapse turned a generation of homebrew code into museum ware. On the 8-bit machines, MSX BASIC, Locomotive BASIC, and Sinclair BASIC live only in emulators — code you can run in a browser tab but never in production. TUTOR ended with the PLATO network — though its remnants still run at cyber1.org, which keeps a PLATO system alive for preservation. Multics's PL/I died when the last Multics site powered off in 2000. HolyC — Terry Davis’s language — is the category’s edge case: alive in community forks (ZealOS, Shrine), but bound forever to a platform that was itself one person’s artifact; when its author died in 2018 the platform became a fixed point rather than a moving one, which is a kind of death no vendor ever had to sign.

The teaching languages that were built to die

A quieter category: languages designed to be temporary. PL/0 — Wirth's 40-line compiler-in-a-diagram for teaching compiler construction — was never meant to be used, and wasn't. WATFIV and WATFOR — Waterloo's fast FORTRAN teaching compilers — taught a generation of students and were retired when the curriculum moved to Pascal. Pascal-S and UCSD Pascal's p-System were teaching vehicles that lasted exactly as long as their institutional niche. These languages are dead in the way a laboratory rat is dead — purposefully, at the end of the experiment, having done their job.

Absorbed, not buried

Some languages don't die so much as get eaten. ABC — CWI's teaching language — was consumed by its own implementer: Guido van Rossum had worked on ABC's implementation at CWI, watched its deployment and extensibility failings up close, and built Python explicitly as its successor.^[18] CoffeeScript was absorbed into ES6, which took its arrow functions, classes, and destructuring and left the language with nothing to do. QUEL lost the relational language war to SQL — POSTGRES's own POSTQUEL was later rewritten to SQL95, closing the loop.^[19] Microsoft's research dialects Cω, Spec#, and Polyphonic C# were absorbed into C# itself — LINQ and contracts are their fossils. Objective-C is mid-digestion: Apple still compiles it, but Swift owns the future. The strangest absorption in the cluster is ECMAScript 4 — the ambitious, ActionScript-3-derived rewrite of JavaScript that died in committee in 2008 and was replaced by the more conservative ES5 "Harmony" path; ActionScript 3's proposed future standard was buried with it. Perl 6 staged the strangest absorption of all — it renamed itself Raku in October 2019 and left the Perl name to Perl 5.^[20]

COMIT   (Bell Labs, 1957)   first string-processing language — dead
  |
  v
SNOBOL  (Griswold, 1962-67) pattern as first-class data — dormant
  |
  v
Icon    (Arizona, 1978)     goal-directed evaluation — alive, just
  |
  +--> escaped into: AWK, Perl, regular expressions everywhere
  +--> Python generators — cited by name in PEP 255

The zombie tier

A few languages are not dead and not alive — they run, they are maintained just enough to keep running, and nobody writes anything new in them. VBA is the classic: Microsoft froze the language decades ago, but it is embedded in every Office document on Earth and cannot be allowed to die. JCL is the same species — nobody calls it a programming language, and it has outlived almost all of them. Open Genera, the Symbolics Lisp-machine environment, survives as a product that runs on emulated Alpha hardware. These are the living dead — production-critical, developmentally extinct.

The recent dead

The graveyard keeps filling — just slower, and more quietly. Nemerle — JetBrains' C#-plus-metaprogramming research dialect — lost its sponsor around 2012 and exists now only as an archived repository. Ioke and Seph — Ola Bini's mid-2000s experimental languages — were designed, demonstrated, and dropped. Vala — GNOME's compiled C#-like language — lost its institutional backing as GNOME moved toward Rust. Arc — Paul Graham's 2008 Lisp — shipped twice, was famous for a weekend, and has been dormant since. Io, Fancy, Kitten — the experimental language boom of the 2000s produced dozens of corpses nobody has catalogued. The newest deaths are invisible because they never got a reputation to lose.

The false positives

The most instructive section of this article is the list of languages that everyone calls dead and that keep not dying:

• COBOL — the standard's latest revision is ISO/IEC 1989:2023; banks still run on it.^[21]
• FORTRAN — ISO/IEC 1539-1:2023; the HPC community's oldest workhorse is still standardized and still compiled.^[22]
• Ada — ISO/IEC 8652:2023 (Ada 2022); safety-critical systems still certify new Ada.^[23]
• RPG — IBM i's business language still ships new releases.
• APL — Dyalog's interpreter is a going commercial concern; J, K, and Q keep the notation's other branches alive.^[24]
• Forth — niche but maintained; Open Firmware still boots on it.^[25]
• Prolog — SWI-Prolog is actively maintained; the paradigm's flagship never died.^[26]
• Smalltalk — Pharo and Cincom keep the language's descendants current.^[27]
• MUMPS — alive as M on InterSystems IRIS and GT.M; Epic and the VA's VistA still run on it.
• SNOBOL and Icon — dormant, not dead: CSNOBOL4 is maintained and Icon 9.5.25a shipped in September 2025.
• Modula-2 — GNU Modula-2 was merged into GCC 13; Wirth's language re-entered the world's most-used compiler.^[28]
• Delphi — Turbo Pascal died, but its commercial descendant is a shipping product; Free Pascal keeps the open-source line too.^[29]
• PL/I — the "dead" ALGOL descendant that IBM still sells: Enterprise PL/I for z/OS is a shipping product.
• Maxima — the open-source Macsyma — is healthy enough to make lists like this one look foolish.
• TeX — frozen by design: Knuth froze the language itself while the ecosystem lives on; its version number converges to π.
• Perl — 5.x still releases regularly; reports of its death confuse decline with extinction.^[30]
• Common Lisp / Emacs Lisp — the Lisp family is the immortality ward: implementations like SBCL and GNU Emacs's eLisp engine ship features nobody calls alive and nobody can kill.^[31]

The oldest false positive of all: the ALGOL family supposedly died in the seventies — yet Unisys ClearPath Forward systems still ship today with an ALGOL-descended systems language (NEWP) in the box, and IBM still sells PL/I.

The deeper point is that decline is not death. Tcl is unfashionable but maintained; AWK and sed are so small they can never be worth killing; elisp is immovable inside GNU Emacs. A language can be culturally dead — nobody chooses it for new work — and commercially immortal at the same time, which is why "dead" has to mean something stricter than "out of fashion."

Necromancy

A handful of languages have been brought back. Interlisp — the Xerox/BBN Lisp environment — was resurrected by the Medley Interlisp Project, which got the original system running on modern hardware. Microsoft released the 1983 GW-BASIC sources under MIT in May 2020 — an explicit "historical reference" with no pull requests accepted, a fossil made freely inspectable.^[32] Clipper lives on as Harbour, the open-source xBase implementation; dBASE itself is still sold commercially by dBASE LLC.^[33] BBC BASIC was never allowed to die; R.T. Russell's ports keep it current.^[34] Poplog went open source in 1999 and still compiles. Open Genera — the Symbolics Lisp-machine environment — survived its own company, running under emulation long after Genera stopped being a commercial system.

The retrocomputing scene added a strangest kind of afterlife: the dead 8-bit BASICs — Sinclair, Locomotive, MSX — never got a revival at all, yet they are more runnable today than when they were products, in browser emulators on machines a million times faster than the hardware that hosted them. Extinct as products, immortal as artifacts.

Behind the scenes, the infrastructure of the undead is already built: SimH emulates the machines the dead languages ran on; the Computer History Museum and Software Heritage archive the sources so that a resurrection is at least possible. A language that cannot run can still be read — and sometimes, as Plankalkül proved, a language can be read for fifty-five years before it ever runs.

The inheritance

The dead are not gone; they are in the living. Almost every feature you use today was invented by a language that failed:

Counting the dead

How many is "most"? Sammet's 1969 survey described about 120 languages; by the late 1970s her roster listed over 170 — a generation's mortality in a decade. Community catalogs now count thousands of designs. The practical number is smaller and starker: the TIOBE index publishes a top-fifty list and a "next fifty" — a hundred names total — and the bottom half is statistically indistinguishable from noise.^[38] Something like 90–95% of the languages ever designed are, by any reasonable definition, dead.

There is one honest correction to make to the arithmetic, and it is the article's last lesson: languages die at the level of the implementation, not the family. LISP died — the specific language, McCarthy's 1960 M-expressions — but Lisp the family never did; it just kept shipping under new names: MacLisp, Zetalisp, Common Lisp, Scheme, Clojure, elisp. ALGOL died — but Algol-descended syntax is nearly all of the syntax there is. The deaths are real; they are just almost never total.

That is not a tragedy; it is the mechanism. Languages are cheap to design and expensive to sustain — every death left behind an idea the survivors could steal for free: the class from Simula, the iterator from CLU, the channel from CSP, the arrow function from CoffeeScript. The corpses are the R&D the living didn't have to pay for. A language can die; its DNA cannot.

And every language on this list once had believers — people who learned its syntax, shipped its code, bet a career or a company or a thesis on its survival. The lesson for anyone choosing a language today is not "pick a safe one" — it is "know what you are betting on": the sponsor's balance sheet, the platform's future, the community's depth, and whether the language's ideas are good enough to survive its own death. Most aren't worth stealing. The best of the dead have already been stolen — and they are running in everything you have written today.

Sources

• Jean E. Sammet, Programming Languages: History and Fundamentals (Prentice-Hall, 1969) — the foundational census; ~120 languages documented, most now dead.
• Knuth & Trabb Pardo, "The Early Development of Programming Languages," Stanford CS-TR-76-562 (1977) — the standard history of 1949–58: Short Code, MATH-MATIC, FLOW-MATIC, COMTRAN, IPL.
• Dennis M. Ritchie, "The Development of the C Language" — CPL → BCPL → B → C, the most consequential genealogy in the field.
• ACM HOPL papers — Simula (1978), CLU (1993), Haskell (2007), JavaScript: The First 20 Years (2020), Forth (2007).
• Microsoft lifecycle documentation — VB.NET freeze (2020), VBScript deprecation (October 2023), Visual FoxPro end-of-support (January 2015), Internet Explorer 11 retirement (June 2022).
• Adobe Flash Player end-of-life notice — December 31, 2020.
• University of Michigan, Michigan Terminal System history — MAD's host, shutdown June 30, 1996.
• multicians.org — Multics history; last site shut down October 30, 2000.
• ISO/IEC 1989:2023 (COBOL) · ISO/IEC 1539-1:2023 (FORTRAN) · ISO/IEC 8652:2023 (Ada) — the standards that refute the obituaries.
• Guido van Rossum, "The Making of Python," Artima interview (2003) — ABC's death into Python.
• Open Dylan · interlisp.org · harbour.github.io · dbase.com · bbcbasic.co.uk · cyber1.org — the resurrections and zombies.
• Software Heritage · Computer History Museum · SimH — the archives.

See also

• History of Programming — the long view this article sits inside
• SNOBOL and Icon · ALGOL · COBOL · FORTRAN · BASIC — the survivors
• C (programming language) · Ada Programming Language · LISP · Forth — languages that outlived their obituaries
• Plankalkul — the first designed language, never run in Zuse's lifetime
• Grace Hopper · Konrad Zuse — the people who wrote the first corpses
• Icon programming language · REBOL — niche survivors that refuse to die
• HolyC — the platform-dead edge case: alive in forks, bound to a frozen temple
• Vector Symbolic Architectures — the dataflow descendants