TL;DR
Paul Tarvydas argues that advancing type systems—dependent types, effect systems and sophisticated type-level programming—misses the practical need for composable software primitives. He proposes a parts-based substrate: simple transport, recursive container/leaf parts, asynchronous message-passing, ports/gates and fan-out to enable true “LEGO” composition.
What happened
In a recent essay, Paul Tarvydas critiques the current trajectory of programming-language research and engineering that prioritizes ever-more-complex type systems. He argues that functional programming’s emphasis on pure, synchronous function composition produces brittle abstractions for systems where timing, sequencing and concurrency matter. Instead of deeper type theory, Tarvydas proposes building software from modular parts that behave like LEGO bricks: a minimal transport for moving data between parts, recursive container/leaf part hierarchies, port- and gate-based boundaries, first-class fan-out and intrinsic asynchronous, fire-and-forget messaging. He frames operating systems and UNIX-style pipelines as partial or misguided workarounds — useful ideas but limited or misaligned with the needs of modern distributed and embedded systems. The piece calls for primitives that make composition explicit, eliminate hidden control flow and allow architects to reason about timing and protocols when necessary.
Why it matters
- Shifting focus from type-theory advances to composition primitives could change how systems are architected, emphasizing explicit boundaries and connectivity.
- Intrinsic asynchronous messaging and port-based encapsulation aim to reduce hidden coupling that undermines black-box abstractions.
- A parts-based substrate could simplify building distributed, concurrent and real-time software by making timing and topology first-class concerns.
- Reorienting research and tooling toward composability may influence language design, frameworks and runtime models used in Internet, robotics and IoT systems.
Key facts
- The author contends that pursuing deeper type systems and type-level engineering is a misdirected investment for composability.
- Functional programming is characterized as well-suited to ‘calculator’ style problems but inadequate where sequencing, timing and concurrency matter.
- Tarvydas lists five fundamental elements needed for LEGO-like composition: a simple transport, recursive part definitions, non-filter parts (fan-out), asynchronous message-passing, and ports/gates for boundaries.
- He criticizes synchronous function calls as inherently blocking and says they force workarounds to achieve asynchronous behavior.
- Operating systems are described as a kind of workaround that converts synchronous call stacks into state machines, often without architect control.
- UNIX pipelines are acknowledged as a limited inspiration: they show composability but only along a single rendezvous/filter dimension.
- Fan-out is highlighted as necessary to build true black-box abstractions that hide internal complexity behind single external interfaces.
- The author emphasizes the need to be able to express and reason about timing and protocols explicitly when they matter.
What to watch next
- not confirmed in the source: whether mainstream language designers or runtime teams will adopt the parts-based substrate model described.
- not confirmed in the source: concrete implementations, reference runtimes, or standards that realize the port/gate and asynchronous primitives proposed.
- not confirmed in the source: any timelines or projects that would trial fan-out-first composition models at scale.
Quick glossary
- Functional programming: A programming paradigm that treats computation as evaluation of mathematical functions and emphasizes immutability and pure functions.
- Asynchronous message-passing: A communication pattern where senders dispatch messages without waiting for immediate processing or replies, enabling non-blocking interactions.
- Fan-out: A connectivity pattern where a single input is routed to multiple internal consumers or outputs, allowing branching and parallel composition.
- Port and gate: Architectural abstraction where a port is an external connection point and a gate is the corresponding internal endpoint, enforcing encapsulation.
- Black-box abstraction: An encapsulation that exposes only a defined interface while hiding internal implementation details and complexity.
Reader FAQ
Is the author rejecting functional programming entirely?
The author argues FP is inadequate for certain composability needs, especially timing and concurrency, but does not provide a blanket rejection of all FP ideas.
What are the five primitives the author says we need?
A super-simple transport, recursive container/leaf part definitions, parts that support fan-out (not just filters), pure asynchronous message-passing, and port/gate-based boundaries.
Does the essay call for abandoning type systems altogether?
The author says we don’t need ‘smarter’ type systems for the composability problems described, framing richer type theory as less urgent than better composition primitives.
Are there working languages or systems that implement this parts-based approach?
not confirmed in the source
Discover more from Paul’s Substack My personal Substack Subscribe By subscribing, I agree to Substack's Terms of Use, and acknowledge its Information Collection Notice and Privacy Policy. Already have an…
Sources
- Stop Digging and Start Building: Why We Need Lego Parts, Not Deeper Type Systems
- Why We Need Lego Parts, Not Deeper Type Systems
- Future of Coding Weekly 2026/01 Week 1
- Paul's Substack | Paul Tarvydas | Substack
Related posts
- YouTube page titled ‘Scott Adams has passed away’ raises verification concerns
- Local Journalism: How Democracy Shows Up Close to Home — And Why It Matters
- Why Stoicism Remains One of the Most Effective Mind Hacks Ever