When and how to develop domain-specific languages
14
Citation
0
Reference
19
Related Paper
Citation Trend
Abstract:
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. While 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 try to improve on and extend earlier work on DSL design patterns, in particular by Spinellis (2001). We also discuss domain analysis tools and language development systems that may help to speed up DSL development. Finally, we state a number of open problems.Keywords:
Domain-specific language
Domain analysis
Cite
When a domain specific language (DSL) shall be commonly used, it is important for the development team to have a comfortable editor well integrated in the project's development environment. As DSL are rather often subject to changes, efficient development and evolvement of a comfortable editor is an important success criterion for the acceptance of domain specific languages. In this paper we demonstrate how this issue is addressed in the MontiCore DSL development framework. Basically an extension of the MontiCore DSL definition language can be used to efficiently generate DSL editors for Eclipse. The generation tool also supports the compositional language definition features of MontiCore and allows therefore the reuse of existing language and editor definitions.
Eclipse
Cite
Citations (33)
Domain-specific language
Software product line
Modeling language
Reverse engineering
Cite
Citations (18)
Domain-specific language
Cite
Citations (49)
Domain-specific language
Software design pattern
Cite
Citations (232)
A great part of software development challenges can be solved by one universal tool: Abstraction. Developers solve development challenges by using expressions and concepts that abstract from too technical details. One especially supportive tool for abstraction are domain-specific languages (DSLs). DSLs are specifically crafted languages that support abstraction in two ways. On the one side, they abstract from the (real-world) concepts of the domain by introducing objects with structure and behavior that are representative for the domain. On the other side, they abstract from a programming language and do not depend on hardware-specific details. We focus on internal DSLs, which are build on top of an existing host language. Such DSLs can completely use the development tools of their host, are quick to build because they reuse existing abstractions, and can be easily integrated with other programs, libraries, and DSLs of the same host.
Abstraction
Domain-specific language
Language construct
Cite
Citations (7)
Domain-specific language
Cite
Citations (16)
Context: Computational notebooks are a contemporary style of literate programming, in which users can communicate and transfer knowledge by interleaving executable code, output, and prose in a single rich document.A Domain-Specific Language (DSL) is a software language tailored for an application domain.Usually, DSL users are domain experts that may not have a software engineering background.Therefore, they might not be familiar with Integrated Development Environments (IDEs).In brief, the development of tools that offer different interfaces for interacting with a DSL is relevant.Inquiry: However, DSL designers' resources are limited.We want to leverage General-purpose Languages (GPLs) tooling in the context of DSLs.Computational notebooks are an example of such tools.Then, our main question is: What is an efficient and effective method of designing and implementing notebook interfaces for DSLs?By addressing this question, we might be able to speed up the development of DSL tools, and ease the interaction between end-users and DSLs.Approach: In this paper, we present Bacatá, a mechanism for generating notebook interfaces for external DSLs in a language-parametric fashion.This mechanism is designed in a way in which language engineers can reuse as many language components as possible (e.g., language processors, type checkers, code generators).In addition, we present a Feature-Oriented Domain Analysis that depicts language dependent and language independent features of computational notebooks.Knowledge: Our results show that notebook interfaces generated by Bacatá can be used with little manual configuration.However, there are a few considerations and caveats that should be addressed by language engineers that rely on language design aspects.The creation of a notebook for a DSL with Bacatá becomes a matter of writing the code that wires existing language components in the Rascal language workbench with the Jupyter platform.Grounding: We evaluate Bacatá by generating functional computational notebook interfaces for three different non-trivial DSLs, namely: a small subset of Halide (a DSL for digital image processing), SweeterJS (an extended version of JavaScript), and QL (a DSL for questionnaires).Additionally, it is relevant to generate notebook implementations rather than implementing them manually.To illustrate this, we measured and compared the number of source lines of code that we reused from existing implementations of those languages.Importance: The adoption of notebooks by novice-programmers and end-users has made them very popular in several domains such as exploratory programming, data science, data journalism, and machine learning.Why are they popular?In (data) science, it is essential to make results reproducible as well as understandable.However, notebooks are only available for GPLs.This paper opens the notebook metaphor for DSLs to improve the end-user experience when interacting with code and to increase DSLs adoption.
Domain-specific language
Executable
Cite
Citations (4)
Since many domains are constantly evolving, the associated domain specific languages (DSL) inevitably have to evolve too, to retain their value. But the evolution of a DSL can be very expensive, since existing words of the language (i.e. programs) and tools have to be adapted according to the changes of the DSL itself. In such cases, these costs seriously limit the adoption of DSLs. This paper presents Lever, a tool for the evolutionary development of DSLs. Lever aims at making evolutionary changes to a DSL much cheaper by automating the adaptation of the DSL parser as well as existing words and providing additional support for the correct adaptation of existing tools (e.g. program generators). This way, Lever simplifies DSL maintenance and paves the ground for bottom-up DSL development.
Lever
Domain-specific language
Cite
Citations (9)
With the emergence of model-driven engineering (MDE), the creation of domain-specific languages (DSLs) is becoming a fundamental part of language engineering. The development cost of a DSL should be modest compared to the cost of developing a general-purpose programming language. Reducing the implementation effort and providing reuse techniques are key aspects for DSL approaches to be really effective. In this paper, we present an approach to build embedded domain-specific languages applying the principles of model-driven engineering. On the basis of this approach, we will tackle reuse of DSLs by defining families of DSLs, addressing reuse both from the DSL developer and user point of views. A family of DSLs will be built up by composing several DSLs, so we will propose composition mechanisms for the abstract syntax, concrete syntax, and model transformation levels of a DSL's definition. Finally, we contribute a software framework to support our approach, and we illustrate the paper with a case study to demonstrate its practical applicability.
Domain-specific language
Model Transformation
Model-driven architecture
Domain analysis
Cite
Citations (0)
Domain-specific language
Cite
Citations (14)