JDomInO is presented, a bidirectional synchronization toolchain for tactical DDD that keeps a Java codebase and its domain model connected through a shared metamodel, with the goal of keeping the two in sync as the system evolves.
Abstract
Domain-Driven Design gives teams a shared vocabulary for complex business logic, but that vocabulary only stays useful as long as the model and the code agree with each other. In practice, they drift apart: code changes outpace the model, or model revisions never make it into the codebase. This paper presents JDomInO, a bidirectional synchronization toolchain for tactical DDD that keeps a Java codebase and its domain model connected through a shared metamodel, with the goal of keeping the two in sync as the system evolves. JDomInO generates Java code structure deterministically from a domain model (forward path) and reconstructs a domain model from existing Java code (reverse path). The forward path has been fully validated on a Hotel Management scenario covering all 12 building block types in the metamodel; the reverse path's mapping logic has passed unit testing, with end-to-end validation underway. We also outline how the structured domain model produced by JDomInO could serve as a precision context layer for AI code assistants, helping them respect aggregate boundaries and DDD semantics that raw source code alone does not convey.
Large language models generate code effectively but falter in enterprise settings that demand complex business rules, particularly in rule consistency and conflict detection. This study proposes the Atomic Logic Sheet (ALS), a structured representation of business logic, injected through the Hierarchical Business Logic Injection (H-BLI) framework. Four conditions were compared on a warehouse management domain, 20 runs each: requirements only; a natural-language design document; the same content with worked examples, anti-patterns, and an explicit conflict-handling directive in prose; and that content expressed in ALS. Conflict responses were adjudicated by two independent raters (κ = 0.993 and 1.000) and cross-checked against a byte-level code comparison. Logic compliance converged near 97% whenever a design document was supplied; conflict detection separated them: 10.0% and 43.1% for the requirements-only and plain-document conditions, and 100% for both content-bearing conditions, neither of which modified code. The two notations detected conflicts identically, and where they differed, the prose condition was better, so the effect follows the content a document is obliged to carry rather than its notation. A replication under a second model reproduced the gap between the requirements-only baseline and the full treatment, and a replication on independently designed conflicts reproduced the detection result for the document conditions; neither included the prose condition, so neither reproduces the comparison between notations. Schema deviation, however, was higher under ALS. As a single-domain study, replication elsewhere remains necessary.
Man-Su Kim, Museong Choi, Miseon Shim et al.· Electronics· 0 citations
Large Language Models are increasingly used to generate structured engineering artifacts, yet the instruction artifacts that govern this generation are rarely treated as modeling artifacts in their own right. They typically appear as monolithic prompt blocks, schemas, or informal examples. When tools, metamodels, APIs, or domain vocabularies evolve, stable domain concepts, volatile tool details, validators, and examples drift together in a single prompt contract. This paper puts forward the thesis that prompt-level instruction artifacts should be understood as versioned modeling languages: explicit artifacts that define the LLM-facing structure required to obtain tool-consumable outputs. We realize this idea through Modular Meta-Language-defined Structure Instructions (MMLDSI), a modular architecture that decomposes structured instructions into versioned modules with explicit interfaces, profiles, adapters, validators, examples, and deterministic rule-deck resolution. Changes to tools or domain concepts can then be represented at the affected modules and profiles rather than hidden inside whole-prompt rewrites. The approach is demonstrated in VR scene generation and automotive security modeling. Across a balanced 320-artifact VR subset, required-key validity reaches 88.1%, while a stricter prompt-contract audit accepts 80.9% and exposes remaining tool-readiness gaps. An offline monolith-to-modular pilot maps 12 legacy feature families and resolves 343 case-specific decks without dependency gaps. Our contribution is not another prompting technique, but a model-management perspective on instruction artifacts for evolving LLM toolchains.
Louis Burk, Alexander Fischer, Christoph Scharnagl et al.· Proceedings of the ACM/IEEE...· 0 citations
Evaluations of model-based engineering (MBE) typically report what a generator produces—coverage, artefacts emitted, lines generated. Yet under industrial delivery pressure much of that structure is later overwritten, bypassed, or absorbed into hand-written code, while other model-derived assets quietly endure. We argue the operationally meaningful question is not what a toolchain produces but what a delivered system retains—and that retention is readable directly from shipped code. A delivered model leaves a system two assets, structure and vocabulary, and each can fit the delivered code independently of the other: structural fit is conditional, while conceptual fit can persist after generated structure erodes. We introduce retention mining, a way to read a model’s payoff from the delivered system itself—scoring both by what was retained rather than what the generator emitted—operationalised by four repository-mined measures. On an industrial mobile health (mHealth) platform of heterogeneous backend services and a cross-platform client, the two axes come apart: more generated structure can accompany less retained vocabulary, yet model-derived names persist across every service and reach the client even where no structure did—so retention can reverse the verdict that production alone would report. We outline retention mining as an emerging method for studying the durable value of generative abstractions—model-based and, increasingly, LLM-based—across systems and over time.
Artur Boronat, Jawad Mustafa, Fola-Dami Eyitemi· Proceedings of the ACM/IEEE...· 0 citations
An airborne software development approach for manned and unmanned aerial vehicles aimed at reducing inconsistencies across system, model-based functional, and embedded software domains is presented and a repository-centered implementation to address recurring failure modes is proposed.
Nils Schlautmann, V. Sinitsyn, Benjamin Engelhard et al.· 0 citations
This paper reviews recent empirical literature to ask what the developer's job is shifting from typing code to directing agents that type code a change often summarized as a move from code generation to code orchestration.
P. N. Nesarajan, P. Thenmozhi, Shenbaga Priya et al.· International Journal of Inn...· 0 citations
The paper argues, on the evidence gathered so far, that formal rules in the mathematical language of B must remain the source of truth, while the language model serves as the fenced assistant in a distributed safety-critical railway system.
Thierry Lecomte, Vincent Germain· arXiv.org· 0 citations
We use cookies to run the site and, with your consent, for analytics and to show ads.
See our Cookie Policy.
