Haskell's lazy evaluation means the order of operations is not guaranteed, making side effects like `print` statements unpredictable. This forced the language to be pure by default. Conversely, OCaml's strict, predictable evaluation order made it easy to incorporate I/O and side effects, allowing it to be impure by default.

The dream of hardware optimized for functional programming (e.g., dataflow or SK combinator machines) proved to be a mistake. These machines were essentially hardware-based interpreters. The better approach is to build a sophisticated compiler that translates functional code into efficient instructions for general-purpose CPUs.

With hundreds of millions of users writing formulas, Excel's side-effect-free, value-based computation model makes it a massive, unintentional functional programming environment. Recognizing this, Simon Payton Jones successfully advocated for adding Lambda functions, making Excel's formula language Turing-complete.

This approach contrasts with imperative languages where computation proceeds by mutating a state over time (e.g., a running total). Functional programming is more declarative, like a mathematical expression or a spreadsheet cell that calculates its value based on others, making it easier to reason about.

Our current computation, based on Turing machines, is limited to "computable functions." However, mathematics shows this set is a smaller, countable infinity compared to the vast, larger infinity of non-computable functions. This implies our current simulations barely scratch the surface of what is mathematically possible.

In imperative code, functions can silently read or write shared global variables, creating invisible and dangerous dependencies. Functional programming forces these interactions to be explicit (e.g., through function arguments or monads), encouraging a more modular and less coupled design that is easier to reason about and maintain over time.

The history of mathematics is filled with examples, like Newton and Leibniz independently discovering calculus, where different people in isolation uncover the exact same mathematical systems. This suggests they are not inventing a language but discovering a pre-existing computational structure inherent to the universe itself.

The power of monads isn't just to sequence side effects, but to treat those entire sequences as first-class values that can be passed, stored, and reused. Unlike in C, Haskell's `do` notation bundles I/O operations into a value (e.g., of type `IO unit`) that can be composed and manipulated like any other data.

Lazy evaluation allows programmers to modularly separate producer and consumer logic (e.g., an infinite data generator and a selective consumer) that would have to be merged in a strict language. For example, one can generate an infinite chess game tree and have a separate function explore only the necessary branches.