FP (programming language)

FP

FP is a language that exists mostly to make an argument — and the argument won. In his 1977 Turing Award lecture, "Can Programming Be Liberated from the von Neumann Style?" (published CACM August 1978), John Backus — the man who'd led FORTRAN — turned against the entire paradigm he'd built. His diagnosis: conventional languages were trapped inside the "von Neumann bottleneck," shuttling single words between CPU and memory, one variable at a time. His prescription was FP: a language where you don't name values at all — you compose functions using a fixed algebra of combining forms.^[1]

FP's rules are austere: every function maps one value to one value; there are no variables, no assignment, no lambda binding — only primitives and functionals (higher-order operations like composition f∘g, apply-to-all αf, insert /f, and the conditional (h⇒f;g)). The algebra of programs — equations about functions — was the point: Backus wanted programs you could prove things about with the same algebra you used on the math they implemented.^[2]

The influence that outlived the language

FP itself was used little beyond academia — and the field took a different road: modern functional languages are built on lambda calculus and named variables (Haskell, ML), not Backus's function-level point-free style. But the argument landed: FP sparked the whole research program of functional programming, directly influenced FL (Backus's own IBM successor), Haskell, and — most visibly for this catalogue — the entire concatenative school, whose canonical language Joy is function-level programming made concrete. FP84 and FFP continued the experiment; the idea that programs could be equational objects is now bedrock.^[3]

Where it sits

FP is the manifesto-as-language: a proof that a Turing Award lecture could carry a whole programming model, and that the most important languages are sometimes the ones nobody runs — because they change how the next languages think. Between ALGOL 58 (notation-as-program) and Joy (point-free made runnable), FP is the hinge where the functional argument first got a machine-readable form.

Check your understanding

• What was FP, and what paper introduced it?
• What does "function-level" mean — what two things does FP not have?
• What did Backus claim the "von Neumann bottleneck" was?
• Which modern language in this catalogue is FP's clearest descendant?