Programming Language Ideas That Did Not Win — And Which Ones Get a Second Chance When Agents Write the Code

Framing: what “did not win” actually means

“Did not win” is not the same as “was wrong.” Almost every language in this dossier shipped, compiled real programs, and in several cases ran production systems for decades. What they failed to do was propagate their central idea into the languages that most engineers are paid to write. The failure modes cluster into four distinct kinds of cost, and the distinction matters enormously for the question this dossier is actually about.

The first is annotation cost — the human labor of writing down something the machine could in principle check but cannot infer: a precondition, a loop invariant, a mode declaration, a region name, a uniqueness attribute. Eiffel’s require/ensure (Meyer, Applying “Design by Contract”), Dafny’s invariant/decreases/modifies (Dafny overview), Mercury’s is det/is semidet (Mercury reference manual), and Cyclone’s int * r region-qualified pointers (Hicks et al., Safe and Flexible Memory Management in Cyclone) are all annotation costs. This is the category most obviously disrupted by machine authorship: a cost measured in keystrokes and attention that a human grudgingly pays and an agent pays trivially.

The second is proof cost — not writing the spec but discharging it, including the part where the solver times out and a human must restructure the program or supply a lemma. Agda’s Foetus termination checker refusing a legitimate function, Dafny’s verifier losing information about a mutated array across a loop boundary, ATS requiring “administrative” linear-proof code (Introduction to Programming in ATS) — these are costs of the decision procedure, not of typing. Agents shrink this cost materially (they can iterate against a verifier far faster than a human) but they cannot abolish undecidability. Mercury’s own manual concedes that “perfect determinism inference is an undecidable problem” (Mercury determinism); no amount of inference compute changes that.

The third is runtime and interop cost — garbage collection you cannot afford, a VM you cannot deploy, a foreign function interface that does not exist, a calling convention that fights C. Alef was dropped from Plan 9 partly because it “lacked automatic memory management” and partly because maintaining a language across architectures proved “too difficult to maintain” (Alef). Mercury’s motivation page explicitly identifies performance as the reason designers “do not even consider logic programming languages” (Mercury motivation). These costs are physics and engineering economics. Agent authorship does not touch them at all.

The fourth is cultural and institutional cost — hiring pools, manager risk aversion, single-vendor dependency, marketing spend, library chicken-and-egg. Eiffel’s own advocates named this directly: Eric Bezault cited the “lack of a heavy marketing campaign” against Sun’s push for Java, a “relative lack of class libraries” creating a “chicken-and-egg dilemma,” and managers who feared blame because “you can’t get fired for using C++ (or Java, for that matter)” (Jackson, Eiffel: The Language That OOP Forgot?). Agent authorship partially dissolves the hiring-pool and library-scarcity components — a fluent-in-everything author does not have a hiring pool, and library synthesis is cheaper than library adoption — while leaving procurement conservatism, security review, and platform lock-in fully intact.

Read each entry as a three-part judgment against that taxonomy. The idea section describes the mechanism concretely enough to implement. The why it lost section identifies which of the four costs dominated, with sources. The agent-era reassessment asks whether that dominant cost is one machines pay cheaply. The honest answer is frequently no: ideas that failed on annotation cost are the ones most likely to get a second life, ideas that failed on runtime or deployment cost are not, and ideas that failed because the reading experience is bad may actually get worse, because agent-written code is read by humans far more than it is written by them.


Contracts, Design by Contract, and Refinement Types

This cluster shares one mechanism — an executable or solver-checkable logical predicate attached to a program point — and one failure mode: humans were asked to write specifications twice (once as code, once as logic) for a payoff that was invisible until something broke. Meyer observed that “dozens — probably hundreds — of DbC extensions” have been proposed for major languages and “almost none has gained wide acceptance,” naming SPARK and JML as the mission-critical exceptions (Meyer, Right and wrong: ten choices in language design). This is the cluster where the agent-authoring argument is strongest, because the dominant cost was almost purely annotation labor.

Eiffel (1985) — Design by Contract

The idea. Eiffel was designed on 23 September 1985 by Bertrand Meyer as an internal tool at Interactive Software Engineering in Santa Barbara; the first internal implementation was ready in mid-1986 and the compiler was sold commercially from December 1986 (Meyer, A brief history of Eiffel). Its central mechanism is a routine wrapped in logical obligations: require introduces a precondition the caller must satisfy, ensure a postcondition the routine guarantees, with old usable only in postconditions to denote an expression’s value at call entry, and semicolon-separated clauses acting as conjunction while remaining individually identifiable for error reporting (Meyer, Applying “Design by Contract”). The blame assignment is the point: a precondition violation is a bug in the client (“the caller did not observe the conditions imposed on correct calls”), a postcondition violation a bug in the supplier (“the routine failed to deliver on its promises”). Class invariants extend this to object state, and the inheritance discipline treats redefinition as subcontracting — a descendant may weaken preconditions and strengthen postconditions but not the reverse. Meyer credits Simula 67, Abrial’s Z, abstract data type work by Liskov, Zilles and Guttag, and the Floyd–Hoare–Dijkstra proof tradition as inputs, while claiming the assertion-plus-inheritance combination as original to Eiffel (A brief history of Eiffel).

Why it did not win. Eiffel’s practitioners diagnosed this in detail, and technical merit was not on the list. Marketing asymmetry: Bezault cited the “lack of a heavy marketing campaign” against a Java “pushed heavily by Sun Microsystems.” Library scarcity: a “relative lack of class libraries” created a “chicken-and-egg dilemma” where developers avoided Eiffel for lack of libraries and libraries grew slowly for lack of developers. Procurement politics: managers were “harder to convince” than engineers because language choice was “a political decision,” and the downside was asymmetric — nobody gets fired for choosing C++ (Jackson). Pricing and vendor concentration compounded it: EiffelStudio’s full version was listed at $4,799 per copy, with the free non-commercial build stripped of diagramming, documentation export, and compilation metrics. Meyer himself argues the deeper obstacle is that contracts must be “tightly integrated with the fabric of the language and the development environment (IDE),” which is why bolted-on DbC extensions failed, and that mainstream OO teaching actively installs contradictory preconceptions — “you should use defensive programming,” “you should make fields private and write getter functions” — that must first be un-taught (Ten choices).

Does the reason still apply? Mostly not, for the parts that mattered. The annotation burden — the felt sense that writing ensure new.parent = Current is extra work with no visible payoff — is the cost an agent pays at near-zero marginal effort, and contracts are unusually well suited to machine authorship because they are local, checkable, and self-documenting: a postcondition is precisely the artifact a reviewer needs to audit generated code without reading the body. Meyer’s “un-teaching” problem also inverts: an agent has no defensive-programming habit to unlearn. The library chicken-and-egg weakens too, since synthesis substitutes for adoption. What does not change: the single-vendor and commercial-tooling story is dead weight regardless of who types, contract inheritance discipline still constrains how hierarchies may be designed rather than merely annotated, and runtime assertion checking still costs cycles in hot paths — a decision no authoring change makes for you.

SPARK Ada (1987) — Provable Subsetting with Flow and Dependency Contracts

The idea. SPARK is a subset of Ada plus a toolset, developed since 1987 through PVL, Praxis, and Altran UK, with the modern generation (SPARK 2014) built on Ada 2012 aspects and driven by AdaCore’s GNATprove (AdaCore/Thales, Practical Formal Verification for Reliable Software). The design goal was explicitly “the largest possible subset of Ada that was still amenable to simple specification and sound verification” (SPARK overview). Specifications are Ada aspects: Pre => X < Integer'Last, Post => X = X'Old + 1, plus two SPARK-specific aspects that most contract systems lack — Global => null asserting the subprogram touches no global state, and Depends => (X => X) asserting an information-flow dependency, which the docs note is “especially interesting for security.” Enforcement rests on language restrictions, not just proof: expressions may not update objects, functions with out/in out parameters are forbidden, aliasing between out parameters and modified globals is checked “on every call,” and access-type assignment transfers ownership so “the source object loses its permission to read or write the underlying allocated memory.” Analysis runs in two tiers, fast flow analysis and full proof, and SPARK_Mode scopes which units are subject to the rules. Crucially, contracts are executable, so testing and proof “use the exact same semantics for contracts,” enabling hybrid verification where proven SPARK and tested Ada coexist in one file (AdaCore/Thales).

Why it did not win. SPARK did not fail so much as stay confined to the domains that mandate it. The AdaCore/Thales adoption paper concedes formal verification “may be intimidating for companies without formal verification expertise,” which is why the toolset is packaged as five graduated assurance levels — Stone (valid SPARK), Bronze (data flow), Silver (absence of run-time errors), Gold (key properties), Platinum (full functional correctness) — precisely so that adopters need not commit to full proof to get value. The tooling roadmap reads as a list of historical pain points: generation of implicit specifications, automatic generation of loop invariants, counterexample generation when proof fails, all aimed at reducing “the cost of writing specifications” and “the time required to prove code respects its contracts” (AdaCore/Thales). Add the Ada substrate: the hiring pool, the aerospace/defense association, and the deliberate absence of features the rest of the industry treats as table stakes.

Does the reason still apply? This is the most directly transferable design in the dossier, because SPARK already solved the hardest non-annotation problem — it made the specification language the same language as the program, executable and testable, so an agent-written contract degrades gracefully into a runtime check when the prover stalls. The intimidation barrier and the loop-invariant tax are annotation-and-iteration costs, exactly what an agent absorbs; the graduated Stone-through-Platinum ladder is a natural fit for an agent instructed to “get this module to Silver.” What does not change: SPARK’s guarantees come from excluding language features, so an agent still cannot use closures, arbitrary aliasing, or exception-heavy designs inside SPARK_Mode, and the Depends information-flow discipline constrains architecture, not just syntax. Nor does it help with the deeper reason most shops never consider SPARK — they are not building avionics and will not adopt an Ada toolchain.

D (2001) — Contracts as a Mainstream Systems-Language Feature

The idea. D was created by Walter Bright at Digital Mars, with design starting in late 1999 and the first DMD prototype released on 8 December 2001; Bright worked essentially alone on definition and implementation from 1999 to 2006, Andrei Alexandrescu joined in 2006, and D 1.0 shipped on 2 January 2007 (Bright, Alexandrescu & Parker, Origins of the D Programming Language). D’s contract programming folds Eiffel’s idea into a C-family systems language: in and out blocks on functions, assert expressions, and struct/class invariant blocks, with the language spec arguing that built-in contracts (rather than a library) deliver “a consistent look and feel,” tool support, better code generation “using information gathered from the contracts,” easier enforcement, and — the hard part — “handling of contract inheritance” (D language spec, Contracts). Violation semantics are deliberately brutal: if a contract is false “the program is assumed to have entered an undefined state.” D’s broader bet was C compatibility as a migration path — C headers translated into D modules, C ABI compatibility so both compilers’ output links into one executable, and a goal that equivalent syntax carry equivalent semantics or fail at compile time (D HOPL).

Why it did not win. D is the control experiment: it put contracts in a pragmatic, C-interoperable, imperative language with none of Eiffel’s academic or pricing baggage, and contracts still did not spread from it to the mainstream. D’s own historians identify its adoption obstacles as garbage-collection criticism, the D1/D2 incompatibility, and the split between the incompatible Phobos and Tango standard libraries, with D1 deprecated and discontinued in 2012 (D HOPL). Governance was late and thin — the nonprofit D Language Foundation was only created in 2015 — while the language competed for the same niche as C++ with a fraction of the ecosystem. The lesson for contracts specifically is that feature availability is not the binding constraint: D programmers had in/out/invariant for two decades and used them sparingly.

Does the reason still apply? The D case is the strongest argument against naive optimism about the agent era. If contracts went unwritten even where they were free, syntactically pleasant, and built into a C-family language, then the barrier was never notation — it was that a human author gains nothing observable at the moment of writing. That specific asymmetry does flip: an agent’s marginal cost of emitting an in/out block is negligible, and the contract’s value accrues to the human reviewer who must trust code they did not write. So D’s contracts may finally get used, not because D revives, but because the pattern gets ported into whatever the agent is writing. What does not change: D’s actual killers — GC in a systems language, library schism, ecosystem mass — are runtime and network-effect costs that authorship changes not at all.

Cobra (2006) — Contracts, Tests, and Nil-Tracking in One Ergonomic Package

The idea. Cobra was designed by Charles Esterbrook, first appearing in 2006 and released under the MIT License on 29 February 2008 under Cobra Language LLC, targeting .NET and Mono; the final release was 0.9.6 on 23 December 2013 (Cobra). Its thesis was ergonomic rather than theoretical: take Python’s indentation-based readability and mix in C# static typing, then bundle the whole quality-control toolkit into the language itself — contracts, assertions, unit tests written inline, docstrings, and compile-time nil-tracking. Cobra is explicitly described as “strongly influenced by Python, C#, Eiffel, Objective-C.” Static and dynamic typing coexist with compile-time type inference, and the tooling shipped as compiler flags (cobra -doc, cobra -highlight) rather than separate products. The bet was that verification-adjacent features fail not because they are hard but because they are inconvenient — so put tests next to the method they test and contracts in the signature, and adoption follows.

Why it did not win. Cobra is a case study in single-maintainer risk and platform timing rather than in any intellectual deficiency; the available record documents the arc — 2006 appearance, 2008 open-sourcing, last release 2013, status discontinued (Cobra) — without a designer’s post-mortem. Structurally, it chose the .NET/Mono runtime at a moment when that platform’s cross-platform story was still Mono-shaped, competed directly with C# (which absorbed type inference, and got Code Contracts as a Microsoft research library), and offered a syntax that asked Python developers to accept static typing and C# developers to accept significant-whitespace — a double switching cost for a language with one maintainer, no corporate sponsor, and a small library surface. The claim that it “failed for lack of a killer app” is commonly said but not verified in this pass.

Does the reason still apply? Cobra’s bundling insight is the durable part and it reads as prescient: an agent-authored codebase wants contracts, inline tests, and nil-tracking generated together as one artifact, because they are mutually reinforcing evidence for a reviewer, and agents have no incentive to skip the tedious two-thirds. Inline unit tests in particular are near-ideal agent output — local, cheap to generate, immediately executable as a self-check. What does not change: single-maintainer languages remain a governance risk no matter who writes the code, and ecosystem mass on a competing runtime is not something synthesis fixes quickly. Cobra’s ideas will likely be reborn as conventions and linters inside mainstream languages rather than as a language.

Whiley (2010) — A Verifying Compiler Built Around Flow Typing

The idea. The Whiley project began in 2009 as a response to Tony Hoare’s 2003 “Verifying Compiler Grand Challenge,” with the first public release in June 2010, developed mainly by David J. Pearce at Victoria University of Wellington and funded 2012–2014 by the Royal Society of New Zealand’s Marsden Fund (Whiley). Its key design decision was to build an imperative language “designed primarily to simplify verification” from scratch rather than retrofit one, and deliberately to avoid features that create “difficult or insurmountable problems for verification” (Pearce & Groves, Designing a verifying compiler: Lessons learned from developing Whiley). Specifications use requires/ensures clauses with the named return variable usable only in ensures, multiple clauses conjoined for readability. The distinctive mechanism is constrained types: type nat is (int n) where n >= 0 makes the invariant part of the type, with subtyping decided by constraint implication — so T1 <: T2 when they share an underlying type and T1’s constraint implies T2’s, which means type equivalence itself is a theorem-proving question. Loop invariants attach via where clauses, and the compiler statically discharges array-bounds, divide-by-zero, and null-misuse obligations. Its second signature feature is flow typing: after a runtime test x is S, the true branch types x as T & S and the false branch as T & !S, supported by union, intersection, and negation types (Whiley). Termination was explicitly out of scope, so there is no loop-variant syntax (Pearce & Groves).

Why it did not win. Whiley remained a research and teaching platform: documented adoption is student research projects and undergraduate classes, with contributions from “a small community” (Whiley). Its record shows the characteristic churn of a verification-first design: slow evolution, many syntax changes, and the removal of first-class string, char, set, dictionary, resizable-list, and real types to simplify the language and make compiler development manageable — i.e., the standard library shrank to keep the prover tractable. There is no concurrency support and no formal memory model for shared mutable state. The JVM target gave interop with Java but also placed Whiley in direct competition with a language that had every library and no proof obligations.

Does the reason still apply? Partially, and interestingly. The flow typing idea escaped entirely — TypeScript’s narrowing and control-flow analysis are the same mechanism in mainstream clothing — which is the clearest case in this dossier of an idea winning under a different name. The where-constrained-type idea is a strong agent-era candidate: expressing invariants in the type rather than in scattered assertions gives a checkable, compositional specification, and an agent can afford to declare nat, pos, and a dozen other refinements where a human would just write int. What does not change: subtyping-by-implication means type checking invokes a solver, so compile times and timeout-shaped failures remain; the missing concurrency story and absent memory model are language design gaps, not authoring gaps; and a shrinking standard library is a self-inflicted cost that agent synthesis mitigates but does not remove, since every synthesized data structure must itself be verified.

Dafny (2009) — Verification-Aware Programming with Automatic Discharge

The idea. Dafny was created in 2009 by K. Rustan M. Leino at Microsoft Research, following his earlier work on ESC/Modula-3, ESC/Java, and Spec# (Dafny). It is a “verification-aware programming language” requiring verification alongside code development, associated with the correct-by-construction paradigm. The annotation vocabulary is the most complete in mainstream reach: requires and ensures for pre/postconditions, invariant for loop invariants, decreases for loop variants and termination, modifies for framing which objects a method may mutate, with methods allowed side effects and specification-level functions required to be pure. Framing uses a variant of separation logic called implicit dynamic frames. Proofs between functions are written in the language itself: ghost methods encode lemmas, recursion supplies structural induction, match handles case analysis, and method invocation applies the inductive hypothesis. The pipeline compiles to Boogie as an intermediate verification language and discharges obligations with the Z3 SMT solver, “automatically, given sufficient specification,” with program analysis inferring many assertions to reduce specification burden — it can infer simple invariants like invariant i >= 0 but generally discards information about variables mutated in loops, so anything stronger (invariant forall i :: 0 <= i < arr.Length ==> arr[i] >= 0) must be stated explicitly (Dafny).

Why it did not win — yet. Dafny is the counterexample that proves the annotation-cost thesis, because it is the one language here whose adoption curve turned upward: Dafny 4 was released on 3 March 2023 and Dafny is used in industry, including by teams at Amazon such as the AWS Encryption SDK team (Dafny 4 is released). Its limits are structural rather than social. The verifier needs complete access to a function’s body to unroll it, and hiding contents with protected “can limit what properties can be established about it” — so verification fights information hiding. Loop invariants remain the reliable wall: the inference that works is shallow, and the invariants that matter must be hand-written (Dafny). And the failure mode users experience is not a clear counterexample but a silent timeout, which no amount of discipline prevents.

Does the reason still apply? This is the single strongest agent-era case in the dossier. The dominant cost was writing loop invariants, modifies clauses, and ghost lemmas — pure annotation-and-iteration labor, and the iteration loop is machine-checkable, meaning an agent gets a hard pass/fail signal and can search. Dafny’s design already anticipates the workflow: obligations are discharged automatically given sufficient specification, so the job reduces to “produce enough specification,” which is exactly what a tireless author with a solver in the loop is good at. What does not change: SMT undecidability and timeouts — an agent that cannot find an invariant fails the same way a human does, only faster and more often; the verification-versus-abstraction tension around protected; and the deployment reality that Dafny compiles out to another language, so the runtime, interop, and ecosystem story remains that of the target platform.

Liquid Haskell (2014) — Refinement Types as an Optional, Non-Invasive Layer

The idea. LiquidHaskell was built by Niki Vazou, Eric L. Seidel, and Ranjit Jhala at UC San Diego, presented at Haskell ‘14 in Gothenburg on 6 September 2014, with support including a gift from Microsoft Research (Vazou, Seidel & Jhala, LiquidHaskell: Experience with Refinement Types in the Real World). It refines base types with predicates from a decidable logic — specifically quantifier-free equality, uninterpreted functions and linear arithmetic (QF-EUFLIA) — so that type Nat = {v:Int | 0 <= v} and div :: n:Nat -> d:Pos -> {v:Nat | v <= n} turn a divide-by-zero into a type error. Dependent binders let input names appear in output refinements (range :: lo:Int -> hi:{Int | lo <= hi} -> [(Rng lo hi)]). measure declarations lift inductive properties of ADTs into the logic, with one equation per constructor, from which refined constructor types are derived ((:) :: _ -> xs:_ -> {v:[a]| len v = 1 + len xs}). Abstract refinements quantify over predicates, and refined data definitions enforce global invariants such as every CSV row matching the header length. The strategic design choice is deployment: refinements live in {-@ ... @-} comments, do not affect dynamic semantics, and make the tool “an optional type checker for Haskell” that can be applied to existing libraries without compiler changes (Vazou et al.).

Why it did not win. LiquidHaskell chose the least-resistance path — no new language, no new compiler, gradual application to existing code, an SMT-backed subtyping check — and still remains a specialist tool within an already-specialist community; the accompanying materials present it as a research artifact with a tutorial-driven learning path (Jhala, Seidel & Vazou, Programming with Refinement Types). The decidable-logic restriction is the crux: everything expressible must fit QF-EUFLIA and measure definitions are constrained to one equation per constructor with right-hand sides in the restricted logic, so properties naturally stated with quantifiers or higher-order reasoning require encoding gymnastics. And it inherits Haskell’s own adoption ceiling.

Does the reason still apply? The comment-based, optional, non-invasive architecture is close to the ideal agent target: it can be added to an existing codebase incrementally, each annotation is independently checkable, and failure is localized. Writing {-@ measure len @-} and threading length refinements through a library is precisely the high-tedium, low-creativity work that made humans skip it. What does not change: the logic’s decidability envelope is a hard ceiling on expressiveness, not a labor cost — an agent cannot refine its way past QF-EUFLIA any more than a human can; and because refinements have no runtime effect, they buy nothing at all if the specification is subtly wrong, which shifts the burden from writing specs to reviewing them. That review burden is the new scarce resource, and it argues for the Eiffel/SPARK style of executable contract over pure static refinement.


Capability Security

Object-capability security is the oldest idea in this dossier that the mainstream has most comprehensively ignored: capabilities were proposed by Jack Dennis and Earl C. Van Horn in 1966, combining “an unforgeable reference” with a message specifying an operation, such that references arise only through initial conditions, parenthood, endowment, and introduction — summarized as “only connectivity begets connectivity” (Object-capability model). The reason mainstream languages cannot express it is structural rather than aesthetic: JavaScript, Java, and C# grant “undeniable authority” through direct instance-variable assignment, reflective metadata inspection, and pervasive imports of primitives like java.io.File, which violates the model’s conditions outright. The lineage of attempted fixes is long — Act 1 (1981), Eden (1985), Emerald (1987), Joule (1996), Original-E (1997), Joe-E (2005), Emily (2006), Caja (2007–2021), Monte (2008–), Wyvern (2012–), Newspeak (2007–), Pony (2014–) (Object-capability model). Emily and Caja are the interesting near-misses: both are subsets plus taming, Caja aiming at safely embedding untrusted JavaScript, and Caja’s two-decade run ending in 2021 is the clearest evidence that retrofitting ocap onto an ambient-authority language is a losing maintenance battle.

E (1997) — Object Capabilities, Vats, Eventual Sends, and Promises

The idea. E was created in 1997 by Mark S. Miller, Dan Bornstein, Douglas Crockford, Chip Morningstar and others at Electric Communities, and open-sourced in 1998; it was preceded by Original-E, built by adding Joule concepts to a sequential capability-secure subset of Java (E; Miller, Tribble & Shapiro, Concurrency Among Strangers). Two mechanisms carry the design. First, authority is conveyed by possession of an object reference and nothing else, so capabilities “add no computational or conceptual overhead costs”; least authority is implemented by handing out narrow objects — in Miller’s canonical example, publishers get statusSetter while subscribers get only statusGetter and therefore cannot call setStatus, no access-control list required. Second, concurrency: every object lives in exactly one vat containing a heap, one thread of control, a call stack, and a pending-delivery queue. Near references (same vat) permit immediate calls with .; references crossing vat boundaries are eventual and permit only <-, with an immediate call on one throwing. target <- method(args) queues a delivery and returns a promise immediately; each delivery plus all immediate calls it causes runs to completion as one turn before the next queued delivery, so turns cannot block and lock-based deadlock is structurally impossible. Messages to unresolved promises are buffered FIFO and forwarded on resolution, which enables pipelining — x <- a() <- c(y <- b()) streams dependent requests without round trips. Exceptions break promises and propagate through dependent sends without aborting the sender’s turn; partitions break cross-vat references and whenBroken handlers react; offline capabilities are captp:// URIs carrying a target vat’s public-key fingerprint, location hints, and an unguessable swiss number (Miller et al.).

Why it did not win. E arrived with a corporate origin in a virtual-worlds company, a novel syntax (:= for assignment, no = operator at all, optional guards like :(int >= 0) that are “not quite type declarations”), and a security model that required rebuilding an application’s entire authority architecture rather than adding a library (E). Its timing was exactly wrong: E’s distributed-object story landed while the industry was standardizing on HTTP, and its security story landed before supply-chain attacks made ambient authority feel dangerous. The retrospective irony is that E’s concurrency half won completely — promises and turn-based event loops are now how JavaScript works, with Crockford on the design team — while its security half did not travel, because promises can be adopted as a library and capability discipline cannot.

Does the reason still apply? The barriers here are architectural, not notational, so the agent-era verdict is mixed but favorable for a specific reason: the cost of ocap discipline is the cost of threading authority explicitly through constructors and parameters instead of importing fs at the top of a file. That plumbing is tedious, repetitive, mechanically checkable, and completely uncreative — the archetype of what agents do well and humans refuse to do. And the payoff has inverted since 1997: when code is authored by a semi-trusted machine and pulled from a package ecosystem that has become an attack surface, “this module cannot touch the filesystem because it was never handed a filesystem” is exactly the property a reviewer wants. What does not change: vat-and-turn concurrency is a runtime model with real costs, ocap security is only as strong as the boundary (an agent that decides to pass fileSystem in defeats it), and no amount of agent labor makes a mainstream language’s reflection and ambient imports go away.

Joe-E (2005) — Capability Safety as a Verified Subset of Java

The idea. Joe-E was built by Adrian Mettler and David Wagner at UC Berkeley with Tyler Close of waterken.org; the specification version 1.1 is dated 18 September 2009 and the verifier and libraries shipped open-source (Mettler, Wagner & Close, Joe-E: A Security-Oriented Subset of Java), with the language dated to 2005 in capability-model surveys (Object-capability model). The engineering choice is the point: Joe-E adds nothing to Java. A Joe-E program is a Java program satisfying extra restrictions checked by a verifier that “does not transform the program,” so existing JVMs, debuggers, and profilers keep working. The restrictions enforce ocap by closing Java’s authority leaks: the global scope may contain only immutable data (all static fields final and of transitively immutable type); org.joe_e.Immutable implementors must have only final fields of primitive or Immutable type, checked at compile time; native methods are prohibited; reflection features that disable access checks are not exposed; overriding finalize() is prohibited; all throwables must be immutable, and catching Throwable, Error, or any Error subtype is forbidden along with the finally keyword. Ambient-authority JDK APIs are excluded by “taming,” with safe wrappers supplied where needed. Capabilities then propagate through ordinary Java references — constructor arguments, parameters, returns, fields — and objects begin life with no authority except what was passed in. Verification is per-file rather than whole-program. Waterken layers vats on top: each application object belongs to one single-threaded persistent event loop, with asynchronous invocation across vats able to transport exported references (Mettler et al.).

Why it did not win. The authors name the barrier themselves: effective use requires architecting systems according to capability-design principles that “are unfamiliar to most programmers” and likely require training, and taming the Java library is itself substantial ongoing work (Mettler et al.). That is a brutal combination — the language delta is zero, so there is nothing to learn syntactically, yet the design delta is total, and the restrictions that make it work (no finally, no catching Error, no native methods, a tamed subset of the JDK) break idiomatic Java and most existing libraries at exactly the point where a team would want to reuse code. A security property that costs you the ecosystem is a hard sell absent a mandate.

Does the reason still apply? The “unfamiliar architecture requires training” barrier is precisely the kind that dissolves when the architect is a machine with no habits: an agent asked to write a module that receives its authority as constructor arguments does so without complaint, and a per-file verifier gives it a fast local check. The taming work — auditing a large library surface and writing safe wrappers — is large-scale mechanical review, which is now plausibly automatable at a cost that was prohibitive for a university group in 2009. What does not change: losing finally and catchable Errors still breaks real libraries, and no authoring change makes an untamed dependency safe. The likely agent-era form of this idea is not Joe-E revived but per-module capability manifests enforced by a verifier over a mainstream language — the same trick, with the taming burden paid by machines.

Wyvern (2012) — Capability-Safe Modules Plus an Effect System

The idea. Wyvern is a Carnegie Mellon language (Jennifer A. Fish, Darya Melicher, Jonathan Aldrich), dated to 2012 in capability surveys (Object-capability model), whose case study on building an I/O library shows the design concretely (Fish, Melicher & Aldrich, A Case Study in Language-Based Security: Building an I/O Library for Wyvern). Modules are first-class capabilities and global state is forbidden — a module gets access to a resource only when a capability is passed as an instantiation argument or delegated later at runtime. The filesystem library is a capability hierarchy with progressively narrower authority: fileSystem → Directory → File → read-only Reader or write-only Writer, where fileFor(path) yields a File, directoryFor(path) a Directory, and makeReader()/makeWriter() the restricted streams. The root fileSystem module can only be instantiated with a special java FFI capability handed by the runtime to the top-level script, so authority has a single traceable origin. Layered on top is an effect system: effects annotate resource uses such as file and network reads and writes, types may declare abstract effects given concrete definitions at instantiation, functions and types may be parameterized by effects, FFI calls automatically carry system.FFI, and higher-level effects abstract over it — the library defines fileEffects.Read/Write initially equated with system.FFI. Effect annotations are statically checked and erasable at runtime. A third mechanism, type-specific languages, lets a type control how its literals parse and elaborate, so format strings splice typechecked expressions with %{...} and — crucially for injection safety — user-supplied strings are String, not FormatString, and cannot be coerced, forcing format strings to be literals in program text (Fish et al.).

Why it did not win. Wyvern is an active research language rather than a failed product, and its own case study is candid about the costs: capability designs can require wrapper objects producing runtime overhead, and the paper’s contribution is a demonstration that a usable I/O library can be built this way — which tells you that it was not obvious. Structurally it asks for two simultaneous discipline changes (capability threading plus effect annotation) in a language with no ecosystem, no corporate sponsor, and a JVM-FFI-shaped interop story.

Does the reason still apply? Wyvern is arguably the most agent-appropriate design in the capability cluster because it combines two things machines do cheaply and humans do badly: threading authority explicitly and annotating effects exhaustively. The abstract-effect mechanism matters here — it means a module’s authority signature can be read off its type, which is exactly the summary a human reviewer of agent-written code needs, and effect erasure means the annotations cost nothing at runtime. The TSL injection-safety trick generalizes beautifully to the agent setting, where the classic failure is an LLM concatenating user input into a query string: a type system that makes user strings structurally incapable of being format strings defeats that class of bug by construction rather than by vigilance. What does not change: wrapper-object overhead is real, and the capability hierarchy has to be designed once by someone — agents can populate a hierarchy but the decision about what authority exists is architectural.

Newspeak (2007) — Modules as Objects, No Global Namespace, No Static State

The idea. Newspeak was developed by Gilad Bracha with Peter von der Ahé, Vassili Bykov, Yaron Kashai, William Maddox and Eliot Miranda, originally at Cadence, with a specification version 0.05 in 2009 and a prototype built on Squeak Smalltalk representing roughly eight person-years of work (Bracha et al., Modules as Objects in Newspeak). It takes one idea to its limit: modularity is based exclusively on arbitrarily nested classes — no packages, components, or fragments. Top-level classes are module definitions, first-class, immutable, stateless, self-contained parametric namespaces; their instances are modules and may be stateful. There is no global namespace and no static state whatsoever, so every external dependency must be supplied as an argument to a module’s factory method: class ShapeLibrary usingPlatform: platform = (...), with immutable imported slots bound by = (private List = platform collections List.) and mutable slots by ::=, which also generates accessors. Factory arguments are visible only in the instance initializer, so the programmer deliberately chooses what to retain. This makes capability security fall out of the module system: a module receives capabilities as ordinary object arguments, and holding a reference to an object able to perform an operation is the authority to perform it. All names are late-bound method invocations — classes, slots, methods, and even superclass names are virtual and overridable, and every class declaration is a mixin declaration — so modules can be instantiated side by side with different dependencies, passed, stored, or dynamically substituted like any object. Bracha’s own summary of the language notes its design intent to support “modularity and security,” with top-level classes acting as component-style modules and object-capability sandboxes, and pluggable types planned (Bracha, Newspeak).

Why it did not win. Newspeak asked for the elimination of the two mechanisms every working programmer uses to get anything done — imports and statics — in a Smalltalk-family syntax, on a Squeak-based prototype, funded by an EDA company with no stake in language adoption; the paper itself flags mutual recursion as awkward under the no-global-namespace rule (Bracha et al.). Dynamic typing with types only “planned” meant it offered neither the tooling of a static language nor the ecosystem of a dynamic one. Eight person-years produced a beautiful system with nobody to hand it to.

Does the reason still apply? The specific pain Newspeak inflicts — every dependency must be explicitly passed, nothing is reachable by ambient name — is dependency-injection boilerplate, and boilerplate is what agents are for. There is a real prize on the other side: a codebase with no global namespace and no static state is one where an agent’s blast radius is bounded by construction, and where a reviewer can determine a module’s capabilities from its factory signature alone. That is a far better property than any amount of sandboxing after the fact. What does not change: the mutual-recursion awkwardness is a genuine expressiveness cost; late binding of everything, including superclasses, is hostile to static analysis at exactly the moment we want more of it; and Newspeak’s own tooling and runtime lineage is a dead end. Expect the idea to resurface as “no ambient imports, inject everything” conventions enforced by linters in mainstream languages, not as Newspeak.


Totality, Termination, and Bounded Execution

The languages here all restrict what you may compute in order to guarantee something about whether you compute. Their common failure was that the restriction was felt continuously and the guarantee was felt rarely. The agent-era question splits cleanly: where totality costs only annotation and proof search (Idris, Agda), machine authorship helps a great deal; where it costs expressiveness (Dhall, Bosque), nothing changes, because the restriction binds the program, not the programmer. Coq and Lean are the useful contrast — both accepted much heavier proof burdens than Idris and both grew, because their users came for proofs rather than for programs, which suggests the binding constraint was never the checker but what the user wanted out of it.

Idris (2011/2017) — Full Dependent Types with Optional Totality

The idea. Idris was designed by Edwin Brady at the University of St Andrews, with the implementation paper dated 15 September 2013 and version 1.0 released in 2017 (Brady, Idris, a General Purpose Dependently Typed Programming Language; InfoQ, Dependent-Types Language Idris Reaches 1.0). It supports full dependent types — “no restriction on which values may appear in types” — while remaining a general-purpose language rather than a proof assistant. The implementation strategy is the interesting part: source passes through explicit phases, IDRIS desugared to IDRIS−, elaborated to a small core type theory TT (a dependently typed λ-calculus with inductive families, ADTs and pattern matching), then compiled. Elaboration runs an elaboration monad recording incomplete programs plus a collection of tactics that construct and refine TT terms under the direction of high-level syntax, using type checking, unification and evaluation to resolve holes — which is how conveniences like implicit arguments (introduced automatically for names free in non-function positions, inferable from applications, overridable as {n=2}), type classes, case, and with rules for matching on intermediate dependent values are all reduced to the same small core. Totality is checked internally but not required by default: the total keyword enforces it, and the checker verifies that all patterns are covered and recursive calls operate on structurally smaller values. Total programs get stronger guarantees from their types and can be optimized more aggressively; coinductive definitions are supported for legitimately non-terminating processes (Brady).

Why it did not win. Brady is explicit about the structural cost: type inference is generally undecidable for dependent types, so all top-level functions must have type signatures — and with full dependent types those signatures carry the program’s logical content, which is where the real work is. He also names the competitive reality plainly: Haskell’s type-system extensions have “the short-term advantage of mature infrastructure and extensive libraries,” against which Idris offers freedom from backwards compatibility (Brady). At 1.0, Brady described Idris as primarily a research tool, “under-stuffed to be considered production-ready,” needing compiler and runtime efficiency work, with over 200 open bugs, many concerning tooling and usability (InfoQ).

Does the reason still apply? Mandatory top-level type signatures are the barrier most cleanly inverted by agents: a signature is a specification, an agent can produce it, and — unlike a comment — the compiler checks that the body matches it. Interactive elaboration with holes is close to an ideal machine interface; it is a search problem with typed, local feedback, which is what agents exploit best. Optional totality is a better design for this era than Agda’s mandatory version, because it lets an agent prove what it can and fall back where it cannot. What does not change: undecidable inference is a theorem; runtime performance and library depth are engineering debts that agent authorship does not retire; and dependently typed error messages remain hard for the humans who must review the result. The realistic path is dependent-type ideas arriving in mainstream languages piecemeal — refinement types, const generics, exhaustiveness — rather than Idris displacing anything.

Agda (1999/2007) — Dependent Types Where Totality Is Non-Negotiable

The idea. The original Agda system was developed by Catarina Coquand at Chalmers in 1999 (1.0); the rewritten Agda 2 by Ulf Norell appeared in 2007, with development continuing at Chalmers (Agda). Agda is a dependently typed functional language and proof assistant built on propositions-as-types via Curry–Howard, grounded in Zhaohui Luo’s unified theory of dependent types. Data types are inductive families: natural numbers from zero and suc, the relation ≤ from constructors encoding its axioms and inference rules. Dependently typed pattern matching is the induction and recursion principle — matching is primitive, and the core language contains no separate recursor. Proofs are ordinary functional programs; a term inhabiting a proposition’s type is a proof. Development is interactive through metavariables: writing ? creates a hole, and the Emacs interface displays its expected type and lets the user refine it incrementally. The non-negotiable part: every program must terminate and all patterns must be matched, enforced by the Foetus termination checker, because without termination and total coverage the logic becomes inconsistent and arbitrary statements become provable. There is no separate tactics language; proof automation is written inside Agda, including reflective programming and Emacs-mode proof search (Agda).

Why it did not win as a programming language. Agda’s own documentation states the cost: programming in pure type theory involves “a lot of tedious and repetitive proofs,” the standard library is described as in beta and under active development, and source relies heavily on Unicode (Agda). Each of those is disqualifying for production use independently. Mandatory totality is the deepest issue — a server loop, a REPL, an event handler, and an interpreter are all legitimately non-terminating, so the very programs industry writes require the escape hatch of coinduction, which imposes its own discipline. And with no tactics language, automation must be built from within, raising the floor of expertise needed to avoid the tedium.

Does the reason still apply? “Tedious and repetitive proofs” is, on its face, the single most agent-favorable phrase in this dossier: repetitive machine-checkable obligations are exactly what a tireless author with a typechecker in the loop should absorb, and hole-driven interactive development gives excellent local feedback. Unicode-heavy syntax stops mattering when the writer is a machine and the reader has a rendering font. But the honest assessment is that Agda’s barriers are only half labor. Mandatory totality is an expressiveness restriction, not an annotation cost: no amount of agent effort makes a non-terminating program acceptable to Foetus. Termination checking is undecidable in general, so a correct program can be rejected, and the fix requires restructuring the algorithm — a creative act with no checkable search signal. Agda’s most likely agent-era role is what it already is: a place where the hard theorems get proved, with results exported into ordinary languages.

Dhall (2017) — Total Configuration, and Non-Turing-Completeness as a Social Signal

The idea. Dhall was created by Gabriella Gonzalez, with the Haskell package copyrighted 2017 and described as “a configuration language guaranteed to terminate” (dhall on Hackage). The pitch is “JSON + functions + types + imports,” and the guarantees are precise: it is not Turing-complete, so “evaluation always terminates, no exceptions,” and every configuration file “can be reduced to a normal form which eliminates all abstraction and indirection” — meaning any Dhall program, however layered, can be flattened into inert data for review (dhall-lang). Totality is achieved by three mechanisms together: eliminating general recursion, a strong type system with “no escape hatches for reintroducing general recursion,” and forbidding arbitrary side effects, which otherwise backdoor recursion into a language (Gonzalez, Why Dhall advertises the absence of Turing-completeness). The language is formally specified so that independent bindings in other languages can be checked against a standard test suite, and deliberately minimal — “you cannot even compare strings for equality” (dhall-lang).

Why it did not win — and what “winning” means here. Dhall reached real distribution (Arch, Debian, Fedora, NixOS, Stackage, with ~58 direct reverse dependencies on Hackage) without displacing YAML or JSON in the mainstream (dhall on Hackage). Its designer’s own analysis is unusually clear-eyed and is the most useful data point in this section: the absence of Turing-completeness “does not provide many safety guarantees,” since a compact Dhall function can still take longer than the age of the universe to evaluate — he offers an Ackermann implementation as proof. The desirable properties people actually want (inert, understandable, side-effect-free, no crashes) “do not necessarily imply” non-Turing-completeness. Gonzalez concludes that “not Turing-complete” functions largely as a shibboleth — a signaling mechanism that marks membership in the camp that believes configuration should be data rather than programs (Gonzalez). Meanwhile the opposing camp cites types and DRY as the real remedies for configuration-induced outages, and Dhall’s multi-language-binding strategy imposes a hard complexity budget: “the more complex the configuration language the more difficult to create new bindings” (dhall-lang).

Does the reason still apply? Dhall is the clearest case where agent authorship changes nothing about the barrier and quite a lot about the value. The barrier was never that Dhall was hard to write — it is that YAML is already written, tooling assumes it, and totality’s benefit is diffuse. None of that shifts. But normalization to an abstraction-free normal form becomes genuinely more valuable when a machine generates configuration: a reviewer can diff the normal form rather than the generated abstractions, which is a direct answer to “the agent produced 400 lines of clever templating and I cannot tell what it does.” Guaranteed termination matters more, too, when configuration is produced by a process that will not notice it wrote a loop. Against that: minimalism that forbids string equality means an agent hits expressiveness walls a human would route around with a script, and the shibboleth dynamic is cultural inertia in its purest form.

Bosque (2019) — Regularized Programming, Built for Machine Reasoning

The idea. Bosque was designed by Mark Marron at Microsoft Research, first appearing on 3 March 2019, published as MSR-TR-2019-10 and described as “an experiment in regularized design for a machine-assisted rapid and reliable software development” (Marron, Regularized Programming with the Bosque Language). The mechanism is subtraction. Bosque aims to move past the structured-programming model of the 1970s by removing sources of complexity: loops, mutable state, and reference equality (Bosque). In place of low-level loop actions it provides algebraic data-transformation operators, and it removes “incidental ties to a particular computational substrate” and “indeterminate behaviors” so that reasoning about program behavior — by tools, not only humans — becomes tractable. The claimed payoff is explicitly tool-facing: “massively improved developer productivity,” “increased software quality,” and “a second golden age of developments in compilers and developer tooling” (Marron).

Why it did not win. Bosque is the one entry here explicitly designed for machine-assisted development, and it is instructive that it has not spread despite a Microsoft Research origin and considerable press. No adoption barrier is stated in its own materials, so the assessment must be structural: it is a research language that asks developers to give up loops, mutation, and reference identity — three things every existing codebase and every existing programmer depends on — with no migration path from anything, no ecosystem, and a value proposition (“tools can reason about your code better”) whose beneficiary was, in 2019, hypothetical. Bosque also illustrates a timing failure of a distinctive kind: it arrived before the machine consumer of its regularity existed at scale, which is the mirror image of Eiffel arriving before the industry cared about reusable components.

Does the reason still apply? Bosque’s premise has aged extremely well even though the language has not. The argument for regularization was always that indeterminate behaviors and substrate-specific semantics make automated reasoning expensive, and that argument is strictly stronger now that machines both write and analyze the code. The removal of loops in favor of algebraic operators is the kind of restriction an agent pays nothing for — it has no muscle memory for for — while a human loses a familiar tool. What does not change, and is decisive: removing mutable state and reference equality has performance consequences that no authoring change addresses, and interop with a world built on mutation is an ongoing tax. The likely legacy is not Bosque adoption but the vindication of its thesis in other forms — the growing preference for pure functional cores, immutable data, and deterministic builds in agent-heavy workflows.


Fault Tolerance, Supervision, and Actors Done Right

This is the cluster where an idea did win, which makes it the best control group in the dossier. Erlang’s model propagated — into Elixir, Akka, Orleans, and the general industry assumption that a service should be restartable — while Pony’s and Oz’s refinements of it did not. The differentiator was not elegance but the existence of a production system that could not be built any other way. Note also what was adopted: the architecture (isolation, supervision, restart) travelled, largely without the language, and often reimplemented as a framework or an orchestrator rather than a runtime. That pattern — idea escapes, language does not — recurs throughout this dossier.

Erlang (1986/1993) — Isolation, Let It Crash, and Supervision Trees

The idea. Research began at the Ericsson Computer Science Lab in 1981; Joe Armstrong began work on the language in 1986, the name first appears in 1987 with a Prolog-based implementation by year-end, Erlang acquired its own syntax and became a language in its own right in 1990, the first commercial version shipped in 1993, and Erlang plus the OTP libraries were released under an open-source license in December 1998 (Armstrong, Making reliable distributed systems in the presence of software errors). The original team was Armstrong (compiler), Robert Virding (libraries), and Mike Williams (JAM emulator), with Claes Wikström adding distribution in 1991. The mechanism is a stack of four commitments. Processes are lightweight, managed by the runtime rather than the OS, share no memory, and communicate only by asynchronous message passing into a mailbox, where receive pattern-matches and re-queues non-matching messages. Processes are therefore the unit of error encapsulation: a failure cannot propagate unless links were deliberately established. “Let it crash” means that on encountering an error it does not know how to handle, a process should terminate — “if you can’t do what you want to do, die” and “let some other process fix the error.” Recovery is structural: supervision trees arrange supervisors over workers and other supervisors, a failed worker emits an exit signal carrying a reason, and the supervisor restarts that child or all children depending on OR- or AND-supervision, with OTP behaviours (gen_server, gen_event, gen_fsm) standardizing worker shape (Armstrong). Armstrong’s later summary reduces the requirements for fault tolerance to four: isolated processes, pure message passing, remote error detection, and the ability to determine why a process crashed; there are no mutexes and no shared memory (Armstrong, Erlang, CACM).

Why it did not win sooner. The decisive event was corporate, not technical: Erlang was banned for new Ericsson product development in February 1998 because Ericsson wanted to be a consumer of widely used languages rather than the owner of a proprietary one (Armstrong) — a ban imposed on a language that had just shipped the AXD301, which by 2003 exceeded 1.7 million lines of Erlang and became a market leader in its niche. Open-sourcing in December 1998 was the escape route, but Armstrong records that uptake was slow after 2000 before a “dramatic upturn” driven by multicore, messaging, and reliable storage systems — RabbitMQ, ejabberd, CouchDB, MochiWeb, Amazon SimpleDB (Armstrong, CACM). The commonly cited barriers of Prolog-derived syntax and telecom association are real but subordinate; the strongest evidence for the syntax argument is that Elixir’s popularity was built by putting a different surface on the same runtime.

Does the reason still apply? Almost none of it. Single-vendor risk was resolved by open-sourcing; the “arrived before the problem was felt” timing problem resolved itself when everything became distributed and multicore; and the syntax objection is the one barrier that agent authorship neutralizes outright, since an agent is indifferent between ->/end and braces. There is a sharper agent-era argument: “let it crash” is the correct discipline for code whose author is a machine that cannot be trusted to enumerate failure modes. Defensive programming requires anticipating what can go wrong; supervision requires only deciding what to restart. That trade — replacing exhaustive foresight with structural recovery — is exactly what you want when a fallible author generates large volumes of code, and it explains why supervision has been reinvented at the infrastructure layer (Kubernetes restarts, retry-and-circuit-breaker libraries) even where the language offers no help. What does not change: isolation costs copying, per-process heaps cost memory, and the model buys nothing for single-threaded CPU-bound work.

Pony (2014) — Reference Capabilities Making Data-Race Freedom a Type Property

The idea. Pony, created by Sylvan Clebsch, is an actor-model, capabilities-secure, statically typed language dated to 2014 in capability surveys (Object-capability model). Its contribution is reference capabilities: annotations on every reference that “codify in the type system safe data handling practices” and describe to the compiler how data may be handled, such that “if you try to do something unsafe, your program won’t compile” (Pony, Reference Capabilities). The practical effect is that Erlang-style actor isolation stops requiring copying: because the type system tracks whether a reference is uniquely owned, immutable, or shareable, Pony can pass data between actors by reference while statically guaranteeing no two actors hold conflicting mutable access — data-race freedom without either locks or defensive deep copies. Pony pairs this with C-FFI interop for wrapping existing C libraries (Pony, Why not Pony?).

Why it did not win. Pony’s own documentation is refreshingly direct on both halves. On the idea: reference capabilities are “one of the ideas that make Pony unique” and are acknowledged as difficult to learn, with some people concluding Pony has “too much type system” or is “too hard,” especially for programmers coming from dynamically typed or single-threaded languages — “generics and reference capabilities are the hardest things to get a handle on while learning Pony” (Pony, Reference Capabilities). On the ecosystem: Pony remains pre-1.0 with breaking changes “regularly,” the pool of ready-to-use libraries is “very small,” it is a “batteries required” language where missing functionality must be written from scratch or wrapped from C, there is no IDE, and GDB/LLDB debugging has “some rough edges” — the project itself advises that projects needing a large community and library wealth are “much better off selecting another language” (Pony, Why not Pony?).

Does the reason still apply? This is a near-perfect split between a barrier that dissolves and barriers that do not. The cognitive-load barrier — the central stated reason people bounce off Pony — is a human working-memory constraint. An agent tracking six capability annotations across a call graph is not straining; it is doing the kind of bookkeeping compilers were invented for, and the compiler provides an exact, local error signal to iterate against. If reference capabilities were the problem, Pony’s problem is solved. But they were not the only problem: pre-1.0 instability, an empty library ecosystem, and absent IDE and debugger support are all ecosystem-and-tooling costs. Agent-driven library synthesis genuinely attacks the library gap (writing a Pony HTTP client is a bounded task), but breaking changes each release are a governance failure, and debugging remains a human activity for which rough tooling is a real tax. Note also the evolutionary evidence: Clebsch subsequently worked on Microsoft’s Project Verona, which suggests the ideas are migrating rather than the language reviving.

Oz / Mozart (1995) — A Layered Kernel Language and Dataflow Variables

The idea. Oz design began in 1991 in the HYDRA project at DFKI Saarbrücken under Gert Smolka with Martin Henz, Michael Mehl and Ralf Scheidhauer, in collaboration with Seif Haridi’s group at SICS and Hassan Aït-Kaci’s at DEC PRL through the ACCLAIM project (1992–1995); the first prototype was demonstrated in late 1992, DFKI Oz 1.0 was released 23 January 1995, and Mozart 1.0 (Oz 3) on 25 January 1999 under a BSD-style open-source license, with later contributions from Peter Van Roy and Christian Schulte (Van Roy et al., A History of the Oz Multiparadigm Language). The design idea is a layered kernel language: rather than gluing paradigms together, each paradigm is a subset of one kernel language, so functional, object-oriented, concurrent, constraint, and distributed styles coexist in one program with one semantics — “a coherent design of a language that combines the programming abstractions of various paradigms in a clean and simple way.” The semantic base is a shared constraint store observed by concurrent agents through two operations: tell adds a constraint, ask waits until the store entails a constraint or its negation. Dataflow variables — single-assignment logic variables on which threads block until binding — are the synchronization primitive from which deterministic dataflow, lazy streams, and channels are all derived. Adding cells gives explicit mutable state, ports give named many-to-one message streams (i.e. actors), WaitNeeded gives by-need laziness, and first-class computation spaces (NewSpace, Choose, Ask, Commit, Clone, Merge) give programmable search. Each added mechanism is a deliberate step away from declarative purity, which is the pedagogical payoff: the layering shows exactly what each expressive gain costs (Van Roy et al.).

Why it did not win. Mozart achieved real distribution — over 10,000 downloads in 1999 and continued use through 2009 (Van Roy et al.) — and became influential primarily through a textbook rather than through deployed systems. Its position was the hardest one in language marketing: a language whose selling point is that it can do everything has no single constituency, competes with the best-in-class tool in each paradigm it supports, and is most easily described to outsiders as “academic.” Its funding and stewardship were distributed across three research institutions and a European project, which is excellent for research output and poor for the sustained, unglamorous work of ecosystem building.

Does the reason still apply? Dataflow variables are the transferable prize and their agent-era case is strong: a single-assignment variable that blocks readers until written is a synchronization primitive with no race conditions to reason about, and it expresses “these computations depend on each other, figure out the order” — which is precisely the level of abstraction at which a machine-authored concurrent program should be specified. Promises are the degenerate one-shot case, and they won; the general case did not. The layered-kernel pedagogy also has a new audience: a rigorous account of which language mechanism buys which expressiveness at which semantic cost is exactly the reference an agent choosing an implementation strategy should consult. What does not change: multiparadigm breadth without a killer application is still a positioning failure, the constraint-store runtime carries costs a specialized runtime avoids, and a language maintained by rotating graduate cohorts has a structural sustainability problem regardless of who writes the code.


Simplicity by Law — Small Is a Feature

These languages made smallness a design constraint rather than an aspiration, and they show the full range of outcomes: Lua won overwhelmingly in its niche, Forth won in a narrower one, Oberon won intellectually and lost commercially, and the Newsqueak–Alef–Limbo line won posthumously through Go. The pattern that explains the difference is embeddability and interop, not elegance. The agent-era question for this cluster is uncomfortable, because “small language, few features” was largely a concession to human working memory and to compiler-implementation effort — two constraints that machine authorship relaxes — while the genuine benefits (fast compilation, predictable code, small runtime, easy embedding) are mechanical and survive intact.

Oberon (1987) — Reduce Rather Than Increase Complexity

The idea. Oberon was designed by Niklaus Wirth at ETH Zurich, with design work spanning 1986–1988 and first publication in 1987, as part of implementing the Oberon operating system for the Ceres workstation (Wirth, The Programming Language Oberon (Oberon Day, CERN, 2004); Oberon). The method was explicitly subtractive: take Modula-2 as the basis, discard several inessential features, add exactly one major capability — type extension of record types, giving inheritance-like extensibility — and simplify the syntax, under the stated design direction “reduce rather than increase complexity” (Wirth). The concrete mechanisms are modules with separate compilation and no overhead for crossing module boundaries, “watertight type checking, also across module boundaries, at compile time,” very fast loading and linking with modules loadable dynamically on demand at runtime, low-level device-register access encapsulated inside designated modules, strict type checking with runtime index and null-pointer checks, and a compiler that generates “straight” code with predictable behavior and “no surprises,” under the rule that “no hidden mechanisms” are tolerated. Wirth’s claimed payoff chain runs: simpler to define and document → easier to learn → cheaper to implement and faster to compile → fewer misunderstandings and more efficient programs → disciplined programming and fewer mistakes (Wirth).

Why it did not win. Michael Franz, who joined Wirth’s Oberon group in early 1989, wrote the definitive post-mortem and its causes are almost entirely social. Oberon was “too far ahead of their time.” The research community expected a language and received a complete system, so people examined the language and “ignored the remainder.” Wirth avoided marketing, and his modesty produced “self-imposed obscurity” — Franz argues Modula and Oberon “would probably have been considerably more successful” had their names advertised the Pascal lineage (“Pascal-2,” “Pascal Plus”). The original hardware existed “only at ETH in Zurich.” The user interface was “highly unusual and outright intimidating,” lacked introductory tutorials, had a “very steep learning curve,” and required a three-button mouse where many simultaneous-click combinations carried distinct meanings. And the timing was fatal: Oberon users were doing load-time dynamic just-in-time compilation with machine-independent “Slim Binaries” by late 1994, and then Java’s publicity in 1995 “more or less completely drowned all prior or simultaneous research” in mobile code and dynamic compilation (Franz, Oberon — The Overlooked Jewel).

Does the reason still apply? Several barriers evaporate and one hardens. Naming, marketing, and the intimidating three-button interface were friction against human onboarding, and an agent does not onboard. The steep learning curve and absent tutorials likewise stop mattering when the writer has read the language report. But Oberon’s central thesis is partly undermined by agent authorship: much of the argument for radical minimalism was that humans cannot hold a large language in their heads and that small languages are cheap to implement — and a machine author is not constrained that way, which is why agents are perfectly happy writing modern C++. What survives, and is arguably more valuable than ever, is the mechanical half: fast compilation and linking, no hidden mechanisms, predictable generated code, and watertight cross-module compile-time type checking are exactly the properties that make a codebase cheap to verify at the scale agents can produce. Also unchanged: Franz’s note that the community rejected the all-or-nothing system, and the general truth that a language requiring you to abandon your existing toolchain loses.

Newsqueak (1980s) and Alef (1992) — First-Class Channels, and the Maintenance Wall

The idea. Newsqueak was developed in the first half of the 1980s by Luca Cardelli and Rob Pike at Bell Labs as a concurrent language for interactive graphical interfaces — presented, with its predecessor Squeak, as “a language for communicating with mice” — taking concurrency from Hoare’s CSP but making one decisive change: “channels are first-class objects,” which enables dynamic process creation and dynamic channel creation (Newsqueak). That change addresses what Pike identifies as CSP’s “main defect”: in Hoare’s original, channels could not be stored in variables, passed as arguments, or sent over channels, so “the communication structure must be fixed while writing the program,” which is why CSP papers are full of hardcoded examples like the first 1,000 primes or a 3×3 matrix (Cox, Bell Labs and CSP Threads). Alef, designed by Phil Winterbottom at Bell Labs and first appearing in 1992, applied the Newsqueak model to a full compiled systems language with C-like syntax, and distinguished two kinds of concurrent entity (proc and thread) (Alef; Cox). Alef shipped in the first and second editions of Plan 9.

Why it did not win. Alef was abandoned during development of Plan 9’s third edition, and Pike’s explanation is a two-item list: it lacked “automatic memory management” — he and others urged Winterbottom to add garbage collection — and maintaining a language variant across multiple architectures proved “too difficult to maintain” (Alef). An MIT operating-systems lecture on Plan 9 records the same verdict more bluntly: a new programming language is “convenient, but difficult to maintain,” Alef was retired when its author Winterbottom stopped working on Plan 9, and the “good ideas transferred to C library plus conventions” (MIT 6.828, Plan 9). That is what happened: libthread made Alef’s concurrency available to C programs and allowed existing Alef programs, including Acme, to be translated, after which the Alef compilers were retired (Cox). The ideas then travelled — Newsqueak’s model was developed further in Alef, Limbo, and Go, with Pike and Thompson placing CSP at the center of Go’s concurrency support (Newsqueak; Cox).

Does the reason still apply? This is the cleanest case of a barrier that agent authorship attacks directly. The stated killer was not that Alef was hard to use but that it was expensive to maintain — one compiler per architecture, one person, no GC. Compiler maintenance, backend porting, and runtime work are large-volume, well-specified, heavily testable engineering, which is the most credible category of agent contribution to language infrastructure. The historical calculus “we cannot afford to keep a language alive, so let us reimplement its ideas as a C library and conventions” is exactly the trade that machine labor makes cheaper, and it suggests more small languages surviving rather than dissolving into libraries. What does not change: the missing GC was a design decision with real consequences, “good ideas transferred to a library” remains the efficient outcome when the idea is expressible as an API, and a language whose survival depends on one author’s continued interest has a governance problem no tooling fixes.

Limbo (1995) — Load-Time Type-Checked Modules on a Portable VM

The idea. Limbo was designed at Bell Labs by Sean Dorward, Phil Winterbottom, and Rob Pike, first appearing in 1995 as the application language for the Inferno operating system (Limbo). It inherits Alef’s typed-channel concurrency — send and receive block until a matching partner appears, and alt selects randomly but fairly among ready channels, with spawn creating a process that shares memory except for its own stack, preemptively scheduled by the Inferno kernel — and adds two mechanisms Alef lacked. First, memory management: automatic garbage collection frees objects when the last reference disappears, with non-cyclic structures getting “instant free,” i.e. deterministic prompt reclamation rather than deferred collection. Second, and more distinctive, a module system where types are checked twice: at compile time and again when modules are loaded. Each source file compiles to machine-independent byte code in a .dis file executed by the Dis virtual machine; modules are always loaded dynamically at runtime via a load operator that fetches the code and performs run-time type checking, and multiple instances of the same module type can run simultaneously with different implementations (Kernighan, A Descent into Limbo). That combination — a nominal module type checked at load time, with implementations swappable behind it — is a statically typed answer to dynamic loading that neither C’s dlopen nor the JVM’s classloaders quite match.

Why it did not win. Limbo’s fate was bound to Inferno’s: it is the language for writing Inferno applications, historically developed at Bell Labs and now maintained by Terzarima Systems and the Inferno64 project (Limbo). Inferno was a commercial distributed-OS play that lost to the web, and a language that exists to program one operating system inherits that operating system’s market share exactly. Limbo did better than Alef by any measure — GC, a portable VM, a coherent module story, Kernighan writing the tutorial — and it still could not escape its host. The concurrency ideas escaped instead, into Go.

Does the reason still apply? Mostly not, because the barrier was platform coupling rather than any property of the language, and platform bets are decided by markets, not by authorship. But one Limbo mechanism deserves revival on agent-era grounds: load-time re-checking of module types against a nominal interface is a runtime-enforced contract at the plugin boundary, which is the exact guarantee you want when the code on the other side of an interface was generated, downloaded, or hot-swapped rather than reviewed and linked. Modern systems achieve something similar with WebAssembly component interfaces, which is a strong hint that the idea was right and early. What does not change: a bytecode VM imposes performance and deployment costs, and prompt refcount-based reclamation has the throughput profile it has regardless of who writes the source.

Lua (1993) — One Data Structure, Mechanisms Not Policy

The idea. Lua was born in 1993 at Tecgraf, the Computer Graphics Technology Group of PUC-Rio in Brazil, created by Roberto Ierusalimschy, Luiz Henrique de Figueiredo, and Waldemar Celes to replace two earlier in-house languages (DEL and SOL) used for Petrobras applications; the first implementation was complete by July 1993, Lua 1.0 was never publicly released, and Lua 1.1 was published as source by FTP in July 1994 (Ierusalimschy, de Figueiredo & Celes, The Evolution of Lua). Its defining decision is radical data-structure minimalism: tables are the sole data-structuring mechanism — first-class associative arrays that accept any value as a key and store any value — so records are tables with string keys, arrays are tables with natural-number indices, and sets, lists, objects, classes, and modules are all tables by convention. Sugar makes this pleasant rather than tedious: t.x is t["x"], and foo{...} is foo({...}), which produces the language’s most distinctive trick — procedural data files, where a file that looks like a declarative data format is actually executable Lua and constructs like article{...} are function calls. Extensibility arrived in stages: global fallbacks in Lua 2.1, tag methods keyed by (event, tag) pairs in 3.0, and metatables with metamethods such as __index in 5.0 — ordinary Lua tables whose fields define behavior. The result is user-defined object systems and inheritance without any built-in class model, which the authors summarize as “Lua provided mechanisms, not policy” (Ierusalimschy et al.).

Why it did win — and where it did not. Lua is the success case, and the reasons are instructive because they are the exact inverse of every failure in this dossier. It was embeddable in C with a tiny runtime, so adopting it cost nothing architecturally; it solved an immediate problem for a paying industrial customer; it imposed no paradigm, so each community built its own; and it spread into robotics, image processing, text editors, Ethernet switches, bioinformatics, finite-element packages, web development, and games (Ierusalimschy et al.). What Lua did not win is the general-purpose application-language market, and the reason is the flip side of its design: one data structure and no policy means no static types, no module conventions until late, no standard library depth, and a tooling story built by each embedder.

Does the reason still apply? Lua’s agent-era position is genuinely double-edged. The embeddability argument gets stronger — a small, sandboxable, fast interpreter is the natural target for machine-generated glue and configuration-as-code, and Lua’s procedural data files are a better answer to “configuration needs a little logic” than the templating disasters the industry actually adopted. But “mechanisms, not policy” is a human-centered virtue: it works because a small expert community can agree on conventions. Machine-generated code across many independent modules with no enforced policy produces convention drift that no reader can track, which argues that the agent era favors Lua’s size and Dhall’s rigidity rather than Lua’s permissiveness. What does not change: dynamic typing gives a verifier almost nothing to check, and the absence of a large standard library shifts work to synthesis with no static guarantee that the synthesized parts agree.

Forth (1970) — A Language That Is Its Own Implementation

The idea. Forth was developed by Chuck Moore, beginning at the Smithsonian Astrophysical Observatory in 1958 with a four-word interpreter core (WORD NUMBER INTERPRET ABORT) and carried through SLAC (1961), freelance work, Mohasco (1968), and NRAO (1971); it had no name until the end of the 1960s, and in 1968 the interpreter file was labeled FORTH for “4th (next) generation software,” shortened because the host operating system allowed only five-character filenames (Moore, The Invention of Forth). It first appeared publicly in 1970 on the IBM 1130, and Moore and Elizabeth Rather formed FORTH, Inc. in 1973, porting Forth systems to dozens of platforms (Forth). The language is “words separated by spaces,” combined to construct new words, with an implicit data stack passing parameters between words in reverse Polish notation — 25 10 * 50 + — and a separate return stack holding return addresses to support nesting. INTERPRET calls WORD to read space-delimited input and NUMBER to convert unrecognized tokens, with ABORT handling errors by asking the user what to do. Definitions live in a linked dictionary: CREATE builds an entry holding a link to the previous entry, a count and first three characters, code to execute, and parameters; compilation stores dictionary addresses rather than source text, and indirect-threaded code sequences through definitions via an address interpreter — on the PDP-11, NEXT was a two-word macro, : NEXT IP )+ W MOV W )+ ) JMP ;. Control flow (IF/ELSE/THEN, DO/LOOP) and even : and ; are themselves words, so the language has essentially no syntax distinct from its own extension mechanism (Moore).

Why it did not win. Forth achieved “remarkable acceptance where efficiency is valued” (Moore) and retains “a niche in astronomical and space applications”; it was popular on early-1980s microcomputers because it fit in very little memory, and the very ease of implementation produced many incompatible variants (Forth). That last point is the self-limiting mechanism: a language so cheap to implement that everyone implements their own has no portable ecosystem. Its deeper barrier is cognitive and unusual in this dossier — reverse Polish with an implicit stack means a word’s meaning depends on invisible context established by preceding words, so Forth code is exceptionally hard to read without mentally simulating the stack, and its extreme extensibility means every large Forth program is written in a private dialect. Hardware also moved against it: traditional disk-block storage “has become rare since the mid-1990s” (Forth), and cheap memory removed the argument that justified the tradeoff.

Does the reason still apply? Forth is the entry where the agent-era verdict is most clearly negative, and it is worth being blunt. Its costs were never about the labor of writing — Forth is famously terse to write — they were about legibility and about a fragmented ecosystem of private dialects. Machine authorship makes both worse: if agents write the code and humans read it, an implicit-stack notation whose meaning depends on non-local context is the worst possible surface, and the ability to redefine the language per project turns from a power feature into an auditing nightmare. Forth’s genuinely durable contributions are elsewhere: interactive incremental development against live hardware, and the insight that a language can be its own metalanguage — which survives as Lisp macros, Zig’s comptime, and Nim’s macro system rather than as Forth.


Transactional, Logic, and Relational Semantics

The languages here separate what from how, and their common failure was that the “how” leaked back in — through cuts, modes, determinism annotations, or performance tuning — until the declarative promise was compromised. Prolog’s history also demonstrates a failure mode absent elsewhere in this dossier: an idea can be destroyed by partial success, as its distinctive capabilities are absorbed piecemeal into systems that solve narrower problems better. The agent angle is unusually interesting here because search-based, nondeterministic, “specify the constraints” programming is closer to how agents are prompted than to how humans code.

Prolog (1972) — Logic as a Programming Language

The idea. Prolog began with a project Alain Colmerauer established in summer 1970; a preliminary Prolog was implemented in late 1972 and the definitive version designed and implemented in 1973 with the interpreter completed that December. Philippe Roussel invented the name in Marseilles in 1972 as an abbreviation of “PROgrammation en LOGique,” and wrote Prolog 0 in Algol-W, with Prolog I developed in Fortran at the end of 1973 by Battani, Meloni and Bazzoli; Kowalski’s collaboration with Colmerauer produced the 1972 system on which it rests (Colmerauer & Roussel, The birth of Prolog; Körner et al., Fifty Years of Prolog and Beyond). The mechanism converts Robinson’s resolution theorem proving into a programming language via ordered clauses and linear resolution: the leftmost literal of the current resolvent unifies with the head literal of a program clause, the most general substitution is applied to the remaining literals, clauses are tried in the order written, literals execute left to right, and nondeterminism is handled by backtracking that stores only one branch of the search tree at a time. The efficiency compromise was deliberate and consequential — restricting unification to the head literals of ordered clauses sacrificed completeness, though the strategy turned out to be complete for Horn clauses: “we had discovered the strategy which is complete when only Horn clauses are used” (Colmerauer & Roussel). Retained impurities included the cut operator ! to prune search, meta-calls through variables, and dynamic clause assertion and retraction. Colmerauer’s difference lists and extra grammar parameters produced executable grammars for language processing (Körner et al.).

Why it did not win. Three mechanisms, all documented. First, dissemination without stewardship: “Prolog was not really distributed; rather it ‘escaped’ and ‘multiplied’” through copied implementations at Edinburgh, Budapest, Warsaw, Toronto, Waterloo, Montreal, Paris and Leuven (Colmerauer & Roussel), which produced implementations that “depart from each other in significant ways” and severe code-portability problems; DEC-10 Prolog was “deeply tied to its computer architecture” and “inherently not portable” to 32-bit systems, and the ISO standard required changes “not always backwards compatible,” delaying adoption. The retrospective names a fragmented community, a small user base, weak stewardship, limited tooling, and the perception of Prolog as “old” or merely academic as continuing threats (Körner et al.). Second, the killer app that failed: Japan’s Fifth Generation Computer System project (1982–1992) “could’ve been Prolog’s killer app,” and its failure helped take Prolog down with it — compounded by the project’s shift from Prolog toward committed-choice languages, which arguably reduced its impact (Kaplan, Why did Prolog lose steam?; Körner et al.). Third, and most interesting, death by absorption: Prolog’s declarative uniqueness was “chipped away” as its useful parts migrated elsewhere — SQL took enough declarative data programming to “outcompete Prolog-derived databases,” production-rule systems like Jess and Drools took expert-system and business-logic rules, and LINQ brought SQL-like declarative querying into C# including over in-memory arrays (Kaplan).

Does the reason still apply? The fragmentation and portability problems were maintenance-and-stewardship costs, which are the most agent-tractable category, and the “perception of being old” is a human hiring signal with no machine analogue. More substantively, unification and backtracking search are a natural target for machine-generated code: stating relations and letting the engine search is closer to a specification than to an implementation, and an agent that can generate a relational specification plus a test oracle gets much of Prolog’s original promise with modern tooling. What does not change: the cut operator and the order-sensitivity of clause selection mean real Prolog programs encode control flow in their ordering, so “declarative” was always partly a fiction that an author must understand; backtracking’s performance profile is what it is; and the absorption dynamic is permanent — if the useful 20% of an idea is already in SQL and LINQ, nobody adopts the remaining 80%.

Mercury (1995) — Types, Modes, and Determinism as Compiler Contracts

The idea. Mercury’s first version was built by Fergus Henderson, Thomas Conway and Zoltan Somogyi at the University of Melbourne under Somogyi’s supervision, released on 8 April 1995 (Mercury); the execution algorithm was designed in October 1993, the compiler first compiled itself on 24 February 1995, and the first public beta (0.3) shipped on 18 July 1995 (Mercury motivation). It is a purely declarative logic language that keeps Prolog’s relational core while adding three static disciplines. Strong polymorphic types are the familiar part. Modes declare the instantiation direction of each argument, so append(in, in, out) and append(out, out, in) are distinct procedures of one predicate. Determinism annotations then classify each mode by solution count and failure behavior: det (exactly one solution), semidet (zero or one), multi (at least one, possibly more), nondet (zero or more), failure (fails without a solution), and erroneous (no call returns to the caller) — so append(in, in, out) is det while append(out, out, in) is multi and append(in, in, in) is semidet. The compiler infers determinism from calls, unifications, conjunctions, switches, disjunctions, if-then-elses and negations, checks declarations against inference (a too-strong declaration is an error, a too-weak one a warning), permits omission on local procedures but not exported ones, and uses the solution-count assertions for optimization — including potentially optimizing away goals that could throw, trace, or loop forever. Committed choice (cc_multi, cc_nondet) permits multiple logical solutions while committing operationally to the first, with promise_equivalent_solutions [X, Y] (G) letting the programmer assert that all solutions are equivalent (Mercury determinism). Purity is enforced rather than encouraged: there is no cut and no imperative I/O, with I/O expressed by threading a dummy world value through linear types, and impure code permitted mainly for foreign calls and required to be explicitly marked (Mercury).

Why it did not win. Mercury’s own motivation page identifies the barriers it was built to overcome — Prolog compilers “detect many fewer errors” than imperative ones and leave programmers debugging with “minimal debugging support,” which “significantly reduces productivity,” while implementations are “significantly slower” than C so performance-sensitive designers “do not even consider logic programming languages” (Mercury motivation). Mercury fixed both — its type, mode and determinacy checkers caught “several hundred bugs” in its own compiler, and it benchmarked from roughly twice as fast as Aquarius Prolog to 20–36× faster than bytecode Prolog systems — and still did not break out, which is the informative part. The price of those guarantees is three interlocking annotation systems on every exported predicate, purity that makes some ordinary constructs harder to express (the docs note a switch over multiple options with a default is awkward), and a compilation model targeting C for portability. Documented use is the compiler itself, the Prince XML formatter, and the ODASE platform (Mercury).

Does the reason still apply? Mercury is one of the top agent-era candidates in this dossier, for a precise reason: mode and determinism declarations are exactly the class of annotation that is mechanically derivable, locally checkable, and hated by humans. They are pure bookkeeping with immediate compiler payoff — better error detection and better generated code — and a human resents writing three declarations per predicate while an agent does not. Determinism annotations are also outstanding review artifacts: is det on a signature tells a reader more about a function’s behavior than most type signatures do. What does not change: the manual’s own admission that “perfect determinism inference is an undecidable problem,” so an agent will also sometimes be unable to prove what it believes; enforced purity is an expressiveness restriction that reshapes program architecture; and the ecosystem is what it is.

Curry (1990s) — Functional Logic Programming with Needed Narrowing

The idea. Curry was produced not by one designer but by “an international initiative of researchers in the area of functional logic programming,” with the explicit goal of providing “a common platform for the research, teaching, and application of integrated functional logic languages,” its design discussed on the Curry mailing list and its report edited by Michael Hanus (Curry; Hanus, Functional Logic Programming: From Theory to Curry). It merges the two paradigms at the semantic level rather than by embedding one in the other. From functional programming it takes algebraic data types, polymorphic typing with inferred signatures, higher-order functions, and demand-driven (lazy) evaluation; from logic programming, nondeterministic operations that “can return different values for the same input,” free variables denoting unknowns that get instantiated with concrete values, partial data structures, built-in search, and flexible nondeterministic pattern matching with user-defined functions (Curry). The semantics is the contribution: declaratively, CRWL (constructor-based conditional rewriting logic) with non-strict operations and call-time choice for nondeterministic operations; operationally, needed narrowing extended with generalized definitional trees, sharing, and residuation — narrowing selectively evaluates only demanded arguments and nondeterministically instantiates free variables with constructors, while sharing ensures a nondeterministic argument makes one shared choice rather than diverging per use, and residuation handles external operations and conditionals (Hanus). The result is a claim to both soundness/completeness and optimal evaluation on inductively sequential programs — the technical prize that motivated the whole enterprise.

Why it did not win. Curry’s structure is its limit: a design by international committee via mailing list, with several competing implementations as its “most prominent representatives” — PAKCS, KiCS2, and MCC (Curry) — which distributes effort exactly where concentration is needed. Hanus notes the language “has been also used to develop larger applications” and calls it “currently the only functional logic language” combining strong foundations with larger applications, while identifying implementation complexity for encapsulated search, concurrency, fair scheduling, parallelism, and advanced type systems as open difficulties (Hanus). The user-facing problem is subtler and probably decisive: call-time choice, sharing, and needed narrowing interact in ways that make a program’s operational behavior genuinely hard to predict, which for a working engineer means unpredictable performance and hard-to-localize bugs.

Does the reason still apply? The optimistic case is real: nondeterministic operations plus free variables plus built-in search let a programmer state a problem and get a solution, which is close to how agents are instructed, and lazy functional syntax makes the result far more readable than Prolog. An agent is also unbothered by having to reason about needed-narrowing semantics to predict behavior — it can simply test. What does not change, and is the honest verdict: unpredictable operational behavior is a reading and debugging cost, and reading/debugging is precisely the part that stays human. Search-based semantics also have an inherent performance profile, multiple partial implementations remain a fragmentation cost, and the open problems Hanus lists — encapsulated search, fair scheduling, parallelism — are research problems, not labor problems.

Verse (2023) — Deterministic Functional Logic Programming with Transactions

The idea. Verse is Epic Games’ language for Fortnite and its metaverse ambitions, built on the Verse calculus (VC) described at ICFP 2023 by Lennart Augustsson, Joachim Breitner, Koen Claessen, Ranjit Jhala, Simon Peyton Jones, Olin Shivers, Guy L. Steele Jr., and Tim Sweeney, with the authors noting their motivation is “practical rather than theoretical” (Augustsson et al., The Verse Calculus). VC is a core calculus for deterministic functional logic programming, and the word deterministic is the whole contribution: rather than nondeterministic search over time, VC reifies logical variables, unification, and choice into the term itself and replaces search with a deterministic tree of successful results — choices are “laid out in space” in the syntax, order is preserved, duplicates retained, and failure simply produces no values, with one{e} returning the first value and all{e} collecting all results into a tuple; semantics is a small-step rewrite system, “by applying successive rewrites,” and the authors prove confluence for well-behaved terms. The second mechanism is transactional: “software transactional memory is at the core of Verse,” with computation classified by an effect system of exclusive effects — converges (terminates), computes (pure), varies (reads random or non-constant state), transacts (mutates, and therefore can roll back), and no_rollback (side effects that cannot be undone) — written in function signatures as TwiceTransacts(F()<transacts> : void)<transacts> : void (McKenna, Type system of Fortnite’s Verse language). The design intent is to make it easier to write software spanning many servers while handling shared game state correctly: speculative mutation that can be rolled back is a coherent answer to concurrent world-state updates.

Why it has not won (yet). Verse has an asset no other language here possessed — a captive audience with over 1,000 projects created per minute on public release day (McKenna) — and the limitations are self-imposed and real. Users cannot define their own effects or effect handlers; effect polymorphism is not supported, so a generic Twice(e : exclusive_effect, ...) cannot be written; converges functions cannot currently be written except in native code; explicit dependent types are prohibited; higher-kinded types and abstraction over type constructors are blocked, forcing separate implementations for lists, maps, arrays and optionals; and the compiler and tooling are closed source (McKenna). On the theory side, the authors state they have not formalized or proved a normalizing evaluation strategy, VC’s determinism “pretty much rules out laziness” and parallel first-come-first-returned search, and logical completeness is “well out of reach,” especially with arithmetic (Augustsson et al.).

Does the reason still apply? The transacts / no_rollback distinction is the single most underrated idea for the agent era in this dossier. The core problem with a machine performing effectful work is not that it computes the wrong value but that it takes an irreversible action, and Verse makes reversibility a type-level property that the compiler tracks and propagates through signatures. That is the primitive an agent runtime actually needs: speculate freely within transacts, require explicit escalation to touch no_rollback. Determinism is the second gift — a deterministic result tree makes generated code reproducible and testable in a way nondeterministic search is not. What does not change: closed-source tooling and single-vendor control are the classic risk this dossier documents repeatedly; the absence of effect polymorphism and higher-kinded types forces duplicated code that no authoring change makes correct; and STM has a real runtime cost.


Effect Systems

Algebraic effects are the youngest idea here and the one currently most likely to reach the mainstream on its own merits — the lineage from Plotkin and Power’s algebraic treatment of computational effects through Plotkin and Pretnar’s handlers to Leijen’s row-typed implementation is now visible in OCaml 5’s effect handlers, Java’s structured concurrency debates, and every async/await design. The mechanism is a single generalization: exceptions, state, generators, async/await, nondeterminism, and dependency injection are all one construct — an operation whose continuation is handed to a handler that may resume it zero, one, or many times. The historical barrier was not adoption resistance but implementation: efficient compilation of multi-shot continuations and inference of effect rows without drowning the programmer in variables.

Koka (2014) — Row-Polymorphic Effect Types with Inference

The idea. Koka is Daan Leijen’s language, with the row-polymorphic effect-types design published in 2014 (Leijen, Koka: Programming with Row-Polymorphic Effect Types) and the algebraic-effects treatment as MSR-TR-2016-29 (Leijen, Algebraic Effects for Functional Programming). Its defining property is that effects are inferred, not declared: Koka “automatically infers and tracks the effect of every function in its type,” so a function type is arguments, effect, and result — fun sqr : (int) -> total int, fun divide : (int,int) -> exn int, fun turing : (tape) -> div int, fun print : (string) -> console (). Effects compose as rows: <div,exn,ndet> is a concrete row, <div|e> extends a row variable, alias pure = <div,exn>, and polymorphic functions carry the caller’s effect through — map : (xs : list<a>, f : (a) -> e b) -> e list<b> (Koka book). Handlers supply the semantics. An effect declares operations, effect raise { ctl raise(msg : string) : a }, and a handler dynamically binds them over a scoped block, with ctl raise(msg) 42. ctl operations receive an implicit resume and may resume zero, once, or many times — which is how the same construct expresses exceptions (never resume), state (resume once), and nondeterminism or generators (resume repeatedly). fun operations are tail-resumptive (the common, efficient case), val operations are dynamically bound values, and mask<eff> and override control which nested handler receives an operation. Performance is addressed by Perceus: optimized reference counting with reuse analysis and tail-recursion-modulo-cons, so unique data is updated in place and shared data copied, targeting “within 2x of the performance of C/C++” (Koka book). The 2016 work shows algebraic effects generalizing exception handling, state, iterators, and async-await, with inference via “extensible effect rows using scoped labels” and efficient compilation to JavaScript, JVM and .NET through a type-directed selective CPS translation (Leijen 2016).

Why it has not won. Koka’s own documentation states that v3 is “a research language…not ready for production use,” with missing async libraries and package management, and FBIP still “active research”; it also concedes that the effect semantics are powerful but potentially complex (Koka book). That is the honest summary: the theory is mature, the ecosystem is not, and the conceptual load of multi-shot continuations is genuinely high — a handler that resumes twice produces control flow most engineers have never had to reason about.

Does the reason still apply? Effect inference is the crucial design detail for the agent era, and it cuts in a favorable direction: because Koka infers effects rather than requiring declarations, the annotation-cost question largely disappears for author and agent alike, and what remains is a machine-checked summary of what every function can do. That artifact is enormously valuable when reviewing generated code — -> total int is a proof that a function cannot print, diverge, throw, or mutate, which is a far stronger claim than any type signature in a mainstream language. For agent safety specifically, an inferred effect row is a capability audit computed by the compiler rather than asserted by the author. What does not change: multi-shot resumption remains hard for humans to read, which matters more as reading dominates; efficient compilation of general handlers is still an implementation research problem with real costs; and missing async libraries and package management are ecosystem debts.

Eff (2012) — Algebraic Effects and Handlers as a Language

The idea. Eff was built by Andrej Bauer and Matija Pretnar at the University of Ljubljana; the tutorial is by Pretnar, acknowledging Bauer and Alex Simpson, with the foundational paper Programming with Algebraic Effects and Handlers appearing in 2012, which treats effects as algebraic operations and handlers as homomorphisms from free algebras, and makes both effects and handlers first-class so that new effects can be defined, existing effects combined, and delimited-continuation techniques used (Bauer & Pretnar, Programming with Algebraic Effects and Handlers; Pretnar, An Introduction to Algebraic Effects and Handlers). Eff’s value is that it exhibits the mechanism in its bare, unsugared form. Effects are named operations — get, set, read, print, raise, decide, fail — and an operation call carries a parameter, a result binder, and an explicit continuation: op(v; y. c), meaning “perform op with v, bind the result to y, continue as c.” A generic effect hides the trivial continuation, op = fun x → op(x; y. return y). A handler is a record of clauses, handler { return x → cr, op1(x; k) → c1, ..., opn(x; k) → cn }, applied by with h handle c; each clause receives the parameter and the captured continuation k, and decides whether, how often, and in what order to invoke it — with the continuation implicitly re-handled, so recursion through the handler is automatic. Operations with no matching clause propagate outward: with h handle op(v; y. c) → op(v; y. with h handle c). The canonical demonstration of the power this grants is a handler that reverses output order simply by sequencing the continuation before the effect: reverse = handler { print(s; k) → k (); print s }. Types separate values from computations, with computation types carrying effect rows A ! {op1, ..., opn}, handlers typed as transformations C ⇒ D, and operation signatures op : A → B (Pretnar).

Why it did not win as a language. Eff was explicitly a research vehicle for an idea, and the idea travelled while the language did not — implementations now exist “as independent languages and libraries,” including a multicore branch of OCaml (Pretnar), which is the outcome a research language should want. Its stated limitations are about precision rather than practicality: effect sets are over-approximations recording no “number of occurrences, passed parameters, or order of operations,” and operations that escape all handlers simply do not reduce — choose (3, 4) is stuck at decide with no handler, which is a runtime failure mode arising from a static type system that tracked the effect but not its handling.

Does the reason still apply? Eff’s case is largely settled in the affirmative: the idea won by migration into OCaml and into the broader design conversation. What agent authorship adds is a reason to prefer explicit handlers over ambient effects in generated code, because a handler is an interposition point — if every effect in a generated program must pass through a handler the human installed, the human retains control over IO, network, and mutation without reading the body. That is a substantially better safety architecture than post-hoc sandboxing. What does not change: effect-set over-approximation means the type tells you what could happen, not what does, so it bounds rather than describes behavior; unhandled operations failing at runtime is a genuine soundness gap that must be closed by the type system, not by diligence; and reasoning about a handler that invokes its continuation multiple times remains a hard reading problem.

Frank (2016) — Abolishing the Distinction Between Functions and Handlers

The idea. Frank was designed by Sam Lindley, Conor McBride and Craig McLaughlin, presented as Do be do be do in 2016, as “a strict functional programming language with a bidirectional effect type system” built around a variant of Plotkin and Pretnar’s effect-handler abstraction, with command interfaces tracked statically (Lindley, McBride & McLaughlin, Do be do be do). Its contribution is a unification: Frank removes the separate effect-handling construct by generalizing functional abstraction itself, so that “a function is simply the special case of a Frank operator that interprets no commands.” Operators may be multihandlers, interpreting commands from several sources simultaneously — which is what a handler cannot do in the conventional formulation, where handling is inherently about one computation. The design goal is to preserve “the direct style of functional programming with values,” i.e. to make effectful code look like ordinary code rather than like monadic plumbing. The second contribution is ergonomic and important: Frank’s effect polymorphism “avoids mentioning effect variables in source code,” achieved by propagating “an ambient ability inwards” rather than accumulating unions of potential effects outwards. That inverts the usual inference direction and eliminates the notational tax — effect-polymorphic signatures cluttered with e variables — that makes row-based effect systems look intimidating. Frank elaborates into functions, case expressions, and unary handlers in Core Frank, which has a sound small-step operational semantics (Lindley et al.).

Why it did not win. Frank is a research language and its authors describe it as such: “programming with effects and handlers is in its infancy,” and the paper is “an exploration of future possibilities,” particularly in combining effects and handlers with other rich type-system forms (Lindley et al.). There is no ecosystem claim to evaluate. The structural difficulty is that its central move — collapsing functions and handlers into one construct — is elegant but unfamiliar in a way that resists incremental adoption: it cannot be added to an existing language as a library or an extension, because it changes what a function is.

Does the reason still apply? Frank’s “ambient ability” inference is the most agent-relevant detail here, and it is an argument about reading rather than writing. The standard objection to effect systems is that signatures become unreadable — map : (xs : list<a>, f : (a) -> e b) -> e list<b> is fine, but real polymorphic code accumulates variables. Frank shows this is a presentation choice, not an inherent cost, which matters most in a world where humans read far more code than they write. That said, the honest assessment is that Frank’s barrier was never annotation labor — it was that the idea needs a language built around it, and building and populating languages is the part agent authorship helps least with relative to the ecosystem already in place. Expect Frank’s inference technique to show up inside other languages’ effect systems rather than Frank itself gaining users.

The idea. Links was created by Ezra Cooper, Sam Lindley, Philip Wadler and Jeremy Yallop at Edinburgh, with the Links: Web Programming Without Tiers paper appearing in 2006–2007 and the initial development effort funded from 2005 to 2009; the core team has since included James Cheney, Simon Fowler, Vashti Galpin, Daniel Hillerström, Wilmer Ricciotti and Wenhao Tang alongside Lindley and Wadler (Cooper, Lindley, Wadler & Yallop, Links: Web Programming Without Tiers; Links). The mechanism is compilation from “a single source” to all three tiers of a web application: JavaScript for the browser, bytecode for the server, and SQL for the database, eliminating the “impedance mismatch problem” between Java, HTML/CSS, JavaScript and SQL (Links). Two further details matter. Links supports rich clients in “‘Ajax’ style” and concurrent processes with statically typed message passing, so client–server communication is type-checked end to end rather than at a JSON boundary. And session state is preserved in the client rather than the server, which the authors present as the source of Links’s scalability and contrast explicitly with Java Servlets and PLT Scheme. Client-side concurrency in JavaScript and the transfer of computation between client and server are both implemented by translation into continuation-passing style (Cooper et al.) — which links this entry to the effects cluster, since CPS is the same machinery that makes handlers work, and Links’s later research direction runs through effect handlers.

Why it did not win. Links stated no adoption barriers of its own, and the structural explanation is straightforward: it required replacing the entire web stack simultaneously — language, server, client, and query layer — at a moment when the industry was investing heavily in each layer separately. The tierless promise is also a specific kind of bet that lost: the industry solved the same impedance mismatch with typed API boundaries and code generation (GraphQL, OpenAPI, tRPC, ORMs) rather than with one language, accepting three languages plus generated glue over one language plus a new runtime. That is a cultural and network-effect outcome, not a technical verdict.

Does the reason still apply? Links’s diagnosis has aged better than its solution, and the agent angle is genuinely interesting: the impedance mismatch it targeted is maintenance work — keeping types consistent across client, server, and schema — and that is precisely what agents now do, by regenerating the glue. In effect, machine authorship delivers the benefit Links promised (one coherent typed view across tiers) while keeping the three-language architecture, which means the specific pressure that motivated Links is now relieved by tooling rather than by language design. The part that remains valuable and unadopted is the statically typed message passing across the network boundary and language-integrated query — the latter having escaped into LINQ, which Wadler’s group also studied. What does not change: the deployment story (a new server runtime) and the ecosystem cost of leaving JavaScript are untouched by authorship, and pushing session state to the client is a design tradeoff with real security implications regardless of who writes the code.


Regions, Linearity, and Ownership

This is the cluster with the most unambiguous happy ending: Cyclone’s ideas are in Rust, and Rust is mainstream. It is therefore the best available evidence for how these transitions actually occur — not by the original language gaining users, but by a successor stripping the research apparatus down to the subset that a working engineer will tolerate, then attaching it to a compelling application. Rust’s own history includes the counterexample: it removed typestate before 1.0 for reasons that are the purest statement of the “cognitive load on human programmers” barrier in this entire dossier, which makes it the single best test case for the agent-authoring thesis.

Cyclone (2001/2006) — Regions, Pointer Kinds, and Unique Pointers at the C Level

The idea. Cyclone was a joint project launched in 2001 between Trevor Jim at AT&T Labs Research and Greg Morrisett’s group at Cornell, with team members including Dan Grossman, Michael Hicks, and Nik Swamy; version 1.0 was released on 8 May 2006 (Cyclone; Goodwin, The Fascinating Influence of Cyclone). Its goal was a safe dialect of C retaining C’s “power and convenience” — same data representations, same performance class, easy interoperation. Two mechanisms carry it. First, pointer kinds stratify what C conflates: * is the ordinary pointer, @ is never-NULL, and ? is a fat pointer carrying bounds for pointer arithmetic with runtime bounds checking, complemented by NULL checks inserted before dereferencing nullable pointers, definite-assignment analysis, safe casts, tagged unions, pattern matching, and parametric polymorphism (Cyclone). Second, regions: every object lives in a typed region, pointer types carry region names (written int *`r with a backquoted region variable), region handles have type region_t<`r>, region polymorphism allows functions reusable across regions, a pointer is well formed only when its region name is in scope and live, and region subtyping follows an “outlives” relation. Lexical regions are scoped — region<`r> h; then rmalloc(h,sizeof(int)) — with deallocation determined by scope and no runtime checks. Dynamic regions use a key of type dynregion_t<`r,`H>: region h = open(k); checks at runtime that the region is live and grants access for the lexical scope, free_dynregion(k) reclaims it, and misuse throws. Unique pointers written τ *`U are unaliased, conceptually an existentially fresh region, created by malloc and freed by free(p), with copies destructive in the flow analysis, consumption by function calls unless marked __noconsume(1)__, and atomic swap syntax e1 :=: e2 for accessing uniques embedded in shared objects. Temporary aliasing uses alias<`r2> τ *`r2 temp = x; to treat a unique pointer as a pointer into a fresh lexical region for a block, with aliases forbidden from escaping. Reference counting is a region kind RC with alias_refptr and drop_refptr (Hicks, Morrisett, Grossman & Jim, Safe and Flexible Memory Management in Cyclone).

Why it did not win. Bluntly stated by a later observer: “Few have heard of Cyclone and almost no one has used it,” and after 1.0 “the developers moved on to other things,” with the team having had to work through complexity from linear logic, move semantics, and quantified types (Goodwin). The tooling died with the project — Cyclone is “no longer supported by its original developers,” and the reference tooling never supported 64-bit platforms (Cyclone). But the internal evidence on ergonomics is the most valuable data in this dossier, because the authors measured it: unique-pointer coding was initially “unusable” without alias and shared-object support and remained “somewhat tedious” even after; their alias-inference pass inferred 71% of the 66 alias statements needed in the MediaNet case study, leaving the remaining 29% to the programmer. The payoff was real: unique and reference-counted pointers improved MediaNet throughput by up to 42%, and gc+free used 128 KB versus 840 KB reserved memory and 8 KB versus 420 KB peak (Hicks et al.). So the tradeoff was: substantial measured performance and memory wins, in exchange for annotation work that the authors themselves called tedious and could only partially automate.

Does the reason still apply? This is the dossier’s clearest “yes.” The barrier was explicitly annotation tedium that inference could only partly eliminate — 71% automated, 29% human — and that residual 29% is exactly the work an agent absorbs. More than that, Cyclone’s history already proves the ideas were right: Rust cites Cyclone among its influences and adopted similar ownership, borrowing, and linearity techniques; Midori’s M# was Cyclone-influenced, and later C# features including slices originated there; Pony, Cone, D and Nim explored related ownership and region ideas (Goodwin). What did not survive into Rust is the part that was too annotation-heavy — explicit region names on every pointer type, dynamic regions with runtime keys costing 12 bytes of state, __noconsume attributes — and that is precisely the set of features worth revisiting now that the author does not mind typing them. What does not change: dynamic regions add runtime checks and can leak keys, region discipline constrains program structure (you must know your lifetimes), and dead tooling is dead.

ATS (2003) — Programming With Theorem Proving, Erased at Runtime

The idea. ATS is Hongwei Xi’s language, conceived around the end of 2002 with implementation beginning in early 2003, a working typechecker by summer 2003 and an interpreter by early 2004; it grew from Xi’s DML work (doctoral thesis under Frank Pfenning, defended December 1998) and the decisive design breakthrough came in summer 2004 when he incorporated “a form of theorem-proving based on linear logic” as the basis for imperative programming (ATS papers and history). ATS “unifies implementation with formal specification” by splitting the language into statics (types and specifications, inspired by Martin-Löf constructive type theory) and dynamics (programs), with a theorem-proving subsystem ATS/LF in which programmers construct proofs that implementations meet specifications — “a programmer-centric approach to program verification” where proofs and programs are built together and proofs are erased with “no run-time cost.” Dependent types are concrete: bool and int are dependent type constructors, so int(i) classifies only the integer i and string(n) strings of length n; interfaces relate arguments to results, fun g1int_add {i,j:int} (int i, int j): int (i+j); dependent datatypes encode invariants, with list(a, 0) empty and list(a, n+1) nonempty and list_length returning int(n); and dataprops encode specifications as propositions, e.g. MUL(m,n,p) and FACT(n,r). Linearity handles resources through views, which are linear propositions — T@L asserts “a value of type T stored at location L” — so pointer operations require proofs: ptr_get0 {l:addr} (pf: a @ l | p: ptr l) and ptr_set0 {l:addr} (pf: a? @ l | p: ptr l, x: a). Linear values are declared with viewtype and linear closures with -<cloptr1> (Introduction to Programming in ATS).

Why it did not win. The ATS book is unusually candid: the language is “syntax-rich and feature-rich” with a grammar “probably more complex than most existing programming languages,” and the book itself may be “rather dense”; ATS code “can be more verbose than C” due to “administrative” linear-proof code; closures, boxed tuples, references and dynamic allocation can require GC; and unsafe embedded C is not rigorously typechecked and is identified as a likely source of bugs (Introduction to Programming in ATS). Xi’s own history notes that predecessors were abandoned for related reasons — deCaml “has never been documented for public release,” and Xanadu’s dependent-type support was “very limited” and could not accommodate common C features (ATS papers). The offer was therefore: C-level performance with proof-carrying memory safety, at the price of a grammar more complex than C++ and code more verbose than C.

Does the reason still apply? ATS is the most dramatic instance of a barrier that machine authorship attacks head-on, because every stated cost is authoring cost. “Administrative linear-proof code” is the definition of work that should not be done by hand. A grammar more complex than any existing language is a human-onboarding problem, not a machine one. Verbosity relative to C is irrelevant if the verbose part is generated and erased. And ATS’s proof erasure means the entire apparatus costs nothing at runtime — so the language offers C performance plus memory-safety proofs, with the price paid entirely in a currency that has become cheap. What does not change, and is decisive for honesty: dense, proof-laden ATS source is very hard for a human to review, which is the wrong direction for a world where review is the bottleneck; the GC requirements for closures and boxed data are real; and unsafe embedded C remains an unchecked hole through which bugs enter regardless of how much proof surrounds it.

Clean (1987) — Uniqueness Types Instead of Monads

The idea. Clean has been developed by the Software Technology Research Group at Radboud University Nijmegen since 1987, originally as the Concurrent Clean System, under a Simplified BSD license; it shares referential transparency, list comprehensions, guards, higher-order functions, currying and lazy evaluation with Haskell and is syntactically very similar, with computation based on graph rewriting and reduction (Clean). Its distinguishing mechanism is the uniqueness type system, which handles mutable state and I/O where Haskell uses monads. Uniqueness attributes decorate types: * means unique, u: is an attribute variable, . an anonymous one, giving *File, u:a, u:[u:a]. A unique function argument guarantees private access at inspection time — reference count exactly 1 — so destructive update is permitted without violating referential transparency: fwritec :: Char *File -> *File consumes and returns a unique file, so WriteABC file = fwritec 'c' (fwritec 'b' (fwritec 'a' file)) performs in-place writes, while a non-unique argument permits read access only (freadc :: File -> (Char, File)). Attribute polymorphism preserves uniqueness through generic code (id :: u:a -> u:a, freadc :: u:File -> u:(Char, u:File)). Uniqueness propagates outwards: storing a unique object in a structure makes the structure unique, so head :: *[*a] -> *a generalizes to head :: u:[u:a] -> u:a. Restrictions are expressed as attribute inequalities — append :: v:[u:a] w:[u:a] -> x:[u:a], [v<=u, w<=u, x<=u, w<=x] — with substitutions invalid if they would produce non-unique ≤ unique. Sharing analysis labels references read-only or write-permitted, with shared or parallel references forced read-only, and unique arrow types like *(Char -> *File) prevent coercing a one-shot function into a reusable one (Clean 2.2 language report).

Why it did not win. The Clean report itself is the most damning source: uniqueness typing is described as “rather complex,” its interaction with higher-order types and constructor classes as “very complex,” and the higher-order combination as “far from trivial” and “incomplete”; unique data structures must be used “single threaded,” so programs may need restructuring; and destructive update is mainly useful for node-stored data such as arrays and files rather than for values generally (Clean 2.2 report). Structurally, Clean shipped a Windows-centric toolchain — the bundled IDE is for Microsoft Windows, ObjectIO is “only available on Windows,” and writing dynamics to files is Windows-only (Clean) — at the moment the functional-programming research community consolidated on Haskell, a syntactically near-identical language with monadic I/O, a committee behind it, and Unix-first tooling. Development has since slowed, though some researchers continue.

Does the reason still apply? Partly, and the decisive part does not move. Attribute annotations and inequality constraints are annotation cost, and an agent pays it happily — writing v:[u:a] w:[u:a] -> x:[u:a], [v<=u, w<=u, x<=u, w<=x] is a pure bookkeeping exercise. But the report’s own words identify a barrier that is not labor: the higher-order theory is “incomplete,” meaning there are programs the system cannot type no matter how carefully annotated, and “programs may need restructuring” to be single-threaded is an architectural demand. Meanwhile, the idea itself won elsewhere in a form the industry could digest — Rust’s affine types and ownership deliver the same in-place-update-without-aliasing guarantee, which is the strongest possible evidence that uniqueness was correct and Clean’s presentation of it was the problem. Windows-only libraries and a stalled ecosystem remain unaffected by who writes the code.

Alias Types and L³ (1999–2007) — Tracking Individual Memory Cells in the Type System

The idea. Alias Types were introduced by Frederick Smith, David Walker and Greg Morrisett at Cornell (technical report TR99-1773, October 1999), with L³ a later refinement by Morrisett, Ahmed and Fluet. The mechanism is more precise than regions: the type system tracks the shape of the store with aliasing constraints and tracks concrete locations through singleton pointer types. ptr(ℓ) is the type containing exactly one value — the pointer to location ℓ. A store fragment is {η ↦ τ} where η is a concrete location or location variable, and constraint collections combine with a non-idempotent join C1 ⊕ C2, so ϵ ⊕ {ρ ↦ ⟨int⟩} describes an integer cell at ρ plus arbitrary other store ϵ. The linearity is the crux: an ordinary {η ↦ τ} constraint guarantees the location is not aliased by another location, which permits safe deallocation and — crucially — changing the type stored at a location despite the existence of pointers to it. malloc x, ρ, n; yields {ρ ↦ ⟨junk₁,…,junkₙ⟩} with x : ptr(ρ); an assignment updates the constraint from {ρ ↦ ⟨int, junk⟩} to {ρ ↦ ⟨int, ptr(ρ₂)⟩}; free v; rewrites {η ↦ ⟨τ₁,…,τₙ⟩} to {η ↦ junk}. Non-idempotence is what prevents alias duplication: {ρ₁ ↦ τ} ⊕ {ρ₂ ↦ τ} is not two copies of {ρ₁ ↦ τ}. Nonlinear constraints {η ↦ τ}ω may be freely duplicated but cannot be deallocated or used at varying types, with subtyping {η ↦ τ} ≤ {η ↦ τ}ω providing the one-way transition from unique to shared (Smith, Walker & Morrisett, Alias Types). L³ carries the same idea further: Morrisett, Ahmed and Fluet separate explicit first-class linear capabilities from freely duplicable pointers, which supports strong updates on shared mutable references, with freeze, thaw and refreeze operations that temporarily regain exclusive update capability for an unrestricted reference (Morrisett, Ahmed & Fluet, L³: A Linear Language with Locations).

Why it did not win directly. Alias Types was never intended as a user-facing language — it targeted typed assembly language, with the authors extending TAL and generating code for it from Popcorn, describing the integration as “quite straightforward,” while noting that bounded-quantification support was “not yet implemented” and recursive types remained future work (Smith et al.). That is the honest classification: it is the theory that made ownership work, developed as a compiler intermediate language, and it won by being absorbed. The reason no one programs in it is that per-location constraint tracking is an unreasonable amount of bookkeeping to expose to a human — the very precision that makes it powerful makes it unwritable, which is why Rust exposes lifetimes and the borrow checker instead, giving up per-cell precision for a discipline a person can hold in their head.

Does the reason still apply? This is the most interesting speculative case in the dossier precisely because the barrier was only bookkeeping volume. Alias Types is strictly more expressive than Rust’s borrow checker in one important respect — it permits strong updates, changing the type at a location while pointers to it exist — which is exactly the pattern Rust programmers work around with Option::take, enums, and unsafe code. If the reason mainstream ownership systems are coarser than the underlying theory is that humans cannot track per-location constraints, then a machine author changes the calculus: an agent can maintain constraint sets that a person cannot, which argues for exposing more precise ownership types rather than fewer. Two cautions. First, the constraints would still have to be read by reviewers, and ϵ ⊕ {ρ ↦ ⟨int, ptr(ρ₂)⟩} is not a readable function signature — so the plausible design is precise internal tracking with coarse published interfaces. Second, expressiveness gaps that were “future work” in 1999 (recursive types, bounded quantification) are research problems, not labor.

Rust’s Pre-1.0 Typestate (2006–2012) — The Barrier Stated Plainly

The idea. Rust began in 2006 as Graydon Hoare’s personal project, was officially sponsored by Mozilla in 2009, released 0.1 on 20 January 2012, and reached 1.0 on 15 May 2015 (Rust). Early Rust carried a typestate system alongside its types: a dedicated compiler pass that checked program-state properties including user-specified constraints, definite assignment, initialization, and must-return behavior, with language surface including check, if check, claim, pure, and constraint declarations, plus support for late initialization and early returns (Remove typestate, etc., rust-lang/rust#2178). Typestate is the natural companion to ownership: where ownership tracks who may access a value, typestate tracks what state it is in — file opened versus closed, connection handshaked versus not — turning protocol violations into compile errors. Rust today delivers ownership and affine types (every value has exactly one owner, values move or are borrowed, references carry tracked lifetimes verified by the borrow checker, with safe references non-null and always valid) but expresses state protocols only indirectly, through the typestate pattern of consuming self and returning a differently typed value (Rust).

Why it was removed. The April 2012 issue thread is the most quotable evidence in this dossier for the human-cognition barrier. brson observed that typestate “does a lot of things, most of which we don’t use” and was “the longest compiler pass, discounting trans.” catamorphism gave the decisive reason: constraints imposed too much cognitive burden, which explained why people did not use them despite potentially useful applications. nikomatsakis had not seen a typestate use that could not also be achieved with ordinary types, though he had caught a bug with it. Only the initialization-tracking portion was considered non-negotiable — pcwalton wrote “We definitely need init to stay,” suggesting typestate might be retained as “just our version of Flow.java,” and graydon said “at very least the init-predicate tracking” was needed because of “move operators and whatnot.” The code had “never been optimized,” and graydon cited incomplete portions, lack of recent attention, and lack of consensus. A DBC/contract-like replacement was floated — pcwalton suggested “DBC + QuickCheck” — with no concrete syntax proposed (rust-lang/rust#2178).

Does the reason still apply? No — and this is the cleanest natural experiment available. Typestate was not removed because it was unsound, uncheckable, expensive at runtime, or unimplementable. It was removed because humans would not write the constraints, plus a maintenance argument about an unoptimized compiler pass. Both reasons are specific to human authorship and human-scale maintenance capacity. An agent writing a file-handle API will happily annotate state transitions; a solver-checkable state protocol is a better review artifact than a comment saying “call open first”; and the class of bugs typestate catches (use-after-close, unhandshaked send, double-free-by-protocol) is exactly the class agent-written code produces when it loses track of a sequencing requirement. Note also that the ecosystem re-derived the idea by hand — the consuming-self typestate pattern and later work on retrofitting typestates into Rust show that demand never went away, only the willingness to pay the annotation cost. What does not change: compiler passes still cost compile time, and Rust’s own adoption history warns that instability is its own barrier — adoption slowed because Rust “radically changed from version to version,” and the “learning curve” was cited as the primary drawback in scientific-software adoption (Rust), which is a caution against assuming that more type-system machinery is free even when an agent writes it.


Synthesis: What Gets a Second Life, What Stays Niche, What Already Won

Tier 1 — Strong revival candidates, because the barrier was annotation labor

These are the ideas whose historical obstacle was, as documented above, humans declining to write machine-checkable declarations. The cost was measured in keystrokes and attention; the payoff accrued later, to someone else; and the check was local and automatic. Every one of those properties inverts under machine authorship, and in each case the source record names annotation burden explicitly rather than inviting inference.

  1. Dafny-style verification-aware programming. Loop invariants, modifies clauses, and ghost lemmas are annotation-plus-search against an automatic decision procedure; Dafny already discharges obligations “automatically, given sufficient specification,” and infers the shallow invariants while requiring the deep ones (Dafny). “Produce enough specification” is a task with a hard pass/fail signal.
  2. Mercury-style mode and determinism declarations. is det / is semidet are mechanically derivable, locally checked, immediately rewarded with better errors and better code, and tedious to write by hand (Mercury determinism).
  3. Rust-style typestate, restored. Removed for stated “cognitive burden” on constraint writers, not for any technical defect (rust-lang/rust#2178).
  4. Eiffel/SPARK-style executable contracts. Contracts that are both provable and runnable degrade gracefully when the prover stalls, and contracts are the ideal review artifact for code a human did not write (AdaCore/Thales).
  5. Cyclone’s unique pointers and explicit regions. The authors measured the barrier: alias inference automated 71% of needed annotations, leaving the rest “somewhat tedious” — in exchange for up to 42% throughput gains and order-of-magnitude memory reductions (Hicks et al.).
  6. ATS-style proof-carrying code with erasure. Every stated cost — grammar complexity, verbosity versus C, “administrative” proof code — is authoring cost, and proofs are erased at runtime (ATS).
  7. Object-capability plumbing. The stated barrier for Joe-E was that capability architecture is “unfamiliar to most programmers” and requires training, plus the large mechanical job of taming a library (Mettler et al.). An agent has no habits to unlearn, and taming is bulk mechanical review.
  8. Verse’s transacts / no_rollback effect distinction. Reversibility as a type-level property is the primitive an agent runtime most needs, and it is inferred or declared rather than proved (McKenna).
  9. Liquid-Haskell-style optional refinements. Comment-based, non-invasive, incrementally applicable to existing libraries, with no runtime effect (Vazou et al.).
  10. Pony’s reference capabilities. The documented reason people bounce off Pony is that reference capabilities and generics are “the hardest things to get a handle on” and some conclude there is “too much type system” (Pony) — a working-memory constraint, not a semantic one.

Tier 2 — Improved but still constrained, because a second barrier is not labor

Here the annotation half of the cost falls away and a second, harder cost remains — undecidability, expressiveness restriction, or runtime overhead. Expect partial adoption of the mechanism, not revival of the language.

  • Idris and Agda. Repetitive proofs are agent-tractable, but mandatory totality (Agda) restricts what may be written rather than how much must be typed, termination checking is undecidable, and dependently typed error messages remain a human-review problem (Agda; Brady).
  • Whiley’s constrained types. Subtyping decided by constraint implication means the typechecker is a solver, with timeout-shaped failures (Pearce & Groves).
  • Clean’s uniqueness types. The report’s own admission that the higher-order theory is “incomplete” and that programs “may need restructuring” is an expressiveness wall, not a labor wall (Clean 2.2 report).
  • Koka, Eff, and Frank. Effect inference already removes the annotation cost, so the residual barriers are efficient compilation of multi-shot continuations and the readability of handler control flow (Koka book).
  • Alias Types / L³. Strictly more expressive than Rust’s borrow checker (strong updates through aliases) and strictly less readable; the plausible outcome is precise internal tracking behind coarse published interfaces (Smith et al.).
  • Oz’s dataflow variables. A clean primitive for machine-generated concurrency, with a constraint-store runtime cost and no constituency (Van Roy et al.).
  • Newspeak’s no-globals, no-statics module discipline. Bounded blast radius is a superb property for agent-written code; the mutual-recursion awkwardness and hostility to static analysis are real (Bracha et al.).

Tier 3 — Stays niche regardless of who writes the code

  • Dhall and Bosque. Their costs are expressiveness and ecosystem, not authoring. Dhall’s own designer concedes non-Turing-completeness “does not provide many safety guarantees” and functions largely as a shibboleth (Gonzalez); Bosque removes loops, mutable state and reference equality with attendant performance and interop costs (Bosque). What survives is the normal form idea — reviewing generated configuration as flattened data is genuinely more valuable now.
  • Forth. The only entry where machine authorship makes things worse: an implicit-stack notation whose meaning depends on non-local context is the worst possible surface when humans read far more than they write, and per-project dialects become an auditing hazard (Moore).
  • Curry. Unpredictable operational behavior under call-time choice and needed narrowing is a debugging cost borne by humans (Hanus).
  • Links. Its diagnosis was right and the industry solved the problem another way; agents now regenerate the cross-tier glue that Links proposed to eliminate by language design (Cooper et al.).
  • Lua’s “mechanisms, not policy.” A human-scale virtue: it works because a small expert community agrees on conventions, and machine-generated code across many modules produces convention drift no reader can track (Ierusalimschy et al.).
  • Anything whose barrier was runtime, deployment, or platform. Limbo’s coupling to Inferno, Cobra’s .NET/Mono bet, Clean’s Windows-only libraries, Cyclone’s dead 64-bit-incapable tooling, and Verse’s closed-source compiler are all costs that authorship does not touch (Limbo; Cyclone; Clean).

Already quietly absorbed under other names

The dominant pattern in this dossier is not revival but absorption: the idea enters the mainstream stripped of its research apparatus, renamed, and attached to a compelling application, while the originating language dies.

IdeaOriginWhere it landed
Regions, ownership, unique pointers, non-null pointer kindsCyclone (Cyclone)Rust’s ownership/borrowing and affine types; Midori’s M# and thence C# slices (Goodwin; Rust)
Alias constraints, singleton location types, linear/nonlinear splitAlias Types, L³ (Smith et al.)The theory underneath every borrow checker
Uniqueness types enabling in-place update without aliasingClean (Clean 2.2 report)Rust’s affine types; Koka’s Perceus reuse analysis (Koka book)
Flow-sensitive typing with union/intersection/negation typesWhiley (Whiley)TypeScript narrowing and control-flow analysis
First-class channels, CSP with dynamic process/channel creationNewsqueak → Alef → Limbo (Newsqueak; Cox)Go’s goroutines and channels
Promises, eventual sends, turn-based single-threaded event loopE (Miller et al.)JavaScript promises and the event loop (Crockford was on E’s design team)
Isolation, let-it-crash, supervision treesErlang (Armstrong)Elixir/OTP; Akka; Orleans; container restart policies and circuit breakers
Algebraic effects and handlersEff, Koka, Frank (Pretnar)OCaml 5 effect handlers; async/await as a special case; generators
Declarative relational querying over in-memory and stored dataProlog, absorbed piecemeal (Kaplan)SQL, recursive CTEs, Datalog, LINQ, Jess/Drools rule engines
Language-integrated query across tiersLinks (Cooper et al.)LINQ; typed API codegen (GraphQL, OpenAPI, tRPC)
Contracts, assertions, invariantsEiffel (Meyer)assert everywhere; SPARK and JML in critical software; property-based testing as the empirical substitute Rust contributors reached for (“DBC + QuickCheck”, rust-lang/rust#2178)
Load-time type checking at a dynamic module boundaryLimbo (Kernighan)WebAssembly component interfaces
A language that is its own metalanguageForth (Moore)Lisp macros; Zig comptime; Nim macros
Embeddable small language, tables-as-everything, procedural data filesLua (Ierusalimschy et al.)Won outright as the embedded scripting language
Fast compilation, no hidden mechanisms, watertight cross-module checkingOberon (Wirth)Go’s compilation speed and deliberate feature parsimony

The three asymmetries worth remembering

Annotation cost collapses; proof cost shrinks but does not vanish; runtime and cultural cost do not move. The single best predictor of whether an idea in this dossier gets a second life is which of those three its historical obstacle belonged to. Catamorphism’s “cognitive burden,” Pony’s “too much type system,” Joe-E’s “unfamiliar to most programmers,” ATS’s “administrative” proof code, and Cyclone’s “somewhat tedious” aliasing are all the first category. Agda’s undecidable termination checking, Clean’s incomplete higher-order theory, and Mercury’s undecidable determinism inference are the second. Alef’s missing GC, Limbo’s platform coupling, Eiffel’s $4,799 license, and Verse’s closed-source compiler are the third.

The value of these ideas rises independently of their cost falling. Contracts, effect rows, capability manifests, determinism annotations, and typestate protocols are all machine-checked summaries of what code can do — and the scarce resource in an agent-heavy workflow is not code production but reviewable evidence that produced code is safe. An idea that was “extra work with no visible payoff” when a human wrote and owned the code becomes the primary review artifact when a machine wrote it. This is why the ranking above puts executable contracts and inferred effect rows near the top even though neither is intellectually novel.

The winning move has historically been absorption, not adoption — and that probably still holds. No language in this dossier was rescued by being right. Cyclone’s ideas reached production through Rust; E’s concurrency through JavaScript; Newsqueak’s channels through Go; Prolog’s declarativeness through SQL and LINQ. The plausible agent-era outcome is the same shape: not Dafny replacing Python, but SMT-checked contracts and invariants appearing in mainstream languages as agent-maintained annotations; not Joe-E reviving, but per-module capability manifests enforced by a verifier; not Pony winning, but reference-capability-style annotations appearing where data-race freedom must be proven. The languages stay dead. The ideas get a second hearing, in a world where the entity paying their cost no longer minds.