reframe: why C won in the 80s and why Lisp is cheaper now

- 1980s: memory K/MB, 1-10MHz CPUs, simple software, testing-sufficient.
  C fit in 64KB; Lisp needed 40MB and GC cycles. The market chose throughput.
- Today: memory and transistors are free (billions on an ARM core).
  Software is too complex for testing alone. Cost of failure > cost of
  verification.
- Inversion: 1980s said correctness is a luxury. 2020s says correctness
  is the only affordable option.
- Passepartout exploits this: verification appliance for K/year replaces
  00K/year in compliance failures.

ideas/passepartout-economics.org

@@ -410,28 +410,72 @@ accelerates from years to quarters.
 
 * Broader Insights
 
-** The historical fork: Lisp vs C as hardware economics
+** The historical fork: why C won economically in the 1980s
 
-C is not inherently more efficient than Lisp. It is more efficient on
+C won because the economics of 1980s hardware made Lisp's overhead
-machines designed for C. The RISC revolution, commodity DRAM, and the PC
+unaffordable:
-ecosystem optimized hardware for C's execution model (static compilation,
-explicit memory, flat address space). This was an economic choice from the
-1980s, not a technical verdict.
 
-A Lisp Machine makes Lisp efficient by making cons cells hardware primitives,
+- **Memory cost.** DRAM was ~$5,000/MB in 1980. Lisp's runtime (SBCL today
-type tags a parallel path in the ALU, and function dispatch a microcoded
+  is ~40MB) was unthinkable. C's runtime fit in 64KB.
-instruction. On such hardware, C would feel bloated — manual memory
+- **CPU speed.** 1-10MHz. Every instruction counted. Lisp's GC, type dispatch,
-management becomes unnecessary overhead, static types become rigid
+  and dynamic allocation consumed cycles that C spent on actual work.
-constraints, separate compilation becomes a workaround for a limitation
+- **Software scale.** Programs were thousands of lines, not millions. A single
-the hardware doesn't have.
+  developer could hold the entire program in their head and verify correctness
+  by reading it. Testing was sufficient. Formal verification was unnecessary
+  overhead.
+- **Market dynamics.** The PC market was expanding exponentially. Speed to
+  market, volume, and unit cost mattered more than correctness. A buggy $500
+  PC sold more units than a correct $50,000 Lisp Machine.
+- **Hardware ecosystem.** RISC (reduced instruction set) was the revolution.
+  Simpler chips, higher clock speeds, cheaper fabrication. RISC CPUs are
+  optimized for C's execution model because C was the dominant systems
+  language when RISC was designed.
 
-The gap people feel ("Lisp is elegant but C is practical") is the distance
+Lisp lost not because it was worse, but because the market optimized for
-between human thought and machine operation, not the distance between Lisp
+a different axis: raw throughput per dollar, not correctness per line.
-and efficiency. Lisp minimizes the distance to human thought. C minimizes
-the distance to the silicon. The Lisp Machine was the only architecture that
-attempted to close both at once.
 
-** How Passepartout could reverse the fork
+** What changed to make Lisp viable now
+
+Four transformations flipped the economics:
+
+1. Memory is free. 40MB runtime is noise on a $20 Raspberry Pi with 8GB
+   RAM. The cost of the runtime is now zero at any relevant scale.
+
+2. Transistors are free. A modern ARM Cortex-A72 has billions of
+   transistors. The GC, type dispatch, and dynamic dispatch that Lisp
+   needs are executed in dedicated silicon within the CPU — they cost
+   nothing because the transistors are there whether used or not.
+
+3. Software complexity saturates human verification. Systems are now
+   tens of millions of lines. No single person can hold them in their
+   head. Testing is necessary but insufficient — zero-day vulnerabilities
+   prove that bugs survive all testing. Formal verification is no longer
+   overhead; it is the only known path to correctness at this scale.
+
+4. The cost of failure is now higher than the cost of verification. A
+   single breach costs millions. A compliance failure shuts down a
+   factory. Regulation (GDPR, SOX, HIPAA, FedRAMP) mandates provable
+   compliance. The cost of proving correctness is now cheaper than the
+   cost of not proving it.
+
+** The key insight
+
+The 1980s trade-off was: C is cheap enough for the market. Correctness
+is a luxury the market cannot afford.
+
+The 2020s trade-off is: C is expensive for the market. Incorrectness
+has become the dominant cost of software. Lisp's verification infrastructure
+is now the cheaper option.
+
+This is the inversion Passepartout exploits: the verification appliance
+(AGPL symbolic engine + RISC-V Lisp μcode on FPGA) costs $5,000/year and
+replaces $500,000/year in compliance audits, breach litigation, and
+regulatory fines. The 1980s math said Lisp was too expensive at any price.
+The 2020s math says Lisp is the only affordable option.
+
+The remaining question is not whether the economics flipped — it's whether
+anyone builds the bridge from today's AGPL software to tomorrow's
+verification appliance. Passepartout is that bridge.
 
 A software ecosystem changing hardware economics has never happened before.
 Passepartout's most realistic path: verification appliances for regulated