A Logical Approach to Event Handling in Imperative Languages

While event handling is a key element in modern interactive programming, it is unfortunate that its theoretical foundation is rather weak. To solve this problem, we propose to adopt a game-logical approach of computability logic \cite{Jap08} to event handling.

💡 Research Summary

The paper addresses a long‑standing gap in the theoretical foundations of event handling in modern interactive programming languages. While graphical user interfaces and other event‑driven systems rely heavily on ad‑hoc mechanisms such as callbacks, state machines, or library‑specific constructs, there is little formal grounding that can guarantee correctness, composability, or reasoning about dynamic user interactions. To fill this void, the authors propose a logical approach based on Computability Logic (CL), a game‑theoretic framework introduced by Japaridze, and specifically leverage the sequential‑choice‑disjunctive operator, denoted “schoo”.

In the proposed extension of a core C‑like language, three syntactic categories are introduced: G‑formulas (executable statements), C‑formulas (constant and procedure declarations), and D‑formulas (programs composed of C‑formulas and the new “schoo” declaration). A G‑formula may be a simple true constant, a print statement, an atomic procedure call, a Boolean condition, an assignment, a sequential composition (G;G), or a sequential‑choice construct schoo(G₁,…,Gₙ). A D‑formula can be a conjunction of declarations (D∧D) or a sequential‑choice declaration schoo(D₁,…,Dₙ). The key idea is that a schoo‑declaration initially activates its first component; when the user generates a specific event (e.g., pressing ESC), the system switches to the next component, thereby modeling dynamic state changes as logical choices.

The semantics are defined via a two‑phase execution model that mirrors the interactive nature of CL games. First, a “stable” predicate determines whether the current program‑statement pair (D,G) is in a stable configuration (no automatic moves are possible) or an unstable one (the machine can make a move). The predicate returns a status code I ∈ {1,2,0,−1} indicating who (machine or user) has a legal move. Second, the actual execution is captured by the meta‑operator ex(D,G,θ,θ′), where θ is the current substitution (variable bindings). Execution alternates between a machine move phase exₘ and a user move phase exᵤ.

The machine move phase exₘ consists of a set of inference rules that handle procedure calls, Boolean evaluation, assignments, printing, sequential composition, and the schoo‑selection within the main program. Notably, rule (11) specifies that schoo(G₁,…,Gₙ) reduces to schoo(G₂,…,Gₙ) after the machine makes a “switch” move, reflecting the user‑triggered transition. The user move phase exᵤ defines how an external event (denoted w.Esc) rewrites a schoo‑declaration in the program, effectively replacing the current component with the next one. This rewriting is performed at the address level, ensuring that only the intended declaration is affected.

An illustrative example demonstrates the approach: a car‑price selection program declares three models using schoo(model==BMW320, model==BMW520, model==BMW740). The main program prints the price of the currently active model. Initially the system is unstable, the machine executes the first three statements, and the price of the BMW320 is printed. When the user presses ESC, the program becomes unstable again, the machine switches to the second model, and the corresponding price is printed. If the user does not act, the machine remains in a stable waiting state. This example shows how the logical construct captures both the automatic progression of the program and the user‑driven event without resorting to explicit event loops or callback registration.

In the conclusion, the authors acknowledge that the current treatment handles only synchronous events. They outline future work to incorporate asynchronous events by extending the CL framework with additional operators, thereby preserving the logical rigor while supporting more realistic interaction patterns. Overall, the paper offers a novel, formally grounded method for embedding event handling directly into the language semantics, promising improved reasoning about interactive programs, reduced reliance on ad‑hoc mechanisms, and a clear pathway toward richer, provably correct user interfaces.