Automatic production of end user documentation for DSLs

Application Generator (AG) can help save time of software development. Some AG has its own DSL (Domain Specific Language) to direct the generated application outcome. In this research, we developed a DSL using the syntax notation text with simple structure that can assist AG in the process of generating source code for desktop-based database application using Java. DSL development is applying the methodology of DSL development from Czarnecki. The development for AG involves three areas of knowledge, i.e. domain engineering, DSL, and AG (compiler). Domain engineering is required to understand the target application domain to be generated, i.e. MySQL database and Java programming language with Swing UI. The DSL is developed in five phases, i.e. decision-making, analysis, design, implementation, and development. The AG itself is developed in Java platform. The DSL and AG developed in this research has shown that the DSL can help programmer to develop Java desktop-based database applications by utilizing DSL to map MySQL database into Java Swing UI, and employ AG to generate applications directly from DSL source. It is expected that further development of this research is to support more flexible application development.

A domain specific language (DSL) focuses on the essential concepts in a specific problem domain, and abstracts from low-level implementation details. The development of DSLs usually centers around the meta-model, grammar and code generator, possibly extended with transformations to analysis models. Typically, little attention is given to the formal semantics of the language, whereas this is essential for reasoning about DSL models, and for assessing the correctness of the generated code and analysis models. We argue that the semantics of a DSL should be defined explicitly and independently of any code generator, to avoid all kinds of complexities from low-level implementation details. As the generated analysis models must reflect some of these implementation details, we propose to formalize them separately. To assess the correctness and consistency of the generated code and analysis models in a practical way, we use conformance testing. We extensively illustrate this general approach using specific formalizations for an industrial DSL on collision prevention. We do not aim for a generic semantic model for any DSL, but this specific DSL indicates the potential of a modular semantics to facilitate reuse among DSLs.

A Domain Specific Language (DSL) focuses on the essential concepts in a certain problem domain, thus abstracting from low-level implementation details. In combination with code generators, DSLs bring software development closer to domain requirements. The development of DSLs usually centers around the grammar and a code generator; there is little attention for the semantics of the DSL. However, a formal semantics is essential for reasoning about specifications in terms of the DSL (i.e., DSL instances). We argue that the semantics should be expressed independent of a code generator. Thus semantic issues can be revealed that could otherwise remain undetected. We also use the semantics to define the conformance of an implementation to a DSL instance, and to automatically test conformance of the (generated) implementation code to a DSL instance. We illustrate our approach using an industrial prototype DSL for collision prevention.

Concern-oriented language development (COLD): Fostering reuse in language engineering

Domain specific languages (DSLs) are increasingly used today. Coping with complex language definitions, evolving them in a structured way, and ensuring their error freeness are the main challenges of DSL design and implementation. The use of modular language definitions and composition operators are therefore inevitable in the independent development of language components. In this article, we discuss these arising issues by describing a framework for the compositional development of textual DSLs and their supporting tools. We use a redundance-free definition of a readable concrete syntax and a comprehensible abstract syntax as both representations significantly overlap in their structure. For enhancing the usability of the abstract syntax, we added concepts like associations and inheritance to a grammar-based definition in order to build up arbitrary graphs (as known from metamodeling). Two modularity concepts, grammar inheritance and embedding, are discussed. They permit compositional language definition and thus simplify the extension of languages based on already existing ones. We demonstrate that compositional engineering of new languages is a useful concept when project-individual DSLs with appropriate tool support are defined.

Large Language Models (LLMs) have shown remarkable capabilities in code generation for popular programming languages. However, their performance in Low-Resource Programming Languages (LRPLs) and Domain-Specific Languages (DSLs) remains a critical challenge. This gap affects millions of developers - with Rust alone having 3.5 million users - who are currently unable to fully leverage LLM capabilities. LRPLs and DSLs face unique challenges, including severe data scarcity and, for DSLs, highly specialized syntax and semantics that are poorly represented in general-purpose datasets. Addressing these challenges is crucial as LRPLs and DSLs significantly enhance development efficiency in specialized domains and applications, including financial and scientific works. While several surveys on LLMs for software engineering and code exist, none comprehensively address the challenges and opportunities specific to LRPLs and DSLs. Our survey fills this gap by providing a systematic review of the current state, methodologies, and challenges in leveraging LLMs for code generation in LRPL and DSL. We filtered 111 papers from over 27,000 published studies from 2020 – 2024 to understand the capabilities and limitations of LLMs in these specialized domains. We also expanded our literature search to include 5 recent papers from 2024 – 2025. We report LLMs used, benchmarks, and metrics to evaluate code generation in LRPLs and DSLs, as well as strategies used to enhance LLM performance, and the collected datasets and curation methods in this context. We identified four main evaluation techniques used in the literature, along with several metrics to assess code generation in LRPL and DSL. We categorized the methods used for LLM improvement into six main groups and summarized the novel methods and architectures proposed by the researchers. We also classified different approaches used for data collection and preparation. While different techniques, metrics, and datasets are used, there is a lack of a standard approach and a benchmark dataset to evaluate code generation in several LRPLs and DSLs. We discuss several distinctions of the studied approaches with the ones used in high-resource programming languages (HRPLs), as well as several challenges unique to these languages, especially DSLs. The challenges stem from the scarcity of data, the unique requirements, and specialized domains, which often need expertise guidelines or domain-specific tools. Accordingly, we provide insights into different research opportunities for the studied aspects. This survey serves as a comprehensive resource for researchers and practitioners working at the intersection of LLMs, software engineering, and specialized programming languages, providing a foundation for future advancements in LRPL and DSL code generation. A GitHub repository was created to organize the papers of this survey at https://github.com/jie-jw-wu/Survey-CodeLLM4LowResource-DSL .

Domain-specific languages (DSLs) are languages tailored to a specific application domain. They offer substantial gains in expressiveness and ease of use compared with general-purpose programming languages in their domain of application. DSL development is hard, requiring both domain knowledge and language development expertise. Few people have both. Not surprisingly, the decision to develop a DSL is often postponed indefinitely, if considered at all, and most DSLs never get beyond the application library stage.Although many articles have been written on the development of particular DSLs, there is very limited literature on DSL development methodologies and many questions remain regarding when and how to develop a DSL. To aid the DSL developer, we identify patterns in the decision, analysis, design, and implementation phases of DSL development. Our patterns improve and extend earlier work on DSL design patterns. We also discuss domain analysis tools and language development systems that may help to speed up DSL development. Finally, we present a number of open problems.

The new approach to development of Domain Specific Languages (DSL) for solving tasks of Systems Engineering (SE) is proposed. A DSL alphabet is defined on the base of an ontology of the SE domain as the set of its typical concepts. A DSL grammar on the base of Finite State Machine (FSM) formalism is defined, which allows to link the SE ontology with the different SE processes (specification of requirements, work planning, development, validation, standardisation etc.). A DSL is mapped with the set of mathematical methods, which allows to solve arising in the SE domains tasks. The approach on the sample of development of the DSL for specification of requirements is illustrated.

Domain-specific languages [1, 2, 3] are programming languages for solving problems in a particular domain and provide built-in abstractions and notations for that domain. Domain-specific languages are usually small, more declarative than imperative, less expressive and more attractive than general-purpose languages because of easier programming, systematic reuse, better productivity, reliability, maintainability, and flexibility. However, the benefits of domain-specific languages are not for free. The cost of domain-specific language design, development and maintenance has to be taken into account. Without an appropriate methodology and tools, these costs can be higher than savings obtained by the later use of domain-specific languages. Advantages of the formal definitions of general-purpose languages should be exploited, taking into consideration the special nature of domain-specific languages. To be productive, the development of these languages has to be based on high-level automated tools [4].The purpose of this mini-track is to bring together an international audience of researchers and practitioners actively involved in the development of domain-specific languages that support the software engineering process. It covers a wide range of domain-specific languages applied in different software engineering problems. Some topics of interest for this mini-track are: design and implementation of domain-specific languages, use of domain-specific languages in the software engineering process, the role of domain-specific languages in software engineering, tools, environments, and techniques needed to support domain-specific languages.In ?A language for Software Subsystem Composition? by Jim Buffenbarger and Kirk Gruell, a domain-specific language for specifying the composition and construction of a software system is described. The authors clearly show how to design and implement a domain-specific language and what are the benefits of its usage.Next, Walter A. Risi, Pablo E. Martinez Lopez and Daniel H. Marcos in ?HyCom: A Domain-Specific Language for Hypermedia Application Development? describe a domain-specific language for hypermedia applications. Hypermedia applications are now in growing interests and the paper shows how the design and implementation of such applications benefit if a domain-specific language is used to specify the design. An automatic application generator finally obtains a hypermedia application.Finally, Peter Pfahler and Uwe Kastens in ?Configuring component-based specifications for domain-specific languages? describe the development of domain-specific languages using domain-specific components, which consist of the implementation part (specifications to compiler generator) and the interface part (specifications of dependencies between components). The domain-specific language is then described as a composition of domain-specific components. Since domain-specific components can be configurable, a whole family of domain-specific languages can be built. Using the Jacob tool, a domain expert can build a particular domain-specific language by selection. The approach is interesting and differs from other domain-specific language development approaches.

Domain-specific languages [1, 2, 3] are programming languages for solving problems in a particular domain and provide built-in abstractions and notations for that domain. Domain-specific languages are usually small, more declarative than imperative, less expressive and more attractive than general-purpose languages because of easier programming, systematic reuse, better productivity, reliability, maintainability, and flexibility. However, the benefits of domain-specific languages are not for free. The cost of domain-specific language design, development and maintenance has to be taken into account. Without an appropriate methodology and tools, these costs can be higher than savings obtained by the later use of domain-specific languages. Advantages of the formal definitions of general-purpose languages should be exploited, taking into consideration the special nature of domain-specific languages. To be productive, the development of these languages has to be based on high-level automated tools [4].The purpose of this mini-track is to bring together an international audience of researchers and practitioners actively involved in the development of domain-specific languages that support the software engineering process. It covers a wide range of domain-specific languages applied in different software engineering problems. Some topics of interest for this mini-track are: design and implementation of domain-specific languages, use of domain-specific languages in the software engineering process, the role of domain-specific languages in software engineering, tools, environments, and techniques needed to support domain-specific languages.In ?A language for Software Subsystem Composition? by Jim Buffenbarger and Kirk Gruell, a domain-specific language for specifying the composition and construction of a software system is described. The authors clearly show how to design and implement a domain-specific language and what are the benefits of its usage.Next, Walter A. Risi, Pablo E. Martinez Lopez and Daniel H. Marcos in ?HyCom: A Domain-Specific Language for Hypermedia Application Development? describe a domain-specific language for hypermedia applications. Hypermedia applications are now in growing interests and the paper shows how the design and implementation of such applications benefit if a domain-specific language is used to specify the design. An automatic application generator finally obtains a hypermedia application.Finally, Peter Pfahler and Uwe Kastens in ?Configuring component-based specifications for domain-specific languages? describe the development of domain-specific languages using domain-specific components, which consist of the implementation part (specifications to compiler generator) and the interface part (specifications of dependencies between components). The domain-specific language is then described as a composition of domain-specific components. Since domain-specific components can be configurable, a whole family of domain-specific languages can be built. Using the Jacob tool, a domain expert can build a particular domain-specific language by selection. The approach is interesting and differs from other domain-specific language development approaches.

Domain-specific languages (DSLs) play a crucial role in facilitating a wide range of software development activities in the context of model-driven engineering (MDE). However, there exists a significant gap in the systematic understanding of how DSLs evolve over time, which could hamper the development of effective methodologies and tools. To address this gap, this paper presents a large-scale study of the development and evolution of textual DSLs created with the Xtext framework and hosted on GitHub. The study focuses on how these languages evolve at the grammar and front-end level, as captured in open-source repositories. We systematically identified and analyzed 1002 GitHub repositories containing Xtext-related projects. A manual classification of the repositories brought forward 226 ones that contain a fully developed language. We further categorized the latter into 18 separate categories of application domains, studied their contained DSL definition artifacts and analyzed the extent to which example instances using the grammar are available. In addition, we explored DSL development practices, focusing on the development scenarios involved, evolution activities, and the modification and co-evolution of related artifacts. We observed that analyzed DSLs evolved faster and were maintained longer when they belonged to specific domains, such as data management and databases. We found grammar definitions of DSLs in 722 repositories in total. While only about a third of them provided corresponding textual instances, community engagement metrics indicate potential usage of the DSLs in downstream repositories. Considering different language development approaches, we found that the majority of analyzed languages were developed following a grammar-driven approach, although a notable number adopted a metamodel-driven approach. Additionally, we identify a trend of retrofitting existing languages in Xtext, illustrating the framework’s flexibility beyond the creation of new DSLs. By investigating software evolution aspects, we found that the development lifecycle of analyzed DSLs varies, but in many cases, updates to grammar definitions and example instances were frequent, and most of the evolution activities can be classified as “perfective” changes. Addressing a need for large and systematically documented datasets in the model-driven engineerifng community, we contribute a dataset of repositories together with our collected meta-information, which can be used to inform our understanding of open-source DSL development practices and the development of improved tools for supporting the development and evolution of DSLs.

[EN] Domain-specific languages (DSLs) are considered to be a powerful tool for enhancing the efficiency of software developers and bring software development closer to end-users from complex domains. However, the successful development of a DSL for a complex domain is a challenge from the technical point of view and because end-user acceptance is key. \nDespite this fact, the relevant role of end-users during DSL development has traditionally been neglected. Normally, end-users participate at the beginning to communicate their preferences but they do not participate again until the DSL is completely implemented. As a consequence, if the language to develop reaches a complex domain, the chances that errors appear in the DSL are higher and solving them could involve large modifications that could have been avoided.\nAs a solution, in this PhD thesis, we propose an agile, model-driven method to involve end-users in DSL development. This thesis researches if the combination of best practices from the model-driven development (MDD) discipline and best practices from agile methods is a suitable approach to involve end-users in the DSL development process.\nIn order to validate the proposal, we have selected a highly complex domain such as the genetic analysis domain and we have collaborated with geneticists from three organizations. The proposed method has been used to involve these geneticists in the development of a DSL for the creation of genetic analysis pipelines. Simultaneously, we have carried out an empirical experiment to validate whether end-users and developers were satisfied with the proposal.

Usability driven DSL development with USE-ME

Domain-specific process modelling has gained increased attention, since traditional modelling languages struggle to meet the demands of highly specialized businesses. However, methodological support on the development of such domain-specific languages is still scarce, which hampers the specification of adequate modelling support. To this end, the paper applies a design-oriented research approach to create an integrated framework that facilitates the development of domain-specific process modeling languages. The framework is a result of 23 consolidated requirements from relevant literature and contains essential building blocks that need to be considered during the development process. It is demonstrated that the framework satisfies the identified requirements by structuring and systematizing the development of domain-specific languages, which increases language adequacy and quality.

Code cloning (i.e., similar code fragments) in general purpose languages has been a major focus of the research community. For domain specific languages (DSLs), cloning related to domain-specific graphical languages has also been considered. This paper focuses on domain-specific textual languages in an effort to evaluate cloning in these DSLs where instances of such DSLs allow for less code to express domain-specific features, but potentially more frequently used code constructs. We suggest potential application scenarios of using clone detection for the maintenance of DSL code. We introduce a clone detection mechanism using a Model Driven Engineering (MDE) based approach to evaluate the extent of cloning in an initial DSL (i.e., the Object Constraint Language (OCL)). The evaluation reveals the existence of cloning in OCL, which suggests the relevance and potential applications of clone detection and analysis in DSLs.KeywordsCode clonesclone detectiondomain-specific languagesATL Transformation LanguageObject Constraint Language