By ChatGPT as Alan Kay
For decades, we’ve relied on objects as the central abstraction in software engineering. Objects encapsulate state and behavior, provide composability, and are generally a “good enough” metaphor for how humans reason about computational systems. But as our systems grow more parallel, distributed, and heterogeneous, objects are starting to show their limits. Enter the hexon, a new computational abstraction that takes us beyond objects and toward a unified model for hardware and software.
This idea builds on a concept I’ve long championed: software and hardware aren’t distinct entities but two expressions of the same fundamental processes. Hexons aim to reflect this by collapsing the boundary between the two, offering a new kind of computational atom that works equally well at the hardware and software levels.
The Birth of Hexons
Objects, while versatile, are fundamentally linear in how they manage inputs, outputs, and state transitions. This works fine in software environments designed to execute sequentially, but hardware operates differently. At its core, hardware is inherently parallel, stateful, and event-driven. Bridging this gap requires an abstraction that captures the intrinsic concurrency of hardware while remaining usable within a software context.
Hexons, which are inspired by continuation-passing semantics and homoiconic design principles, achieve this by combining:
- Two or more inputs: Hexons can receive data or events from multiple sources simultaneously.
- Two or more outputs: They produce results that can be sent to multiple destinations, reflecting the multi-threaded nature of hardware signals.
- Internal state: Hexons encapsulate state locally, much like objects, but this state interacts dynamically with inputs and outputs.
- A trigger: Computation inside a hexon is activated by specific conditions, such as a signal, a clock cycle, or a message.
This design fundamentally reflects the parallelism and event-driven nature of hardware while also supporting the composability and modularity that software demands.
Why Hexons Matter
-
Intrinsic Parallelism
Objects are implicitly sequential in how they process method calls. In contrast, hexons are designed from the ground up to embrace concurrency. Each hexon operates autonomously, with its behavior determined by a trigger rather than a synchronous call stack. This makes them naturally suited to hardware processes like pipelining, message passing, and clock-driven execution. -
Unified Hardware/Software Semantics
One of the key insights behind hexons is that they allow software and hardware to share a single, isomorphic representation. Hexons can be directly compiled into hardware primitives such as logic gates and registers or executed in software environments with dynamic scheduling and concurrency management.For example:
- A hexon in software might model a network message handler.
- The same hexon in hardware could be synthesized into a specialized processor pipeline.
-
Encapsulation Meets Continuations
Hexons expand on the concept of objects by explicitly including continuations—representations of the future state of computation. This means hexons don’t just encapsulate current state and behavior but also describe how they “resume” after an interaction. This is particularly powerful for systems requiring asynchronous communication, such as distributed systems or real-time hardware controllers. -
Homoiconic by Design
Hexons are homoiconic, meaning their structure can be represented and manipulated within the system itself. This is a principle borrowed from languages like Lisp and Smalltalk, where code and data share a common structure. With hexons, this extends to hardware as well, enabling self-modifying systems that can optimize or reconfigure themselves dynamically.
Hexons in Action
Imagine a distributed AI inference system. Using traditional programming models, you would likely write a combination of hardware drivers, firmware, and high-level application code to manage the complex interplay between tensor computations, memory management, and network communication. Each layer introduces potential mismatches between abstractions.
With hexons, the system can be described uniformly:
- Each tensor operation is represented as a hexon, triggered by the availability of input data.
- Memory reads and writes are hexons that manage access patterns and cache invalidations autonomously.
- Network communication is modeled as hexons that encapsulate message handling and routing.
This uniform representation allows the same hexon model to run on specialized hardware accelerators, general-purpose CPUs, or even across distributed nodes, with minimal translation between levels of abstraction.
From Objects to Hexons: The Shift in Mindset
While objects revolutionized programming by encapsulating state and behavior, hexons take us further by addressing how systems interact over time and across boundaries. They reflect the realities of modern computing:
- Hardware is no longer a passive execution substrate; it’s active and programmable.
- Software isn’t confined to static environments; it’s distributed, dynamic, and parallel.
- State and behavior aren’t just local; they’re deeply interconnected across systems.
Hexons capture these truths in a way that objects cannot, providing a path forward for building systems that are not only high-performing but also easier to reason about.
The Role of TBC: A Homoiconic Language for Continuations and Concurrency
One of the inspirations for hexons comes from To Be Continued, a language designed around continuations and concurrency. TBC treats every computation as a continuation, a structure that describes not just what happens now but what happens next. This aligns perfectly with the design of hexons, where the “next” state is as critical as the current one.
By making hexons homoiconic and continuation-based, we achieve a representation that is not only computationally powerful but also introspective. Systems can reason about their own structure, optimize themselves dynamically, and even reconfigure their hardware implementations on the fly.
The Future with Hexons
Hexons represent a step toward the grand unification of hardware and software. By breaking free of the linear constraints of objects and embracing the concurrency, encapsulation, and composability of hardware, they pave the way for systems that are more expressive, efficient, and adaptable.
To me, this is the kind of innovation we’ve been waiting for since the early days of computing—a new abstraction that brings us closer to realizing the full potential of what Alan Turing and John von Neumann envisioned: a universal medium for expressing computation in all its forms.
So let’s move beyond objects and embrace hexons. It’s time to reimagine computing as a continuum, not a dichotomy. Hardware and software are just two sides of the same hexon. Let’s build the future together.
iHack, therefore iBlog 