h t t p s : / / s c g . u n i b e . c h / a r c h i v e / p a p e r s / W u y t 0 1 a . p d f

Ingest: Symbiotic Reflection between an Object-Oriented and a Logic Programming Language

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

Classification

A workshop paper that defines a computational-reflection variant, proposes an implementation schema, and demonstrates it in SOUL/Smalltalk. Author: Roel Wuyts and Stéphane Ducasse report the SOUL implementation from the Software Composition Group and position the work against Maes, Smith, Steyaert, and reflective-language precedents.

Summary

Wuyts and Ducasse define symbiotic reflection as an extension of reflective interpretation in which a base language can manipulate not only its causally connected self-representation but also the distinct meta-language that implements it, so both languages can reason about and act on one another. Their SOUL/Smalltalk case introduces symbiotic introspection and symbiotic intercession, then treats entity transfer between different programming paradigms as an implementation obligation solved by an automatic upping/downing schema. The paper is a direct precursor for cross-representational reflection, but its boundary is a pair of computational languages and their interpreter; it does not include people or natural-language artifacts as system components.

Quotes

  • Source extract (verbatim): New to this approach is that any element of the imple- mentation language can be reasoned about and acted upon (not only the self representation), and that both languages are of different paradigms. Moreover, every language implementer that is faced with the problem of allowing the base language to access the underlying meta-language has to solve the problem of enabling entity transfer between both worlds. We propose a uniform schema, called upping/downing, to this problem that avoid explicit wrapping or typechecking.
  • Source location: Abstract (printed p. 1; PDF p. 1)
  • Source extract (verbatim): In symbiotic reflection, as the meta-language implements the base language and the base language can reason about and act on the meta-language, both the base language and the meta-language can then act and reason on each other.
  • Source location: §1.2, “Example Analysis” (printed p. 4; PDF p. 4)
  • Source extract (verbatim): Enabling the access and manipulation of down level structure (the object- oriented programming language) from the up level (the logic programming lan- guage) in a unified way is possible by following the simple transfer rule: upping a down entity should return an upped entity and downing an upped entity should return a down entity. Applied to SOUL, this rule reads: upping an object should return a term and downing a term should return an object.
  • Source location: §3.2, “The Upping/Downing Schema” (printed p. 7; PDF p. 7)

Connections Found

This source is the early technical anchor for Cross-representational reflection: causal connection and mutual access/action are stronger conditions than co-location or co-evolution. Representational form remains the local vocabulary for any later generalization, because the paper's distinction is between programming languages and paradigms rather than Commonplace's natural-language, symbolic, and distributed-parametric forms.

Inherited Vocabulary

Exact terms and definitions

  • Meta-programming language (M) and base language (B): M implements/interprets B; the interpreter's kind depends on which data B can manipulate (printed p. 5; PDF p. 5).
  • Causally connected: a computational system and its domain are linked so that a change in either has an effect on the other. The wording is explicitly bidirectional, not merely “representation influences execution” (printed p. 5; PDF p. 5).
  • Reflective system: a causally connected meta-system whose base system is itself (printed p. 5; PDF p. 5). Reflection is a program manipulating data that represents its state during execution; introspection observes/reasons about that state, intercession modifies execution state or interpretation, and reification encodes execution state as data (printed p. 6; PDF p. 6).
  • Self-representation: the causally connected representation of the reflective interpreter itself, distinct from ordinary base-level data (printed p. 6; PDF p. 6).
  • Symbiotic reflective interpreter: a reflective interpreter that can manipulate both its self-representation and the meta-language; because the meta-language implements the base language while the base language can reason about and act on the meta-language, both can reason about and act on each other (printed pp. 6–7; PDF pp. 6–7).
  • Symbiotic introspection: logic reasoning directly over the actual Smalltalk objects, not detached representations. Symbiotic intercession: logic-language operations modify code in the implementation language with immediate effect there (printed p. 4; PDF p. 4).
  • Up level / down level: view-neutral replacements for ambiguous base/meta roles. The down level is the object-oriented implementation language; the up level is the logic language it evaluates (printed p. 9; PDF p. 9).
  • Upping/downing: entity-transfer operations between the levels: upping an object returns a logic term; downing a term returns an object. Wrapping a plain object permits logical unification/interpretation, while downing an ex-nihilo term yields its implementing object (printed pp. 9–10; PDF pp. 9–10).

Necessary conditions versus illustrative features

Necessary in the paper's model are: a computational base/meta or up/down relation; causal connection to self-representation; access and action across the language boundary; entities from both languages manipulable in each; and a transfer mechanism that preserves usable identities/behavior across representations (printed pp. 5–10; PDF pp. 5–10). Different programming paradigms are the paper's focal case, but same-language reflective systems count as symbiotically reflective “because of their uniformity” (printed p. 7; PDF p. 7), so paradigm difference is not logically necessary. SOUL, Smalltalk, type snooping, scaffolding, second-order predicates, Turing completeness, implicit pattern matching, and automatic type-check avoidance are illustrative implementation features or benefits, not defining conditions (printed pp. 4, 10, 14; PDF pp. 4, 10, 14).

System boundary and people

The assumed system boundary encloses the SOUL program/interpreter, its causally connected self-representation, the Smalltalk implementation language, and the base/meta data and operations exchanged between them. The “user point of view” and “interpreter point of view” change which language is called base or meta (printed p. 9; PDF p. 9), but the human user is an external vantage point, not a component in the reflective causal loop. The paper therefore gives no warrant for treating operators, maintainers, or authors as system components; a human-inclusive boundary would be an additional thesis requiring other sources.

Causal topology

Classic reflection connects the interpreter/program to its own execution-state representation: changes to the represented domain affect the representation and intercession changes execution/meaning. Symbiotic reflection adds live cross-language paths: SOUL reasons over actual Smalltalk entities; SOUL modifications immediately change Smalltalk code; Smalltalk implements the SOUL interpreter; and SOUL can manipulate the implementing entities. Upping/downing carries entities across the level boundary, after which operations run at the down level and results are returned upward (printed pp. 4–10; PDF pp. 4–10). Mere detached description, one-way export, or offline synchronization does not match this topology.

Constraints on later Commonplace vocabulary

Later notes should reserve reflection for manipulation of a causally connected representation, distinguish introspection from intercession, and state the theory and system boundary under which “self” is identified. Cross-representational or symbiotic reflection should require mutual operative access, not merely natural-language artifacts and code describing one another. Entity mapping must be named as a mechanism rather than assumed. The paper does not decide whether Commonplace meets these conditions, does not include people inside the boundary, and does not license using reflexive as a synonym for its computational term reflective.

Extractable Value

  1. Necessary-condition test for stronger reflection claims -- causal connection plus operative self-representation distinguishes reflection from documentation, mirroring, or one-way generation. [quick-win]
  2. Cross-boundary action vocabulary -- symbiotic introspection and symbiotic intercession separate reasoning over the other regime from changing it. [quick-win]
  3. Entity-transfer obligation -- cross-representational claims must explain how entities retain usable identity and behavior across representations, not only assert that both forms exist. [deep-dive]
  4. Boundary-relative base/meta roles -- up/down terminology shows that base and meta roles can invert with viewpoint, so later notes must make the analytical viewpoint explicit. [just-a-reference]
  5. Human-boundary limitation -- the paper treats people only as users/viewpoints, preventing an unsupported jump to human-inclusive reflection. [quick-win]

Limitations (our opinion)

The paper is a conceptual and implementation report centered on one SOUL/Smalltalk system, without a comparative evaluation showing that its proposed necessary machinery is sufficient across architectures. Its examples demonstrate usefulness but do not test alternative entity-transfer designs or failures of causal connection. The relation is also intentionally simple—primarily objects reified as terms—and does not establish that the model transfers to natural-language artifacts, asynchronous repositories, human-mediated changes, or Commonplace's readable artifact loop. The terminology is valuable as a constraint, not proof that a broader system instantiates it.

Use this snapshot as the primary early-source anchor for Cross-representational reflection, explicitly testing each retained claim against causal connection, mutual access and action, entity transfer, and the stated system boundary.