programming language design

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 challenge that general-purpose large language models often struggle to accurately invoke library functions and adhere to domain-specific conventions when generating code for specialized frameworks such as Scikit-learn and OpenCV. To systematically evaluate customization strategies, the authors construct a synthetic programming dataset spanning general Python, Scikit-learn, and OpenCV, and assess three approaches—few-shot prompting, retrieval-augmented generation (RAG), and LoRA fine-tuning—within a unified framework. The study presents the first comparative analysis of prompt engineering versus parameter-efficient fine-tuning in domain-specific code generation, revealing practical trade-offs among accuracy, cost, and flexibility. Experimental results demonstrate that LoRA fine-tuning significantly outperforms prompt-based methods in both accuracy and domain alignment, whereas few-shot prompting and RAG, while improving relevance, offer limited gains in overall correctness.

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.

Large language models (LLMs) exhibit limited performance in domain-specific code generation—e.g., web, game, and mathematical programming—primarily due to insufficient semantic understanding of specialized APIs (e.g., React, Unity). This work presents the first systematic analysis revealing critical deficiencies in LLMs’ API-level cognition. To address this, we propose DomCoder, a domain-enhanced code generation framework that integrates three complementary API knowledge augmentation strategies: external knowledge retrieval, chain-of-thought (CoT) prompting, and CoT-aware fine-tuning. Evaluated across diverse domain-specific benchmarks, DomCoder achieves significant improvements in both functional correctness and domain-specific fidelity. Our results empirically validate that explicit API knowledge guidance effectively bridges the domain capability gap in LLMs, advancing their applicability to real-world software development tasks requiring deep platform expertise.

This work addresses the problem of program synthesis in domain-specific languages (DSLs) that involve numeric constants and require optimization of quantitative objectives such as accuracy. The authors propose a provably optimal search method that constructs a search graph over program subsets and integrates A* search with a heuristic derived from abstract interpretation to efficiently prune suboptimal subtrees. The key innovation lies in the design of abstract transformers tailored to DSL components with monotonic semantics, enabling a pruning mechanism that guarantees optimality. Experimental evaluation on two real-world DSLs demonstrates that the approach substantially outperforms existing state-of-the-art synthesizers, achieving significant improvements in scalability while maintaining correctness and optimality guarantees.

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.

Modular control-flow handling in abstract interpretation and supporting multiple analysis strategies—such as path- vs. flow-sensitivity, forward vs. backward directionality, and upper vs. lower approximations—traditionally relies on complex monad transformers, leading to implementation brittleness and poor composability. Method: This paper introduces the *cumulative abstract semantics* framework, the first to incorporate *scoped effects* into abstract interpretation. It decouples syntactic structure from semantic behavior via two classes of effect handlers: *syntax-resolving* and *domain-semantics-introducing*. A single syntax-driven interpreter suffices to generate diverse dynamic evaluators and static analyzers. Contribution/Results: The framework eliminates heavyweight data structures, preserving expressiveness while drastically reducing implementation complexity for multi-strategy analyses. It enhances maintainability, composability, and modularity—providing a concise, unified, and extensible theoretical and practical foundation for modular program analysis.

This work proposes a modular framework for random program generation targeting compiler intermediate representations (IRs), addressing the high complexity and effort traditionally required to develop such generators. By decoupling language-specific constructs from generic generation logic, the framework significantly lowers the barrier to implementing new IR-aware generators. Built upon the MLIR infrastructure, it integrates modular design, randomized program synthesis, differential testing, and fuzzing to enable rapid adaptation across diverse IRs. The authors demonstrate the approach’s effectiveness and generality by developing generators for MLIR’s built-in dialects, WebAssembly, and DaCe within a single week, uncovering 9, 15, and 774 distinct bug-triggering test cases, respectively. These results substantiate the framework’s capacity to facilitate efficient and scalable compiler testing.

The dominant programming languages support nothing but linear text to express domain-specific geometric ideas. What is needed are hybrid languages that allow developers to create visual syntactic constructs so that they can express their ideas with a mix of textual and visual syntax tailored to an application domain. This mix must put the two kinds of syntax on equal footing and, just as importantly, the extended language must not disrupt a programmer's typical workflow. This means that any new visual syntax should be a proper language extension that is composable with other language features. Furthermore, the extensions should also preserve static reasoning about the program. This paper presents Hybrid ClojureScript the first such hybrid programming language. Hybrid ClojureScript allows programmers to add visual interactive syntax and to embed instances of this syntax within a program's text. An enhanced hybrid IDE can then display these embedded instances as mini-GUIs that programmers interact with, while other IDEs will show a textual representation of the syntax. The paper argues the necessity of such an extensibility mechanism, demonstrates the adoptability of the design, and discusses what might be needed to use the design in other languages.

This paper addresses the problem of redundant semantic modeling of compilers and cross-language interoperability. It proposes a unified compiler model based on open-term multilingual semantic reduction systems, departing from conventional syntactic translation. Methodologically, cross-language reduction rules formally define both ahead-of-time (AOT) and just-in-time (JIT) compilation behaviors; properties such as confluence and type preservation directly yield partial formal guarantees of compilation correctness and secure compilation. The contributions are threefold: (1) the first holistic characterization of compilation as a multilingual reduction system that simultaneously defines both compilation semantics and interoperability semantics; (2) natural, structural support for uniform AOT/JIT interpretation via the reduction framework; and (3) significant simplification of secure compilation proofs, yielding novel semantic insights into compiler correctness and language interoperability.