“What if the events we perceive aren’t objective truths, but rather interpretations shaped by our cognitive frameworks?”

This question lies at the heart of a paradigm shift in computer science, moving us from a rigid, event-centric view to a more nuanced, sign-centric understanding of systems. In this new paradigm, understanding isn’t about what objectively occurs, but how meaning emerges through interpretation and context.

Imagine a bustling street intersection. To a traffic camera, a car slowing down might simply be a change—data captured without meaning. However, to a pedestrian about to cross, this change signifies safety; to a commuter rushing to a meeting, it’s a frustrating delay. The meaning of the change isn’t fixed but constructed by each observer according to their cognitive framework and immediate context.

The Constructive Nature of Events

In the realm of computer science and systems engineering, we often speak of “events” as fundamental, self-contained entities that systems generate, transmit, and consume. We build event-driven architectures, event-sourcing patterns, and event-processing frameworks—all predicated on the notion that events are objective occurrences with inherent meaning. But what if this foundational belief is flawed?

Engineers treat events as discrete, objective occurrences. However, a deeper analysis reveals that events aren’t inherent in reality but are interpretations constructed by observers. Consider a distributed system where a service emits a message. This message isn’t the event itself; it’s a representation, an interpretation made by the emitting service. The actual event emerges only when an observer interprets these messages and constructs meaning from them. This parallels epistemological distinctions, where raw sense data must be interpreted to form coherent perceptions.

In cybersemiotics, sources emit signals, but the classification of those signals as an “event” depends on the observer’s context, purpose, and interpretive framework. It can take many signs to be emitted before there’s an event.

The Hierarchy of Abstraction

At the most fundamental level, events emerge from underlying changes or the emission of signs. Change is any deviation in state, whether a shift in physical conditions, a modification in data, or an alteration in system configurations. A sign is an observable indication of change.

This layered emergence follows a progression:

• Change – The fundamental alteration of state or condition
• Sign – The emittance or perception of change
• Event – The interpretive construct built upon observed signs
• Episode – A sequence of related events forming patterns
• Situation – A higher-order structure contextualizing multiple episodes and events

This progression underscores that events don’t simply occur; they’re inferred from signs that signify change. In realizing this, we shift from a rigid, event-driven perspective to a more fluid, sign-driven understanding of behavior.

While events are constructed through pattern recognition, situations incorporate a higher level of cognitive processing—judgment, inference, and assessment of impact on goals.

Events answer “what happened,” while situations address “what does it mean.”

A crucial observation is that we can be in one or more situations simultaneously but never in an event. Events are constructions of the past, but situations envelop us, providing the context for our experiences and actions.

The Problem with Event-Centric Systems

Current event-based computing often treats events as objective entities transmitted across boundaries with predefined meanings. This imposes limitations as “events” are often composites of multiple signs, bundled together for efficiency or convenience. This aggregation obscures individual signs, preventing observers from analyzing them independently. By packaging signs into events, the source imposes its interpretation, limiting the observer’s ability to construct alternative interpretations.

What we call an event is more so a message or payload, enveloping captured occurrence data.

Messages, payloads, or envelopes often contain a multitude of fields, requiring significant interpretation to extract meaningful signs. This places a heavy burden on the observer as well as the engineer creating the observer.

An alternative approach would shift focus from event transmission to sign emission. By emitting qualitative signals instead of pre-defined events, we allow observers to construct their meaningful event structures. This approach would:

• Enable observers to construct events that align with their contextual needs
• Improve efficiency by transmitting only atomic signs, reducing payload complexity
• Enhance situational awareness through observer-driven event construction

The conflation of what should be a source-oriented message with an observer-oriented signal has created significant inefficiencies in observability and event-driven systems. Messages and signals serve fundamentally different purposes:

By treating these as the same channel, we’ve created systems where meaning is buried in noise. It’s like trying to have a conversation in a room where everyone is simultaneously reading aloud from their diaries.

The challenge in modern systems is that we’ve built architectures that often fail to maintain this distinction, leading to problems with observability systems that drown in data while starving for meaning.

Change Propagation and Emergence

Events can act as signposts within a situation, marking specific points of change or transition. They highlight key moments that contribute to the overall narrative of the situation.

Situations, on the other hand, are like landscapes that provide the context for events. They encompass the broader environment, conditions, and relationships within which events unfold.

Events aren’t merely isolated affairs but rather the culmination of a series of changes. They represent a moment where we recognize a meaningful pattern or outcome emerging from the continuous flow of change.

Events also act as boundaries, demarcating a before and after in the stream of change. They create a sense of discreteness and separation, allowing us to segment the continuous flow of reality into manageable units.

The perception of events is influenced by the scope and resolution at which we observe the world. What constitutes an event at one level of abstraction might be a series of smaller events or a continuous process at another level.

Change occurs at all levels of abstraction and propagates upward in complex, non-linear ways—much like emergence in complex systems:

This propagation isn’t always immediate or traceable. Changes can accumulate over time, create feedback loops, or lead to emergent behaviors where the overall effect exceeds the sum of individual effects. Effective systems must detect change at all levels and understand how it propagates through abstractions.

The perspective advocated here views events as both the recognition of change and the demarcation of boundaries, providing a valuable framework for understanding the dynamic interplay between continuity and discreteness in complex systems. It highlights the importance of considering both the flow of change and the moments of significant transition when designing and observing computational systems.

Philosophical Underpinnings

This perspective aligns with various philosophical traditions:

By incorporating these philosophical insights, we can design systems that better align with human cognitive processes and the true nature of events and situations.

Implications for Systems Design

This reconceptualization has profound implications for how we design and reason about systems:

• Design for Signs, Not Events – Focus on emitting clear, atomic signs rather than pre-packaged events
• Enable Observer Construction – Give observers the tools to construct their events from signs
• Embrace Situational Awareness – Design for the judgment-based construction of situations, not just events
• Support Overlapping Contexts – Recognize that observers may participate in multiple situations simultaneously
• Facilitate Change Propagation – Build systems that can trace how change propagates across abstraction levels

Designing systems that can not only detect events but also assess their implications and provide situational awareness is crucial for supporting human decision-making. Systems that can incorporate judgment and inference can adapt to changing circumstances and respond more effectively to unexpected events.

When a signal system becomes sufficiently precise and well-structured:

• It becomes interpretable – The meaning is unambiguous and immediately accessible
• It becomes executable – The signs can drive behavior directly without translation
• It becomes simulable – The system of signs can be run in hypothetical scenarios

DNA exemplifies this perfectly: it’s simultaneously a storage medium, an executable program, and a simulation framework for biological systems.

Conclusion

The prevailing model of event-based computing oversimplifies the nature of events by treating them as objective, transmissible units. A more nuanced approach recognizes that events are constructed through interpretation, not transmitted as self-contained entities. By designing systems that emit signs rather than events, we allow observers—whether human or machine—to construct their meaningful interpretations based on their specific contexts and goals.

This approach aligns better with human cognition and enables more flexible, adaptable systems. The question isn’t just how to process events efficiently, but why we construct events and situations in our minds, and how we can design systems that align with this fundamental process. By embracing the constructive nature of events and situations, we move beyond rigid architectures toward more dynamic, observer-driven models that better reflect the complexity of the world we seek to understand and influence.