Interaction-Oriented Programming (IOP)

• Interaction-Oriented Programming is a paradigm that treats explicit interactions, protocols, and commitments as primary design constructs.
• It supports distributed system design through global choreographies, dynamic adaptation, and formal verification methods ensuring properties like deadlock freedom and bisimulation.
• User interaction models in IOP provide guided dialogues and well-defined runtime constructs that simplify testing, reduce code length, and improve performance.

to=arxiv_search 亚历山大发json code: {"^^^^^^^^9query9 Programming^^^^^^^^9\9 OR ^^^^^^^^9\9 Software Engineering^^^^^^^^9\9 choreographies Interacto BSPL9^^^^^^^^", "^^^^^^^^9max_results9 ^^^^9\9query9^^^^, "^^^^^^^^9sort_by9 "^^^^^^^^9relevance9 to=arxiv_search 大发棋牌json code: {"^^^^^^^^9query9 Software Engineering: Concepts and Principles^^^^^^^^9\9 "^^^^^^^^9max_results9 ^^^^9sort_by9^^^^, "^^^^^^^^9sort_by9 "^^^^^^^^9relevance9 to=arxiv_search 天天中彩票在哪json code: {"^^^^^^^^9query9 "^^^^^^^^9max_results9 ^^^^9sort_by9^^^^, "^^^^^^^^9sort_by9 "^^^^^^^^9relevance9 to=arxiv_search เงินฟรีjson code: {"^^^^^^^^9query9 "^^^^^^^^9max_results9 ^^^^9sort_by9^^^^, "^^^^^^^^9sort_by9 "^^^^^^^^9relevance9 Interaction-Oriented Programming (IOP) denotes a family of programming and software-engineering approaches in which interaction is treated as the primary abstraction rather than a secondary consequence of computation. In the literature, this emphasis appears in several forms: protocols among autonomous principals in open sociotechnical systems, global choreographies for distributed applications, first-class user interactions in UI software, bounded-choice constructs in imperative and object-oriented languages, dialogic runtime constructs such as Interactors, and architectures in which signals, actors, and typed documents delimit interaction semantics (&&&^^^^9query9^^^^&&&, &&&^^^^9 choreographies Interacto BSPL9^^^^&&&, &&&^^^^9max_results9^^^^&&&). Across these strands, a recurrent objective is to make interaction structures explicit, analyzable, and separable from local internals.

^^^^9\9^^^^. Conceptual scope and recurring commitments

A central motivation for IOP is the claim that established software engineering is “rooted in a conceptually centralized way of thinking,” where the primary artifact is a specification of a machine that meets stated requirements (&&&^^^^9query9^^^^&&&). That framing is described as a mismatch for open sociotechnical systems, because such systems involve “multiple autonomous social participants or principals” and “no central machine governs the behaviors of the various principals” (&&&^^^^9query9^^^^&&&). In that strand, IOP operationalizes Interaction-Oriented Software Engineering by programming protocols, not a single locus of control.

Other strands use the term more broadly but preserve the same shift of emphasis. Choreographic work treats IOP as programming “from a global point of view,” where the primary abstraction is the interaction pattern among distributed roles and local implementations are derived by projection (&&&^^^^9query9^^^^&&&, &&&^^^^9 choreographies Interacto BSPL9^^^^&&&). UI-oriented work treats interactions themselves—not raw events—as first-class abstractions with behavior, state, typed data, and bindings to commands (&&&^^^^9max_results9^^^^&&&). Work on bounded-choice statements describes programs as “finite, guided dialogues with users,” with each interaction step presenting a controlled set of choices (&&&^^^^9\9query9^^^^&&&). Logic Interactors define programming as “a dialog between simple, self-contained, autonomous building blocks” (&&&^^^^9\9\9^^^^&&&).

This suggests that IOP is not a single formalism but a research family organized around a common inversion: interaction is specified directly, while algorithmic control, internal state evolution, and component implementation are treated as subordinate or encapsulated concerns.

Strand	Primary abstraction	Representative papers
Open sociotechnical systems	Protocols, roles, messages, social meanings	(&&&^^^^9query9^^^^&&&, &&&^^^^9\9^^^^&&&)
Distributed choreographies	Global interaction descriptions and projection	(&&&^^^^9query9^^^^&&&, &&&^^^^9 choreographies Interacto BSPL9^^^^&&&)
User interaction programming	UserInteraction, commands, bounded choices, interactive objects	(&&&^^^^9max_results9^^^^&&&, &&&^^^^9\9query9^^^^&&&, &&&^^^^9\9\9^^^^&&&)
Semantic/runtime models	Interaction semantics, Interactors, signals and actors	(&&&^^^^9\99^^^^&&&, &&&^^^^9\9\9^^^^&&&, &&&^^^^9 OR \9\9^^^^&&&)

^^^^9 OR \9^^^^. Protocols, commitments, and accountability

In the IOSE line of work, specifying a system amounts to specifying “the interactions among the principals as protocols,” with roles, messages, and social meanings made explicit (&&&^^^^9query9^^^^&&&). The protocol determines the social state; there is “no central machine that controls it.” The core formal construct is the social commitment

PRESERVED_PLACEHOLDER_^^^^9query9^^^^

where debtor PRESERVED_PLACEHOLDER_^^^^9\9^^^^ commits to creditor PRESERVED_PLACEHOLDER_^^^^9 OR \9^^^^ that if antecedent PRESERVED_PLACEHOLDER_^^^^9 choreographies Interacto BSPL9^^^^ becomes true, PRESERVED_PLACEHOLDER_^^^^9max_results9^^^^ will bring about consequent PRESERVED_PLACEHOLDER_^^^^9sort_by9^^^^ (&&&^^^^9query9^^^^&&&). Primitive operations include Create, Release, Cancel, Delegate, and Assign. Lifecycle progression is driven by communications’ meanings, and discharge occurs when the consequent is brought about after the antecedent.

The same work reinterprets classical software-engineering principles in interaction-oriented terms. Accountability modularity makes the principal the unit of modularity and accountability. Abstraction is achieved through explicit social meaning, and “solely social meaning” requires that ordering or temporal constraints be expressed through commitments rather than separate control-flow prescriptions. Separation of social and technical concerns distinguishes principals, which bear accountability, from technical components controlled by principals. Encapsulation prohibits reference to principal internals such as goals, intentions, or internal control logic; compliance must be checkable from observable communications (&&&^^^^9query9^^^^&&&).

These principles determine a characteristic implementation style. Principal-side software exposes typed send/receive APIs per role, maintains a local commitments ledger, updates that ledger through a meaning function PRESERVED_PLACEHOLDER_^^^^9relevance9^^^^, and integrates a compliance monitor that determines from observed communications whether commitments are satisfied or violated (&&&^^^^9query9^^^^&&&). No centralized enforcement is assumed; each principal monitors commitments it owes and those owed to it. Observability is supported by secure logging, and protocols may define sanctions or remediation messages whose meanings create new commitments.

The appointment-scheduling example is the canonical illustration. Roles are physician PRESERVED_PLACEHOLDER_^^^^9query9^^^^ and patient PRESERVED_PLACEHOLDER_^^^^9\9^^^^; messages include requestAppointment, availableSlots, selectSlot, and confirmSlot. Message meanings create commitments such as

$$C(\mathit{pat}, \mathit{phy}, \top, \mathit{showUp}(\mathit{pat}, s))$$

and

PRESERVED_PLACEHOLDER_^^^^9\9query9^^^^

Temporal ordering can also be embedded in commitments, for example

PRESERVED_PLACEHOLDER_^^^^9\9\9^^^^

where “PRESERVED_PLACEHOLDER_^^^^9\9 OR \9^^^^” denotes “occurs before” (&&&^^^^9query9^^^^&&&).

A later multiagent-systems toolsuite preserves the protocol-centered view but shifts from commitments to information causality and integrity via BSPL, the Blindingly Simple Protocol Language (&&&^^^^9\9^^^^&&&). A BSPL protocol is PRESERVED_PLACEHOLDER_^^^^9\9 choreographies Interacto BSPL9^^^^, where messages are annotated with in and out parameters. Sending is enabled when all in parameters are already bound locally and all out parameters are unbound. This operationalization preserves autonomy and loose coupling: message ordering is emergent rather than stipulated, and agents enact roles while remaining free to decide when to communicate according to local circumstances.

^^^^9 choreographies Interacto BSPL9^^^^. Choreographies and adaptive distributed interaction

A second major line of IOP treats interaction as a global choreography. Here the defining idea is that a distributed system is programmed “from a global viewpoint,” as a single description of how all roles exchange messages and perform local computations (&&&^^^^9 choreographies Interacto BSPL9^^^^&&&). At the specification level, a communication is atomic, not decomposed into separately programmed send and receive actions. Projection then derives a local process for each participant.

The Dynamic Interaction-Oriented Choreography language, DIOC, includes interactions, sequential and parallel composition, assignments, conditionals, while-loops, and updatable scopes of the form scope@R { I } (&&&^^^^9 choreographies Interacto BSPL9^^^^&&&). In the earlier AIOC/AIOCJ presentation, scopes are written scope@r { C } prop { P }, with a designated coordinator role and properties usable by adaptation rules (&&&^^^^9query9^^^^&&&). Runtime adaptation is externalized: new choreography fragments may replace marked scopes, and adaptation servers may add or withdraw rules while the application runs.

The central structural condition is connectedness. In the AIOCJ presentation, connectedness is a syntactic well-formedness condition ensuring that sequences are properly stitched through interactions and that parallel branches do not introduce causality-breaking races (&&&^^^^9query9^^^^&&&). In the DIOC presentation, connectedness requires that for every sequential composition PRESERVED_PLACEHOLDER_^^^^9\9max_results9^^^^, every final role-pair of PRESERVED_PLACEHOLDER_^^^^9\9sort_by9^^^^ and every initial role-pair of PRESERVED_PLACEHOLDER_^^^^9\9relevance9^^^^ share at least one role (&&&^^^^9 choreographies Interacto BSPL9^^^^&&&). The paper states that connectedness checking takes time PRESERVED_PLACEHOLDER_^^^^9\9query9^^^^, where PRESERVED_PLACEHOLDER_^^^^9\9\9^^^^ is the number of nodes in the abstract syntax tree of the choreography (&&&^^^^9 choreographies Interacto BSPL9^^^^&&&).

Projection yields DPOC local processes with indexed programmer operations and indexed auxiliary operations for conditionals, loops, and scope coordination. The principal formal result is: for each initial, connected DIOC process PRESERVED_PLACEHOLDER_^^^^9\99^^^^, each state PRESERVED_PLACEHOLDER_^^^^9 OR \9query9^^^^, and each set of updates PRESERVED_PLACEHOLDER_^^^^9 OR \9\9^^^^, the DIOC system PRESERVED_PLACEHOLDER_^^^^9 OR \9 OR \9^^^^ and the DPOC system PRESERVED_PLACEHOLDER_^^^^9 OR \9 choreographies Interacto BSPL9^^^^ are weak system bisimilar (&&&^^^^9 choreographies Interacto BSPL9^^^^&&&). Corollaries include deadlock freedom, race freedom, termination under the stated conditions, and orphan-message freedom for terminating runs.

AIOCJ instantiates this theory in Jolie and provides an IDE, compiler, adaptation manager, and adaptation servers (&&&^^^^9query9^^^^&&&). The ^^^^9 OR \9query9\9max_results9^^^^ framework paper reports that scopes introduce substantial overhead relative to code with no scopes: in the pipe scenario, context ^^^^9 OR \9^^^^ versus context ^^^^9\9^^^^ is “≈^^^^9\9 choreographies Interacto BSPL9^^^^× slower”; in fork-join, “≈^^^^9sort_by9^^^^.^^^^9sort_by9 slower.” Adding an adaptation server yields “≈^^^^9\99^^^^% decay” in pipe and “≈^^^^9\9query9^^^^% decay” in fork-join. When adaptation occurs, code transfer and embedding dominate the additional cost: in pipe, context ^^^^9max_results9^^^^ is “≈^^^^9\9^^^^.^^^^9max_results9 slower than Context ^^^^9 choreographies Interacto BSPL9^^^^,” and in fork-join, “≈^^^^9 OR \9^^^^.9× slower than Context ^^^^9 choreographies Interacto BSPL9^^^^” (&&&^^^^9query9^^^^&&&). Those costs are presented as the price of globally coordinated safe adaptation.

A common misunderstanding is to equate choreographic IOP with any decentralized message-passing system. The choreographic literature is more specific: the interaction structure is globally specified first, local code is secondary, and safety properties are obtained by projection rather than retrofitted through monitoring or ad hoc synchronization (&&&^^^^9query9^^^^&&&, &&&^^^^9 choreographies Interacto BSPL9^^^^&&&).

^^^^9max_results9^^^^. User-facing interaction as a program construct

A separate research line applies IOP to direct user interaction. In the bounded-choice work, imperative programs are extended with

PRESERVED_PLACEHOLDER_^^^^9 OR \9max_results9^^^^

a first-class statement for keyboard-driven bounded choice (&&&^^^^9\9query9^^^^&&&). The core syntax is

PRESERVED_PLACEHOLDER_^^^^9 OR \9sort_by9^^^^

and the high-level execution clause is

PRESERVED_PLACEHOLDER_^^^^9 OR \9relevance9^^^^

where PRESERVED_PLACEHOLDER_^^^^9 OR \9query9^^^^ is chosen by keyboard input. If PRESERVED_PLACEHOLDER_^^^^9 OR \9\9^^^^, the formal semantics leaves the program state unchanged. The explicit goal is to replace unbounded read(x)/scan(x) patterns and their associated validation code with finite, guided dialogues (&&&^^^^9\9query9^^^^&&&).

The same paper reports a small empirical comparison for student implementations of a typical ATM program with five bounded-choice interactions. Program length in C is given as (^^^^9\9 OR \9query9^^^^,^^^^9\9 choreographies Interacto BSPL9query9^^^^,^^^^9\9 choreographies Interacto BSPL9sort_by9^^^^,^^^^9\9max_results9 OR \9^^^^,^^^^9\9sort_by9max_results9^^^^) with average ^^^^9\9 choreographies Interacto BSPL9query9^^^^.^^^^9relevance9^^^^, whereas C^BI is (^^^^9\9\9 choreographies Interacto BSPL9^^^^,^^^^9\9\9sort_by9^^^^,^^^^9\9 OR \9 choreographies Interacto BSPL9^^^^,^^^^9\9 OR \99^^^^,^^^^9\9 choreographies Interacto BSPL9 OR \9^^^^) with average ^^^^9\9 OR \9 OR \9^^^^.^^^^9max_results9^^^^; the text states that C^BI codes are “typically ~^^^^9\9query9^^^^% shorter.” Work time in hours is C (^^^^9\9^^^^.^^^^9relevance9^^^^,^^^^9\9^^^^.^^^^9\9^^^^,^^^^9 OR \9^^^^.^^^^9max_results9^^^^,^^^^9 OR \9^^^^.^^^^9sort_by9^^^^,^^^^9 OR \9^^^^.^^^^9\9^^^^) → average ^^^^9 OR \9^^^^.^^^^9 OR \9^^^^ and C^BI (^^^^9\9^^^^.^^^^9 OR \9^^^^,^^^^9\9^^^^.^^^^9max_results9^^^^,^^^^9\9^^^^.^^^^9sort_by9^^^^,^^^^9\9^^^^.^^^^9relevance9^^^^,^^^^9 OR \9^^^^.^^^^9\9^^^^) → average ^^^^9\9^^^^.^^^^9sort_by9^^^^, with the summary that C^BI takes “<^^^^9query9query9^^^^% as long as C” (&&&^^^^9\9query9^^^^&&&).

In object-oriented form, interactive objects are introduced through a choice-disjunctive declaration

PRESERVED_PLACEHOLDER_^^^^9 OR \99^^^^

resolved by the environment at object creation time (&&&^^^^9\9\9^^^^&&&). The proposal describes an interactive object as one whose structure or behavior is intentionally left under-specified until construction, when the environment chooses a branch. After selection, “the object is fixed,” and later computation proceeds as in ordinary OO. This is a construction-time interpretation of interaction rather than an event-driven one.

Interacto generalizes the same orientation to sophisticated UIs by reifying the interaction itself (&&&^^^^9max_results9^^^^&&&). A UserInteraction is a stateful object with behavior, typically modeled as an FSM, and typed InteractionData. A Command encapsulates state change and optional undo/redo. An InteractoBinding “turns the executions of one user interaction into (undoable) command instances,” and a fluent binder configures using, toProduce, when, first, then, end, cancel, continuous, throttle, strictStart, and related options (&&&^^^^9max_results9^^^^&&&). The interaction life cycle is

PRESERVED_PLACEHOLDER_^^^^9 choreographies Interacto BSPL9query9^^^^

The framework reports both industrial-style and experimental results. In LaTeXDraw, a ^^^^9 choreographies Interacto BSPL9sort_by9^^^^k LOC interactive vector editor, the JavaFX version uses ^^^^9 OR \9 OR \9max_results9^^^^ bindings across ^^^^9max_results9sort_by9^^^^ controllers, producing ^^^^9 choreographies Interacto BSPL9query9^^^^ command types. Controller LOC is ^^^^9sort_by9relevance9query9query9^^^^ for a callback-only port versus ^^^^9max_results9query9query9query9^^^^ for Interacto; mean cyclomatic complexity is ^^^^9 OR \9^^^^.^^^^9sort_by9sort_by9^^^^ versus ^^^^9\9^^^^.^^^^9\99^^^^; LCOM is ^^^^9\9^^^^.^^^^9\9relevance9^^^^ versus ^^^^9\9^^^^.^^^^9max_results99^^^^. A Wilcoxon signed-rank test on ^^^^9max_results9max_results9query9^^^^ GUI tests × ^^^^9\9query9^^^^ runs reports “no significant overhead” with p = ^^^^9query9^^^^.9^^^^9max_results9query9 OR \9^^^^ (&&&^^^^9max_results9^^^^&&&). In a controlled experiment with ^^^^9max_results9max_results9^^^^ master students, Interacto-Angular is reported as ^^^^9\9 OR \9^^^^.^^^^9max_results9^^^^% faster overall with PRESERVED_PLACEHOLDER_^^^^9 choreographies Interacto BSPL9\9^^^^, p<^^^^9query9^^^^.^^^^9query9query9\9^^^^; for undo/redo tasks it is ^^^^9\9 OR \9^^^^.^^^^9relevance9^^^^% faster, with PRESERVED_PLACEHOLDER_^^^^9 choreographies Interacto BSPL9 OR \9^^^^, p=^^^^9query9^^^^.^^^^9query9 OR \99^^^^ (&&&^^^^9max_results9^^^^&&&).

These user-facing strands share a precise claim: the interaction step, not the raw event or unstructured input primitive, is the unit of design, implementation, and testing.

^^^^9sort_by9^^^^. Semantic models and interaction runtimes

Some IOP work is primarily semantic. In the IoT interaction-semantics paper, meaning is not transported with signals; it is “locally attributed by processing” in the receiver’s context (&&&^^^^9\99^^^^&&&). A system is characterized by the tuple

PRESERVED_PLACEHOLDER_^^^^9 choreographies Interacto BSPL9 choreographies Interacto BSPL9^^^^

with signals over discrete time and a computable mapping

PRESERVED_PLACEHOLDER_^^^^9 choreographies Interacto BSPL9max_results9^^^^

The architecture derived from this model distinguishes vertical “Use + Observation” interactions from horizontal “Mutual Hinting” protocols. Top-down interactions are deterministic and synchronous through operations and exceptions; bottom-up interactions are nondeterministic and asynchronous through generic or specific events. The paper explicitly states that if eventing is absent and state changes must be signaled via explicit calls, “layering becomes unprovable” (&&&^^^^9\99^^^^&&&).

Logic Interactors provide a different runtime interpretation. An Interactor is “an abstraction of answer generation and refinement in Logic Engines,” supporting the view that programming is “a dialog between simple, self-contained, autonomous building blocks” (&&&^^^^9\9\9^^^^&&&). The basic API comprises new_engine, get, and stop, extended with return(Term) for suspension and result transfer, plus to_engine and from_engine for bidirectional communication. The engine and client cooperate in a mixed-initiative exchange: the client creates engines, injects executable data, and harvests answers; the engine can suspend and resume computations, return intermediate results, and maintain its own private search state (&&&^^^^9\9\9^^^^&&&).

FRJ, the calculus unifying functional reactive programming, actors, and object-oriented programming, gives yet another semantics of interaction (&&&^^^^9 OR \9\9^^^^&&&). Signals are explicit time-varying values and form the “functional boundary between imperative and functional code.” Reference capabilities (imm, read, mut, capsule) control aliasing and mutability, while object capabilities control I/O. The system claims three properties: deterministic behavior for expressions whose input is pure, avoidance of data races and synchronization issues, and confinement of nondeterminism to actor state mutated according to message-delivery order (&&&^^^^9 OR \9\9^^^^&&&). In that sense, FRJ is interaction-oriented not because it centers protocols or commitments, but because it makes signals and asynchronous messages explicit, typed, and semantically delimited.

A plausible implication is that the semantic core of IOP varies substantially by domain. In sociotechnical settings, interaction semantics is social and normative; in choreographies, it is global control and causal structure; in UI work, it is lifecycle and command binding; in logic and reactive calculi, it is dialogic suspension, signals, and message delivery. The shared commitment is explicit interaction structure, not a single universal ontology of interaction.

^^^^9relevance9^^^^. Verification results, empirical findings, and unresolved questions

Verification is one of the strongest recurring themes in IOP. In the BSPL toolsuite, Tango checks two protocol-level properties: safety, formalized as the absence of multiple bindings for any parameter, and liveness, formalized as the ability of any enactment to progress to completion (&&&^^^^9\9^^^^&&&). For the Flexible Purchase protocol, bspl verify liveness returns {'live': True, 'checked': ^^^^9query9^^^^, 'maximal paths': ^^^^9\9^^^^, 'elapsed': ^^^^9query9^^^^.^^^^9query9query9\9query9 choreographies Interacto BSPL9\9^^^^}, while bspl verify safety returns {'safe': True, 'checked': ^^^^9query9^^^^, 'maximal paths': ^^^^9\9^^^^, 'elapsed': ^^^^9query9^^^^.^^^^9query9query9query99relevance9relevance9^^^^}. bspl verify all_paths reports ^^^^9max_results9query9^^^^ paths, longest path: ^^^^9relevance9^^^^, maximal paths: ^^^^9\9 OR \9^^^^. For the buggy variant, Tango returns explicit counterexamples for both liveness and safety (&&&^^^^9\9^^^^&&&).

The choreographic line offers structural guarantees rather than parameter-binding guarantees. The DIOC/DPOC correctness theorem yields weak system bisimilarity between choreography and projection; corollaries establish deadlock freedom, race freedom, termination under the stated assumptions, and orphan-message freedom (&&&^^^^9 choreographies Interacto BSPL9^^^^&&&). AIOCJ adds runtime adaptation but retains deadlock-freedom by construction when connectedness and rule constraints hold (&&&^^^^9query9^^^^&&&).

UI-oriented IOP emphasizes testability and maintainability. Interacto provides binding test oracles, observable binding contexts, a command-test framework, and generated test scaffolds; LaTeXDraw command tests are reported at 9^^^^9\9^^^^.^^^^9 choreographies Interacto BSPL9^^^^% lines coverage (&&&^^^^9max_results9^^^^&&&). The bounded-choice work offers shorter code and lower work time for the ATM example (&&&^^^^9\9query9^^^^&&&). These are not protocol-verification results, but they serve the same broader objective: interaction logic should be explicit enough to test, analyze, and refactor without reconstructing it from low-level callbacks or validation code.

Several limitations recur. The IoT interaction-semantics paper explicitly does not treat quality aspects such as performance and security, and notes that natural-language vagueness and frequent context switching go beyond formal protocols (&&&^^^^9\99^^^^&&&). The dynamic-choreography theory assumes total expressions and functions; richer error handling is future work (&&&^^^^9 choreographies Interacto BSPL9^^^^&&&). Interacto reports a learning curve and notes that for very simple tasks the interaction-command machinery may feel heavier than direct data binding (&&&^^^^9max_results9^^^^&&&). The bounded-choice paper presently centers natural-number indices and treats richer device support as extension points (&&&^^^^9\9query9^^^^&&&).

A common misconception is that IOP is simply event-driven programming under a different name. The surveyed literature does not support that reduction. Event-driven frameworks typically expose callbacks on low-level events, whereas several IOP formulations insist on interaction as a higher-order abstraction: commitments with social meaning, globally specified conversations, bounded-choice statements, first-class UserInteraction objects, or dialogic logic engines (&&&^^^^9query9^^^^&&&, &&&^^^^9max_results9^^^^&&&, &&&^^^^9\9\9^^^^&&&). Another misconception is that decentralization implies semantic minimalism. In fact, many IOP approaches make semantics more explicit precisely to preserve autonomy without central control: commitments, protocol parameters, typed documents, and execution models are all devices for replacing hidden coupling with analyzable interaction structure (&&&^^^^9query9^^^^&&&, &&&^^^^9\99^^^^&&&, &&&^^^^9\9^^^^&&&).

Taken together, the literature presents IOP as a sustained attempt to move interaction from the periphery of programming models to their center. The result is not a single canonical paradigm, but a technically coherent research direction in which protocols, conversations, user interactions, signals, and adaptive choreographies become the definitive objects of specification, implementation, and verification.