Despite vastly different approaches—one based on mutating a tape, the other on pure value reduction—Alan Turing and Alonzo Church's models of computation were proven to be equally powerful. This historical context reveals that the choice between paradigms is about usability and reasoning, not computational limits.

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.

Adding multicore support was not just about re-implementing the garbage collector. A significant challenge was designing a memory model that provides clear, useful guarantees to programmers in a type-safe language. This is much harder than in C/C++, where resorting to "undefined behavior" is an acceptable out.

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.

Instead of building a generic graph compiler, Etched focused on hand-optimized kernels. This approach, similar to high-frequency trading firms, provides maximum performance. It's also future-proof, as they design their tools for AI models to use directly, anticipating a time when AI writes its own kernels.

Early, foundational language ideas like Lisp and Prolog came from academic settings. Today, major innovations like safe systems programming (Rust) and widespread garbage collection (Java) are driven by large companies. This shift reflects the massive engineering effort now required to launch a successful new language.

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.

Some companies intentionally choose a more complex or niche programming language like OCaml not just for its technical merits, but as a hiring strategy. It acts as a filter, attracting fewer applicants overall, but those who do apply often have more interesting and diverse technical backgrounds.