Skip to main content

Dual World Theory

Background: Von Neumann and OOP​

The von Neumann model is built around memory, state, instructions, and state transitions. Memory is spatial; data lives at addresses; computation is expressed as operations over that space. At a deep level, a program describes what exists in memory at a given moment.

That model is extraordinarily powerful, but it is also, fundamentally, a spatial metaphor.

Object-oriented programming inherits that worldview and encapsulates and refines it into classes, objects, inheritance, and composition. An object is a named space; a method is an operation performed on that space. OOP is almost entirely an expression of spatial metaphors — containment, nesting, hierarchy, structure — and has almost no temporal metaphors — events, evolution, adjudication, causality.

As software engineering has developed, however, almost all of its greatest engineering complexity has turned out to be temporal: concurrency, distributed systems, consistency, transactions, messaging, timeouts, synchronization.

In the object-oriented worldview:

World=Current StateWorld = Current\ State

Change then appears as:

State1→State2→State3State_1 \rightarrow State_2 \rightarrow State_3

Causality becomes privatized and fragmented. Each object owns a slice of state, mutates that state through its own methods, or reaches into other objects through callbacks and side effects (a change in spatial content).

History is therefore split into countless fragments scattered across private object space. No unified causal narrative protects continuity of identity.

Spatial models optimize for static clarity: clean boundaries, clear hierarchies, intuitive composition. Temporal models optimize for dynamic clarity: traceable causality, narratable history, adjudicable conflict.

When a fundamentally temporal problem is forced into a spatial structure, time gets fragmented, hidden, and privatized.

At bottom, this is coupling the temporal dimension through spatial modeling.

Dual World Theory​

Dual World Theory asserts that any system that persists through time must distinguish how world facts are formed from how the world is perceived and presented.

Any complex system that must persist through time while continuously exchanging information with the outside world faces two simultaneous requirements:

  1. It must preserve the continuity of its own history.
  2. It must keep absorbing external change.

If a system ignores external change entirely, it drifts out of touch with its environment and loses adaptability. But if each new change simply overwrites the past, the system cannot form history, context, or identity.

A persistent world must therefore keep incorporating new change into an existing history, so that the future remains grounded in the past.

Under that pressure, two cooperating mechanisms emerge:

  • Causal Layer: receives events, interprets them, adjudicates relational change, and maintains an explainable history of facts. Its core assets are fact history and adjudication rules, with pending events entering adjudication as input. It corresponds to the temporal dimension of the system: irreversibility, sequence, and causal continuity.
  • Perception Layer: senses the environment, processes change, and produces experience. It translates external change into usable signals. It corresponds to the spatial dimension: simultaneous perception and parallel presentation.

Together they form a feedback loop:

External World -> Perception Layer detects -> reports event -> Causal Layer adjudicates
                                                                     ↓
External World <- Perception Layer presents <- consumes fact <- emits fact

Causal Layer​

There is an old philosophical question: what is the world made of? One answer points to substances and entities, as in object-oriented thinking; another points to relations and process — that is, process philosophy. The Causal Layer is rooted in process philosophy.

State answers one question: "What is the world like right now?" But any system that persists must also answer: "Why did the world become this way?"

Therefore, the essence of the Causal Layer is to preserve historical continuity and causal explainability. State is merely the current projection of historical facts — if the events that produced the state are missing, the state itself becomes meaningless.

To the system, the external world presents itself as disordered, concurrent, and potentially conflicting. The Causal Layer turns external change into stable, traceable history through adjudication:

  • Validity checks: does this request meet the conditions required to take effect?
  • Semantic transformation: what does this event actually mean in context?
  • Conflict adjudication: when events collide, which factual version enters history?

Perception Layer​

The Perception Layer answers: how is the world experienced and presented?

The Causal Layer produces discrete facts. The Perception Layer unfolds those facts into continuous experience: interface refreshes, animated transitions, sound feedback, haptic alerts, data visualization. "Save succeeded" unfolds from a single record into a progress bar filling, a checkmark appearing, a toast fading out.

Between facts, the Perception Layer is free.

It may interpolate, predict, and choreograph. Buttons may scale on press, numbers may roll up, pages may transition smoothly. These are all local states. They affect only presentation, not the world itself.

Perception components are organized in space. Spatial hierarchy replaces call chains as the way components relate. A dropdown menu is nested within a navigation bar, so it moves with the navigation bar.

The Perception Layer only reads facts and maintains local state, so it is naturally race-free. Many components can unfold in parallel.

The only constraint is at the handoff point. When a new fact arrives, the Perception Layer must acknowledge the latest version and switch quickly.

Eventual Causal Consistency​

Any process that aims to sustain a stable world cannot leave facts unresolved forever.

Once the Causal Layer makes an adjudication, the system must converge within finite time on the factual version determined by that adjudication. This is Eventual Causal Consistency.

It emphasizes:

  • Presentation may lag behind
  • Perception may interpolate
  • Local views may temporarily diverge

But within bounded time and space, all participants must ultimately face the same factual version of the world, so that the causal chain remains complete and explainable.

At the macroscopic level, true parallelism has never existed. What looks parallel is merely a local observer's temporary inability to distinguish order.

You can understand it as:

A macroscopic system may contain a large number of parallel changes, but if those changes are to constitute a stable world, they must eventually be folded into the same explainable history.

Two people swing swords at the same time. Two bullets hit at the same time. Two threads run at the same time. To local observers, these events may appear simultaneous — but that simply means their order has not yet been resolved. If the system must produce outcomes, stabilize state, and establish facts, it must eventually settle on an explainable causal ordering.

That is why adjudication is unavoidable.

Consider two game characters striking each other "at the same time":

A hits B
B hits A

They appear to happen simultaneously. Yet the Causal Layer still has to answer:

  • Who dies first?
  • Can post-death skills still trigger?
  • Does lifesteal apply?
  • Does the death explosion occur?
  • Who gets aggro credit?

Even if the animation, effects, and player perception all suggest simultaneity, the system must still adjudicate.

  • Database transactions: CPUs, networks, and requests may run in parallel, but the database still needs an authoritative ordering. Otherwise money can vanish into thin air, state can corrupt, and the world can lose fidelity.
  • Version control: if two developers edit the same line, Git may try to merge automatically, but unresolved conflicts still require human adjudication.
  • Law: two people may accuse each other, but a court still has to produce a narratable chain of facts, because social order and the public both need a "factual version".
  • Operating systems: thousands of processes compete for CPU, memory, and IO at the same time. In the physical world interrupts fire in parallel, schedulers dispatch in parallel, and resource requests overlap, but the operating system must adjudicate execution order. Otherwise deadlocks freeze the machine, starvation leaves tasks waiting forever, and the system collapses.
  • Blockchain: nodes around the world broadcast transactions and race to produce blocks simultaneously. Messages arrive out of order, nodes act in parallel, and proposals conflict, but the consensus mechanism must adjudicate which chain is the authoritative version. Otherwise double-spending empties accounts, forks split the ledger, and trust collapses.

The word macroscopic is crucial. At microscopic scales, the following may indeed exist:

  • Superposition
  • Probability
  • True concurrency
  • Nondeterminism

But once we enter the macroscopic scale, the world must converge into a narratable reality.

Why? Because macroscopic systems need stable causality.

Otherwise:

  • Observe
  • Reason
  • Collaborate
  • Predict
  • Govern

In other words, civilization itself is built on the eventual ordering of causality.