Ingest: Inter-language Reflection: A Conceptual Model and Its Implementation

Type: kb/sources/types/ingest-report.md

Source: gybels-et-al-2006-inter-language-reflection.md Captured: 2026-07-14 From: https://rmod-files.lille.inria.fr/Team/Texts/Papers/Gybe06aSymbioticReflectionESUGJournal.pdf

Classification

Genre: scientific-paper -- a peer-reviewed conceptual model with two implementation cases (Agora/Java and SOUL/Smalltalk). Domains: reflection, linguistic-symbiosis, protocol-mapping Author: Kris Gybels, Roel Wuyts, Stéphane Ducasse, and Maja D’Hondt consolidate the earlier symbiotic-reflection work into a published model that explicitly separates base-level data mappings from meta-level protocol mappings.

Summary

Gybels et al. define inter-language reflection as traditional reflection in each of two languages combined with linguistic symbiosis between them. Traditional reflection supplies causal connection and reflective access; linguistic symbiosis supplies transparent exchange of data and invocation of behavior. The conceptual advance is to decompose that symbiosis into a base-level data mapping and a meta-level protocol mapping, making clear that apparent native values require the other interpreter's operations to apply to their meta-representations. This is the strongest source here for the conditions of cross-language reflection and for separating representation transfer from operation/behavior transfer.

Connections Found

The paper supplies the mature technical model for Cross-representational reflection and adds a useful qualification to Unified calling conventions enable bidirectional refactoring: sharing a callable surface requires both data mappings and protocol mappings when regimes disagree about values and behavior. Representational form constrains the proposed generalization beyond programming languages.

Inherited Vocabulary

Exact terms and definitions

  • Meta programming: reasoning about a computational system; unlike reflection, it may use a different language but lacks causal connection (printed pp. 109–110; PDF pp. 1–2).
  • Reflection: in the paper's traditional form, base and meta languages are the same and the base program is causally connected to its representation as meta-program data. Inspection alone is introspective; modification is intercessory (printed p. 110; PDF p. 2).
  • Inter-language reflection: reflection between two different languages, possibly different paradigms, extending causal connection across them so a program in either language can reason about and change a program in the other (printed pp. 110–111; PDF pp. 2–3).
  • Traditional reflection + linguistic symbiosis: the paper's explicit equation for inter-language reflection. Each language must permit programs to observe and manipulate data of its own execution; the two languages must transparently exchange data and invoke each other's behavior (printed p. 111; PDF p. 3).
  • Linguistic symbiosis: two languages transparently invoke one another's behavior and exchange data, including access through their reflective interfaces—not only basic base-level values and behavior (printed pp. 111–112; PDF pp. 3–4).
  • Data mapping: values from either language appear as seemingly native data in the other, so operations in B on data from A translate to operations in A, and vice versa (printed p. 112; PDF p. 4).
  • Protocol mapping: the implementation-level condition behind data mapping: meta-representations pass between interpreters and the receiving interpreter's meta-operations become applicable to them (printed p. 112; PDF p. 4).
  • Base-level and meta-level reflective access: linguistic symbiosis between reflective languages exposes not only each other's ordinary values/behavior but also data and behavior available through reflective interfaces (printed p. 111; PDF p. 3).

Necessary conditions versus illustrative features

The conceptual model requires two traditionally reflective languages, causal connection extended across them, transparent bidirectional data exchange and behavior invocation, data mapping, protocol mapping, and access to both ordinary and reflectively exposed data/behavior (printed pp. 110–112; PDF pp. 2–4). The paper also assumes languages with explicit meta-representations of evaluation operations, typical of interpreted or bytecode-interpreted languages (printed p. 111; PDF p. 3); this is an explicit applicability condition, not a universal fact about all languages. Agora/Java and SOUL/Smalltalk, wrappers, shared implementation languages, automatic mappings, and the collapsing of one meta-level into the other's base level are implementation strategies or cases, not the abstract definition (printed pp. 112–123; PDF pp. 4–15).

System boundary and people

The conceptual boundary contains languages A and B at base level, each language's reflective/meta representation, the two interpreters or equivalent meta-level machinery, and the mappings that connect values and operations. Actual implementations may fold one language's meta level into the other's base level, but the model keeps them separate to expose the mechanism (printed p. 123; PDF p. 15). People are neither reflective components nor mapped entities; developers and programmers use the languages from outside the modeled causal system.

Causal topology

Within each language, traditional reflection causally connects execution and its meta-representation. Across languages, data mappings let A-values appear in B and B-values appear in A; protocol mappings translate the receiving interpreter's operations onto foreign meta-representations. Because the mapped surface includes reflective interfaces, a program in A can reach B's causally connected execution data/behavior and vice versa (printed pp. 110–112; PDF pp. 2–4). In concrete implementations wrappers can map base operations directly to meta operations, shortening but not eliminating this topology (printed p. 123; PDF p. 15).

Constraints on later Commonplace vocabulary

Any proposed cross-representational reflection should distinguish (1) a data/representation mapping, (2) a protocol or operation mapping, and (3) causal connection to what those representations govern. Bidirectionality must cover both values and behavior, including whatever counts as reflective/meta-level behavior. A shared repository, readable pair, or common calling convention is not by itself inter-language reflection. Generalizing from languages to prose and formal artifacts must specify the analogue of interpreters, meta-representations, mappings, and causal connection. The paper provides no basis for including humans inside the system boundary and no ruling on whether Commonplace is reflective or reflexive.

Extractable Value

  1. Two-mapping decomposition -- data mapping and protocol mapping are separate requirements, preventing “same interface” from hiding operation-level incompatibilities. [quick-win]
  2. Reflection-versus-meta-programming discriminator -- different-language reasoning without causal connection remains meta-programming, not reflection. [quick-win]
  3. Reflective-interface reach -- cross-language reflection must expose base-level and meta-level behavior, not just ordinary data exchange. [deep-dive]
  4. Conceptual-versus-implementation boundary -- a clean layered model may remain analytically necessary even when implementations collapse levels for convenience. [just-a-reference]
  5. Applicability limit -- explicit evaluation meta-representations are assumed, which a prose/code generalization must replace with a stated analogue rather than silently inherit. [quick-win]

Limitations (our opinion)

The model is supported by two language pairs but not by a systematic comparison against alternative interoperability architectures. Its transparency criterion is partly a usability property and does not by itself establish reflective causal connection; the latter still comes from traditional reflection in each language. The examples are programming languages with explicit interpreters and meta-level protocols, so direct transfer to asynchronous, human-mediated prose and code artifacts risks turning “mapping” into analogy without an operational account. The paper also says little about authority, verification, persistence, or delayed behavioral effects central to Commonplace's representational-form analysis.

Use the data-mapping/protocol-mapping/base-and-meta-access decomposition to constrain Cross-representational reflection, while leaving Commonplace's satisfaction of those conditions explicitly undecided.