Houston Haynes’ talk reframes Excel as the world’s most successful functional programming platform. While developers often dismiss spreadsheets, Excel naturally embodies FP principles: formulas as pure functions, explicit dependencies, declarative logic, and predictable recalculation.
He argues that FP adoption succeeds when framed in familiar terms. Instead of leading with theory, position FP as a safer, scalable version of the spreadsheet model—preserving transparency and predictability while eliminating Excel’s risks. The takeaway: functional programming has already gone mainstream; we just need to recognize it and build on it.
Excel: The World’s Most Successful Functional Programming Platform: A comprehensive overview
Houston Haynes delivered one of the most surprising and thought-provoking talks of the year: a reframing of Excel not just as a spreadsheet tool, but as the world’s most widely adopted functional programming platform.
The talk combined personal journey, technical insight, business strategy, and even a bit of FP philosophy — challenging the functional programming community to rethink the boundaries of their craft and the audience it serves.
The Big Idea: Excel Already Won Functional Programming (Just Not the Way We Expected)
Functional programmers often wonder why FP hasn’t become mainstream.
Houston’s answer was simple:
It has — just not inside the software engineering bubble.
While developers obsess over language rankings, type systems, and purity, billions of people use spreadsheets every day. And whether they know it or not, they’re practicing a form of functional programming:
- Inputs flow into formulas.
- Formulas produce predictable outputs.
- Dependencies form a directed graph.
- Recalculation propagates deterministically.
Excel is a functional runtime — just with a grid instead of a syntax tree.
And that changes everything about how we should talk about FP.
Why Developers Dismiss Excel — And Why That’s a Problem
Most engineers react with an eye-roll when someone says they “built it in Excel.”
Houston admitted he used to do the same.
Developers see:
- Row limits
- Fragile pipelines
- Messy versioning (“Which file is latest_final_FINAL.xlsx?”)
- Hidden state
- Weak auditability
- Security risks
- Data silently turning into dates (!)
Those criticisms are valid — but they also create a communication gap.
To the business users who rely on spreadsheets every day, what they hear is:
“You’re doing it wrong.”
The result?
Stakeholders retreat. Developers lose trust and influence. Projects stall before they start.
Reframing the Conversation: What Business Users Actually Need
When someone chooses Excel, it’s not because they don’t understand “real engineering.”
It’s because Excel offers:
Predictable results
- Traceable logic
- Immediate visual feedback
- Control
- A familiar model of compositional reasoning
These map directly to FP principles:
| Spreadsheet Concept | FP Concept |
| Cell formulas | Pure functions |
| Cell references | Explicit dependencies |
| Recalculation graph | Functional reactive propagation |
| “Same input → same output” | Referential transparency |
| Declarative formulas | Declarative semantics |
This is not a coincidence.
Houston revealed that Simon Peyton Jones (co-creator of Haskell) worked at Microsoft Research on formalizing Excel’s calculation engine — even adding lambda support to complete its functional model.
Excel didn’t accidentally become functional.
It evolved that way — because FP fits the way humans reason about problems.
The Scale Perspective: Why Popularity Metrics Miss the Point
Most language rankings look like this:
TIOBE, PYPL, RedMonk, Stack Overflow trends…
But those sources only measure developers — a population of ~25–30 million.
When we zoom out and ask:
“What technologies do professionals use to get work done?”
…the denominator becomes billions.
By that measure, Excel dwarfs every programming language.
And if spreadsheets are the world’s most common way to express functional logic, then FP has already achieved mass adoption — just not in the form we expected.
The Dark Side of Spreadsheet Programming
Of course, Excel is not a perfect functional platform.
Houston highlighted real-world disasters:
- Fidelity Magellan (1995): A missing minus sign → $2.6B error
- JPMorgan “London Whale” incident (2012): Hidden rows in a spreadsheet → catastrophic mispricing
The takeaway isn’t “Excel is bad.”
It’s:
Excel offers functional reasoning, but without guardrails.
Business users love the freedom.
Companies suffer the consequences.
This is where professional FP engineers enter the story.
The Pitch: Functional Programming as a Scalable, Safer Excel
Houston’s core argument to stakeholders is beautifully simple:
“We’re not taking away your favorite calculator — we’re giving you one that doesn’t break when two people touch it at the same time.”
By framing FP systems as reliable, scalable versions of the spreadsheet model, we gain:
- Familiar mental models for non-technical users
- Easy onboarding for business stakeholders
- Clear mappings between domain knowledge and system logic
- Stronger trust and adoption
Instead of saying “functional programming,” we say:
- Predictable behavior
- Transparent logic
- No hidden state
- Safer updates
- Clear dependencies
- Traceable transformations
Stakeholders understand these intuitively — because that’s what spreadsheets already offer them.
A Live Functional Spreadsheet Demo (But Written in F#)
Houston showcased a web-based spreadsheet engine he built:
- Written in F#
- Compiled to JavaScript via Fable
- Using SolidJS for reactivity
- Running serverlessly on Cloudflare Pages
The point of the demo was not the UI.
It was the proof that spreadsheet behavior is just a functional dependency graph — and that FP languages map naturally to this model.
When users edit a cell:
- Only dependent cells recompute
- Order doesn’t matter (referential transparency)
- The system remains predictable
In other words: Excel’s magic is just FP made visual.
The Business Case: FP Succeeds Where Failure Is Expensive
Houston emphasized that FP’s true strengths shine in industries where errors matter:
- Finance
- Healthcare
- Telecom
- Payments
- Risk and actuarial systems
Companies like:
- Jane Street (OCaml)
- Standard Chartered (F#)
- WhatsApp (Erlang)
Major global banks (F# and Scala)
…run mission-critical systems on FP precisely because of correctness, predictability, and maintainability.
Popularity isn’t the goal.
Reliability is.
Final Takeaway: Rethink What It Means for FP to “Win”
Houston closed with a provocative point:
Functional Programming doesn’t need to become mainstream.
It already is — just not where we’ve been looking.
Spreadsheets show that:
- People naturally gravitate toward declarative, functional models
- FP is intuitive when presented visually
- The real leap is not teaching FP — it’s connecting FP to what business users already understand
Excel won the adoption battle.
FP languages can win the reliability battle.
Conclusion
Houston’s talk reframes Excel not as a rival to functional programming, but as its greatest validation.
It reveals a powerful, empathetic way for FP engineers to communicate with non-technical stakeholders — one that builds bridges instead of barriers.
The future of FP adoption won’t come from arguing about type systems.
It will come from speaking the language that billions of professionals already use: the spreadsheet model.
And as Houston showed, when we connect the dots between spreadsheets and FP, functional programming stops being abstract — and starts becoming obvious.