Decoupling Core Logic from Execution Contexts

65 concepts59 papers1 proposal

Imagine building a house where the electrical wiring is permanently fused into the drywall patterns, and the plumbing is structurally bound to the specific shape of the kitchen sink. If you want to upgrade to a modern sink or change the wallpaper, you have to tear down the entire foundation of the house.

In software engineering, this structural fusion is known as logic tangling. For decades, systems have suffered from a fundamental anti-pattern: embedding core functional rules—the "business logic" or domain rules—directly inside the mechanisms responsible for displaying data, storing it, or transmitting it.

As early as 1980, Ball et al. observed in Representation of Task-Specific Knowledge in a Gracefully Interacting User Interface that hard-coding user interface logic directly into functional software tools creates massive development overhead and prevents the universal implementation of features like error recovery or help systems. When core logic is bound to its execution context, software becomes brittle, unmaintainable, and impossible to scale.

The Dimensions of Coupling

The literature identifies three primary axes where core logic frequently becomes entangled with external concerns:

  1. Logic-Presentation Coupling: This occurs when user interface (UI) flows are mixed with backend execution. Acerbis et al. note in Model-Driven Development Based on OMG's IFML with WebRatio Web and Mobile Platform that embedding business logic inside UI code creates disorganized systems that complicate long-term evolution. Similarly, Houde et al. highlight in Opportunities for Generative AI in UX Modernization 81-91 that legacy software modernization is severely bottlenecked by the difficulty of extracting functional requirements from presentation code without breaking the application.
  2. Logic-Data Coupling: When the rules governing how data is processed are tied to the physical layout or structure of that data, changes to the database break the application. Novak argued in Knowledge-Based Programming Using Abstract Data Types that forcing logic to depend on specific data structures (like nested lists or arrays) requires manual rewrites whenever representations change. In blackboard architectures, Corkill et al. demonstrated in Achieving Flexibility, Efficiency, and Generality in Blackboard Architectures that changing physical storage formats for performance optimization often forces a complete rewrite of the knowledge modules if they are tightly coupled to the database implementation.
  3. Logic-Implementation/Protocol Coupling: Core control algorithms are frequently bound to specific communication protocols or external APIs. The authors of xDevSM: Streamlining xApp Development With a Flexible Framework for O-RAN E2 Service Models show that tightly coupling control algorithms with specific communication protocols forces a complete rewrite of application logic whenever the underlying service model or data format changes.

The Mechanism of Disentanglement

To break these dependencies, researchers introduce abstract intermediate layers and declarative specifications that act as a buffer between logic and context.

Instead of a component directly calling a UI widget or a database query, it interacts with an abstract model. For example, Haesen et al. show in MuiCSer: A Process Framework for Multi-disciplinary User-Centred Software Engineering Processes that a model-based approach separates functional requirements from the presentation layer, allowing developers to efficiently create multiple UI variations without rebuilding the underlying technical framework.

TIGHTLY COUPLED (Rigid):
[ Core Business Logic ] <---> [ Platform-Specific UI / Data Layout ]

DECOUPLED (Flexible):
[ Core Business Logic ] <---> [ Abstract Model / API ] <---> [ Localized Adapters / UI ]

To handle cross-cutting concerns like logging, security, or error recovery without cluttering the core logic, researchers leverage aspect-oriented paradigms. Cao et al. explain in An Aspect-oriented Software Architecture Description Language AO-ADL Based on XYZ how modularizing secondary concerns into independent "aspects" prevents code scattering and tangling, keeping core functionality clean and readable.

Why Disentanglement Works: The Intuition of Orthogonality

To understand why this works, consider the mathematical concept of orthogonality. If you have $M$ business rules and $N$ different user interfaces or delivery channels (e.g., web, mobile, voice), a tightly coupled system requires writing and maintaining up to $M \times N$ distinct code paths. Every time a business rule changes, multiple interface implementations must be updated.

By enforcing interaction-logic decoupling, as articulated by Acerbis et al., the system architecture shifts from a multiplicative complexity ($M \times N$) to an additive complexity ($M + N$). The core business logic is written exactly once as a platform-independent model. Localized adapters or translation layers then map this invariant logic to specific delivery channels, as noted by Sparrow et al. in ISF special issue on enterprise services computing: Evolution and challenges.

This separation also unlocks the ability to optimize components independently. As Mark demonstrated in The Reformulation Approach to Building Expert Systems, decoupling rule selection logic from rule execution logic allows developers to implement high-performance, specialized algorithms internally without changing how the system interacts with the outside world. By ensuring that the core logic does not know how data is stored or where it is displayed, both the logic and the execution context can evolve independently.

Key Foundational Work

Representation of Task-Specific Knowledge in a Gracefully Interacting User Interface (1980) — contributed 1 concept elements to this direction.
The Reformulation Approach to Building Expert Systems (1977) — contributed 1 concept elements to this direction.
History & citationVersion 2 · 2026-10-04

Current · Permanent link

  1. Version 2 (latest) · 2026-10-04 · 55 papers
  2. Version 1 · 2026-10-04 · 65 papers
Cite this direction

Latest version (a living page):

@misc{lacuna_separation_of_concerns_13014097,
  title = {separation of concerns},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/separation-of-concerns/rdr_13014097c8554560a92288f854dce086},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-20},
}

This exact version (version 2, frozen text):

@misc{lacuna_separation_of_concerns_13014097_v2,
  title = {separation of concerns},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/separation-of-concerns/rdr_13014097c8554560a92288f854dce086/v/2},
  note = {Version 2, frozen 2026-10-04. Accessed 2026-11-20},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake