tool engineering

This study investigates whether domain-specific languages (DSLs) enhance developers’ comprehension of data pipeline program structure. Method: A mixed-methods approach is employed—controlled experiments measure task accuracy, while structured surveys and qualitative coding analyze DSLs’ impact on domain experts’ structural awareness, accessibility, and alignment with mental models. Contribution/Results: This work provides the first empirical validation of systematic improvements in structural understanding of data pipelines afforded by DSLs. Results show statistically significant gains in comprehension accuracy (p < 0.01), driven by DSLs’ capacity to reinforce global program overviews, enforce syntactically constrained structures, and better align with users’ domain-specific mental models. Furthermore, DSLs lower the barrier to entry for programmers with limited experience, facilitate cross-tool knowledge transfer, and strengthen perception of dataflow structure.

This work addresses the frequent neglect of sampling strategy design and generalizability in software engineering research, which often undermines the representativeness of empirical findings. To remedy this, the paper introduces a domain-specific language (DSL) that explicitly models complex sampling workflows over code repositories through composable sampling operators, enabling—for the first time—formal specification and reasoning about the generalizability of sampling strategies. Implemented as a fluent Python API, the DSL is integrated with a statistical metric system to quantitatively assess the external validity of sampled datasets. The authors demonstrate the expressiveness and practical utility of their approach by reconstructing and formalizing the sampling procedures from multiple Mining Software Repositories (MSR) studies, thereby validating the framework’s capacity to capture real-world methodological diversity.

To address the challenge of unified querying and modeling across heterogeneous software repositories (e.g., Git, Jira, CI logs), this paper proposes SEDA—a domain-specific data analytics framework for software engineering. Methodologically, SEDA introduces a multi-layer abstraction mechanism driven by Domain-Specific Operators (DSOs), integrating declarative DSL-based querying, semantics-aware modeling, and incremental data integration to achieve unified representation and efficient processing of cross-source software data. The framework enables flexible specification of analytical tasks while ensuring both high extensibility and low usability barriers. Evaluated on five real-world industrial case studies, SEDA achieves, on average, a 3.2× speedup in query execution time and a 27% improvement in modeling accuracy over conventional approaches. These gains significantly strengthen support for canonical software engineering tasks—including software evolution analysis and defect prediction—demonstrating SEDA’s practical efficacy and scalability.

To address the opacity of code semantics in AI-assisted programming—hindering visual inspection and formal verification—this paper proposes a DSL-driven multimodal interaction framework. It anchors program semantics in a domain-specific language (e.g., Lingua Franca), integrates natural language and speech input, and constructs interpretable, visual program models. Real-time graphical rendering and staged refinement enable dynamic traceability throughout code generation. Model checking is embedded to ensure semantic consistency via formal verification. Implemented as a VS Code extension prototype, the framework maintains high code-generation quality while significantly enhancing developers’ understanding of and trust in AI behavior. The core contribution lies in the deep synergy among DSL-based modeling, multimodal interaction, and formal verification—achieving, for the first time in an IDE-integrated tool, a closed-loop workflow wherein AI-generated code is both semantically visualized and formally verifiable.

Existing code-level formal verification tools scale poorly to large-scale software, while mainstream unit-level verification relies heavily on manual effort, often missing critical defects. This paper proposes the “Unit Proof Framework” research agenda—the first systematic definition of a unit verification paradigm supporting automated decoupling and independent verification of code units. Methodologically, it integrates formal verification, program analysis, modular verification, and automated toolchain design, with deep alignment to industrial development practices (e.g., AWS workflows). Its core contributions include: (1) establishing a scalable, engineering-friendly unit verification methodology; (2) characterizing a taxonomy of key technical challenges; (3) overcoming bottlenecks inherent in manual verification; and (4) significantly improving early detection of code-level defects. Collectively, this work lays the theoretical foundation and provides a practical technical pathway for building high-assurance, deployable automated verification infrastructure.

This work addresses the challenge that domain experts face in translating natural language descriptions of data quality requirements into executable analyses, a process often hindered by reliance on data engineers, resulting in inefficiency and high technical barriers. To overcome this, the paper proposes a no-code, model-driven pipeline that leverages a QPM metamodel to define domain-specific quality analysis templates. Coupled with the Constrainify toolchain, it automatically transforms natural language requirements into executable and reusable analytical logic. By integrating model-driven engineering, metamodeling, and no-code web technologies, the approach significantly reduces dependency on technical expertise, enabling efficient, reproducible, and semantically aligned data quality assessments. This advancement enhances both the accessibility and automation of data quality analysis for non-technical domain practitioners.

This study addresses the limitations of existing SysML verification approaches, which are often tool-dependent and restricted to performance properties, lacking support for automated validation of behavioral and interface requirements. To overcome these shortcomings, this work proposes a tool-agnostic, automated verification workflow driven by SysML test cases, integrating UML Testing Profile and behavioral diagram constructs to enable unified validation of multidimensional attributes—including behavior, timing, and state responses. The methodology was developed through a mixed-methods research strategy combining literature review and stakeholder interviews, and its efficacy was empirically validated across two independent SysML toolchains. The approach not only transcends the constraints of conventional parametric methods but also enables automatic traceability of verification results back to the original model elements.

This work addresses the challenge of efficient and scalable formal verification of concurrency properties—such as deadlock—in Java bytecode by proposing a Petri net–based modeling and analysis approach. The method precisely encodes bytecode semantics into Petri nets and leverages the mature model checker LoLA to enable automated verification of concurrent behaviors. Notably, this is the first application of Petri nets to concurrency analysis of Java bytecode, supporting multiple Java versions and partial Kotlin programs, thereby overcoming language-version limitations of existing tools. The prototype implementation, jPetrify, demonstrates high precision and strong scalability in verifying fundamental concurrency properties like deadlock, with performance largely insensitive to parameter scale.

This work addresses the undecidability of formal verification for model transformations, which stems from Turing completeness, and the path explosion problem that persists even in non-Turing-complete domain-specific languages like DSLTrans. The authors propose a scalable verification approach by establishing, for the first time, a bounded completeness theorem for a fragment of DSLTrans with respect to existential and traceability properties, thereby reducing infinite verification problems to bounded yet complete checks. Their method integrates class-boundary-aware encoding, trace-aware dependency analysis, and a CEGAR-driven refinement strategy to drastically reduce SMT formula size and eliminate spurious counterexamples. Implemented atop Z3 and integrated into a Web IDE, the tool successfully verifies 552 out of 899 properties across 29 real-world transformations, generates 345 valid counterexamples, times out on only two cases, and achieves up to a 112× speedup on challenging instances through refinement.

This work addresses the significant performance degradation of large language models (LLMs) in generating code for constraint-based domain-specific languages (DSLs), such as OCL and Alloy, and the absence of systematic evaluation methodologies. The paper introduces the first evaluation framework tailored for constraint DSL code generation, which systematically assesses LLM capabilities in translating natural language to DSL through both syntactic correctness and semantic accuracy, leveraging formal verification. Experimental comparisons across Python, OCL, and Alloy reveal that LLMs perform markedly better on general-purpose languages, that models with limited context windows struggle to jointly generate constraints and domain models, and that incorporating code repair and multi-candidate generation strategies substantially improves output quality. The framework further enables systematic analysis of prompting templates, repair mechanisms, and multi-turn generation strategies.