In software engineering, a persistent "semantic gap" exists between what a user intends for a system to do and how that system is actually implemented. As Liu et al. observe, there is a disconnect between high-level functional requirements and the technical structural design of software architecture. This misalignment means that even when a system is "finished," it may not reflect the intended user-perceivable behavior, leading to systems that are difficult to evolve and maintain.
This research direction focuses on creating formal and automated bridges to ensure that the "what" (specification) and the "how" (implementation) remain in lockstep.
The Nature of the Disconnect
The gap is not merely a matter of poor communication; it is a fundamental difference in representation. Balzer et al. argue that while users naturally describe goals, formal systems require an exhaustive description of the process. This "clerical burden" of writing formal specifications often results in developers skipping the design phase entirely, leading to code that lacks a clear rationale.
This disconnect manifests in several critical ways:
- Execution Semantics: In smart contract development, Mavridou et al. identify a gap between a developer’s conceptual model and the low-level execution logic of the Ethereum Virtual Machine. This leads to subtle bugs, like re-entrancy attacks, where the code technically functions but violates the intended business logic.
- Business-IT Alignment: In enterprise settings, Brambilla et al. note that abstract business process models often fail to map directly to web application implementations, making it hard to enforce organizational roles.
- Safety Risks: For safety-critical systems like medical infusion pumps, Gunter et al. show that the "requirements gap" can hide ambiguities that only surface as catastrophic failures during operation.
Bridging the Gap via Model-Driven Abstractions
One primary strategy for closing this gap is to elevate the level of abstraction so that the "design" is the "implementation."
Liu et al. propose using "features" as first-class entities that bridge requirements and architecture. By mapping architectural decisions directly to user-perceivable features, the system becomes more traceable. Similarly, Mavridou et al. developed FSolidM, which allows developers to design smart contracts as Finite State Machines (FSMs). By generating code automatically from these high-level models, the framework ensures that the final implementation adheres to the verified design.
In the enterprise domain, Acerbis et al. demonstrate that shifting focus from manual coding to visual modeling can achieve up to a 90% code automation rate. This approach, known as Model-Driven Development (MDD), reduces the communication gap between business stakeholders and technical teams by using the model as the single source of truth.
Ensuring Consistency Through Formal Verification
Even when models exist, they often become "ignored artifacts" as the codebase evolves. To prevent this, researchers have developed mechanisms to enforce consistency between different representations of a program.
Sun et al. introduced Clover, a closed-loop framework that checks for consistency between natural language docstrings, executable code, and formal mathematical specifications. By using Large Language Models (LLMs) alongside formal verification tools, the authors ensure that these three distinct representations are perfectly aligned.
For existing systems, Hackett et al. developed OmniLink, which validates unmodified concurrent code against high-level TLA+ specifications. It uses "timeboxes" (timestamps for API calls) to bridge the gap between abstract state transitions and real-world multithreaded execution, catching subtle concurrency bugs that traditional testing misses.
The Future: Intent-Oriented Programming
The ultimate goal of this research is to democratize software creation by allowing users to program via intent rather than syntax. Beheshti proposes Natural Language-Oriented Programming (NLOP), where generative AI translates high-level problem descriptions directly into microservices.
This echoes the vision of the "Programmer's Apprentice" described by Katz et al., a system that captures design rationale (the why) alongside the code (the how). By maintaining explicit links between abstract requirements and their implementations, these systems aim to ensure that software remains a faithful reflection of human intent throughout its entire lifecycle.
Key Foundational Work
Informality in Program Specifications (1977) — contributed 1 concept elements to this direction.
Mapping Requirements to Software Architecture by Feature-Orientation (2003) — contributed 1 concept elements to this direction.