Object-Oriented Intuition Meets the Functional Universe

It’s functions all way day down.

From Objects and Classes to Possibility and Reality

When most programmers think about Object-Oriented Programming (OOP), the first things that come to mind are objects, classes, and methods. Objects are instances of classes, blueprints that define their data and behavior. They interact via methods, and these interactions define relationships: one object may call services provided by another. This basic pattern underlies software engineering, but if we step back, it hints at something deeper about how systems evolve in general.

In OOP, relationships like association, aggregation, and composition define the rules of interaction:

• Association is a general link between objects.
• Aggregation is a “whole–part” relationship where parts can exist independently of the whole.
• Composition is stronger: the part cannot exist without the whole. Deleting the container destroys the contained object.

Aggregation vs Composition: Potential Calls and Committed History

This distinction, seemingly mundane in software, mirrors a fundamental idea in the Functional Universe (FU) framework: the difference between possibility and historical reality. FU models the universe as evolving functional states, distinguishing two ontological layers:

1. Aggregation \(\mathcal{A}\) – the realm of possibilities. Multiple transitions coexist, interfere, and interact, but none are committed to history.
2. Composition \(\mathcal{C}\) – the realm of reality. A transition becomes committed, leaving a permanent causal trace, advancing proper time \(d\tau\) and producing entropy.

In FU, you could think of aggregation as classes and composition as instantiated objects that actually do something. Aggregated transitions are like potential method calls: they exist in principle, can interact with each other, and even cancel or reinforce, but they do not advance the system until one is selected. Only a committed transition - a composition - actually executes, producing real effects and advancing time.

This perspective highlights something subtle but critical: composition is not free. Every committed transition requires at least one minimal cycle, a “quantum” of proper time, and generates entropy because the outcome leaves records in the causal graph. In macroscopic systems, this is why events unfold sequentially, why clocks tick, and why irreversible processes emerge. Even though the underlying possibilities may be reversible and continuous, reality itself advances in discrete, compositional steps.

The analogy to software deepens when we consider OOP relationships. Aggregation in FU is like an object referencing many potential collaborators but never fully calling any method. Composition, however, is a method invocation that produces side effects: it changes the world. Just as in composition in OOP, the committed transition cannot be undone; it becomes part of the system’s history.

When the Universe Actually Executes

For example, consider a complex quantum system, like particles near a black hole horizon. FU distinguishes the many virtual particle-antiparticle pairs (aggregation) from the few that escape and leave permanent records in the universe (composition). Only the escaping particles contribute to future causal chains and observable reality. Aggregation remains ephemeral, exploring possibilities, but composition determines the facts that shape the next state of the world.

From a software engineering perspective, FU gives us a powerful metaphor: functions all the way down. Objects, methods, and their interactions are just one layer of a universal computational fabric. Possibilities flow like uncommitted function calls; reality emerges when the universe executes a subset, producing history, advancing time, and leaving a causal trace.

This lens also helps bridge intuition across scales. In macroscopic systems, we see sequential causality and entropy growth. In microscopic systems, we see superpositions and virtual interactions. FU unifies these views: the same underlying functional principles govern both, with the key difference being whether transitions are aggregated or composed.

In short: OOP gives us a familiar map for thinking about relationships, dependencies, and causality. The Functional Universe extends that map, revealing why some transitions commit, why time advances, and why reality is sparse. Aggregation is abundant; composition is rare. Entropy is paid; history is written. And at the bottom of it all, functions - potential or committed - are what it’s all made of.

In the Functional Universe, functions all the way down - but only some of them ever get called.