The Von Neumann Bottleneck Is Still Here
March 30, 2022
Modern machines added cores, accelerators, clusters, and clouds, yet programmers still assemble them as separate computers contending for shared resources. Brian Greenforest’s architecture replaces that fragmentation with one distributed executable across many cores and devices.
The program keeps explicit object-capability ownership while exposing reactive dataflow, statecharts, Verilog structure, and familiar language surfaces inside one homogeneous model.
Turn a Fleet of Machines Into One Program
A conventional core advances through a sequential instruction stream. Multiple cores add contention, messaging, synchronization, and deployment layers that fracture the developer’s view of the application.
Cartilage gives each resource an owner, makes sharing explicit, and connects work through reactive relationships. Objects and processes can occupy different physical locations while remaining parts of the same program.
Scale Without Losing the Mental Model
A browser session offers a useful analogy: the server can treat each client’s temporary state as a live instance inside the larger application. Cartilage extends that continuity across processors, FPGAs, devices, and network boundaries.
Developers and computing researchers can build with this unified model now. Bring a workload whose structure disappears across heterogeneous infrastructure and explore how one distributed program restores clarity.
LinkedIn status when archived: Visible to anyone on or off LinkedIn.
I am pretty seriously believe that for almost 100 years we haven't made any significant improvement on top of the Alan Turing/John von Neumann computer architecture.
The original program did exist and ran on a single core.
Then we hit the so called "von Neumann bottleneck".
We have tried to address it since then. We thought that many cores was the solution. It wasn't: it simply gave us unscalable and unmanageable mess of multiple interconnected computers, or cores contending for concurrent access to the same resources.
I'm the only person on Earth who has a working solution that supersedes this 100-years old design. I found the way to make one giant distributed .exe that runs on many cores and many devices simultaneously, while maintaining a perfect so called "object capabilities" security model of access, ownership, and share of resources.
And developers can reason about the code in all holy grail way they dreamed of: object-oriented, reactive programming automatic dataflow, statecharts, Verilog, FPGAs, Python... whatever they want, but this time it's massive, distributed, infinitely scalable, homogeneous program.
No more #heterogeneous #computing.
To make an analogy, if you know about Node.js, imagine that every client session browser state is a temporary instance of a class transparently existing from the point of view of the server-side program as a part of it.