Domain Specific Languages
25 Feb 2010-International Journal of Computer Applications (Foundation of Computer Science FCS)-Vol. 1, Iss: 21, pp 105-111
TL;DR: A number of DSLs spanning various phases of software development life cycle in terms of features that elucidates their advantages over general purpose languages and perform in depth study by practically applying a few open source DSLs: ‘Cascading’, Naked Objects Framework and RSpec.
Abstract: To match the needs of the fast paced generation, the speed of computing has also increased enormously. But, there is a limit to which the processor speed can be amplified. Hence in order to increase productivity, there is a need to change focus from processing time to programming time. Reduction in programming time can be achieved by identifying the domain to which the task belongs and using an appropriate Domain Specific Language (DSL). DSLs are constrained to use terms and concepts pertaining to an explicit domain making it much easier for the programmers to understand and learn, and cuts down the development time drastically. In this paper, we will understand what a DSL is; explore a number of DSLs spanning various phases of software development life cycle in terms of features that elucidates their advantages over general purpose languages and perform in depth study by practically applying a few open source DSLs: ‘Cascading’, Naked Objects Framework and RSpec.
Citations
More filters
01 Jan 2014
TL;DR: This work argues that early emphasis should be placed instead on the identification of general, compositional semantic domains, and that grounding the design process in semantics leads to languages with more consistent and more extensible syntax.
Abstract: Convention dictates that the design of a language begins with its syntax. We argue that early emphasis should be placed instead on the identification of general, compositional semantic domains, and that grounding the design process in semantics leads to languages with more consistent and more extensible syntax. We demonstrate this semantics-driven design process through the design and implementation of a DSL for defining and manipulating calendars, using Haskell as a metalanguage to support this discussion. We emphasize the importance of compositionality in semantics-driven language design, and describe a set of language operators that support an incremental and modular design process.
12 citations
Cites background or methods from "Domain Specific Languages"
...A syntax for the basic calendar operations is given below, where Appt represents appointment information (given by strings, say) and Time represents time values....
[...]
...This is necessary since the modelbased view seems more dominant today—it is the view taken by Fowler (2010) and also the one found in most of the chapters in this book....
[...]
...A semantic domain is, in principle, very similar to the notion of a semantic model as described in (Fowler, 2010)....
[...]
19 Oct 2016
TL;DR: This work shows how replacing the equations of an attribute grammar with equivalent constraints that can be solved by a constraint solver allows us to compute repairs of a malformed program solely from a specification that was originally designed for checking its well-formedness.
Abstract: Attribute grammars decorate the nodes of a program's parse tree with attributes whose values are defined by equations encoding the (static) semantics of a programming language. We show how replacing the equations of an attribute grammar with equivalent constraints that can be solved by a constraint solver allows us to compute repairs of a malformed program solely from a specification that was originally designed for checking its well-formedness. We present two repair modes --- shallow and deep fixing --- whose computed repair alternatives are guaranteed to repair every error on which they are invoked. While shallow fixing may introduce new errors, deep fixing never does; to make it tractable, we implement it using neighborhood search. We demonstrate the feasibility of our approach by implementing it on top of ExtendJ, an attribute grammar based Java compiler, and by applying it to an example from the Java EE context, detecting and fixing well-formedness errors (both real and injected) in a body of 14 open-source subject programs.
12 citations
Cites background from "Domain Specific Languages"
...However, for languages whose static semantics are relatively straightforward to specify (the targets of so-called language workbenches [9], some of which offer basic support for implementing automatic repair [8]), or for pluggable checks Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page....
[...]
27 Sep 2011
TL;DR: In this article, the design and implementation issues arising in the development of domain-specific languages for trace analysis are explored, and the authors introduce the general concepts underlying such special-purpose languages building upon the authors' own experiences in developing both external domain specific languages and systems.
Abstract: This tutorial explores the design and implementation issues arising in the development of domain-specific languages for trace analysis. It introduces the audience to the general concepts underlying such special-purpose languages building upon the authors' own experiences in developing both external domain-specific languages and systems, such as Eagle, Hawk, Ruler and LogScope, and the more recent internal domain-specific language and system TraceContract within the Scala language.
12 citations
04 Apr 2016
TL;DR: An in vitro experiment, where the subjects designed UML models and DSL models, indicated that, for performance modeling, effort using a DSL was lower than using UML, and statistical analysis showed that the results were valid.
Abstract: Performance testing modeling is a relative new research field. Researches investigating how to apply models to document performance testing information essentially started to be reported in the last decade. Motivated by the lack of a standard to represent performance testing information, our research group, in collaboration with an IT company, proposed a UML approach and lately a Domain-Specific Language (DSL) to support performance testing modeling. The goal of this paper is to show how we support our partner company on the decision process to replace UML by a DSL, hence we designed and conducted an experimental study to provide evidence about the benefits and drawbacks when using UML or DSL for modeling performance testing. In this paper, we report an in vitro experiment, where the subjects designed UML models and DSL models, for the purpose of evaluation with respect to the effort and suitability, from the perspective of the performance testers and the performance engineers in the context of industry and academia for modeling performance testing. Our results indicate that, for performance modeling, effort using a DSL was lower than using UML. Our statistical analysis showed that the results were valid, i.e., that to design performance testing models using our DSL is better than using UML.
12 citations
Cites methods from "Domain Specific Languages"
...To overcome these issues, we have proposed and implemented a Domain-Specific Language (DSL) [5] to the performance domain: Canopus [2]....
[...]
21 Oct 2011
TL;DR: The solution to these challenges is to provide a host-language independent catalog of design principles and design patterns for DSLs, which are found in 12 DSLs of the three host languages Ruby, Python, and Scala.
Abstract: 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.Developing DSLs is challenging. Especially dynamic object-oriented programming languages like Ruby and Python are used as hosts for DSLs. In these languages, DSLs exploit syntactic variations of the host to express domain-specific notations, and they access the host's reflective facilities and metaprogramming capabilities to implement the domain semantics. Although there are several case studies for DSLs, explanation of a DSLs design and implementation uses mostly host-specific terminology. Here we identify two particular challenge. First, the DSLs design intent is explained too specific to the particular DSL, making it difficult to reuse explained techniques to develop DSLs in another domain. Second, because the DSL design is explained with techniques native to the used host language, it is difficult to transfer these techniques to other host languages. In the long term, this could lead to fragmented islands of DSL design knowledge.Our solution to these challenges is to provide a host-language independent catalog of design principles and design patterns for DSLs. Particularly, this paper contributes six design principles and nine notation patterns for DSLs. The patterns have been found in 12 DSLs of the three host languages Ruby, Python, and Scala.
12 citations
References
More filters
TL;DR: The literature available on the topic of domain-specific languages as used for the construction and maintenance of software systems is surveyed, and a selection of 75 key publications in the area is listed.
Abstract: We survey the literature available on the topic of domain-specific languages as used for the construction and maintenance of software systems. We list a selection of 75 key publications in the area, and provide a summary for each of the papers. Moreover, we discuss terminology, risks and benefits, example domain-specific languages, design methodologies, and implementation techniques.
1,538 citations
Book•
23 Sep 2010
TL;DR: This book covers a variety of different techniques available for DSLs and can be used with whatever programming language you happen to be using, most of the examples are in Java or C#.
Abstract: Designed as a wide-ranging guide to Domain Specific Languages (DSLs) and how to approach building them, this book covers a variety of different techniques available for DSLs. The goal is to provide readers with enough information to make an informed choice about whether or not to use a DSL and what kinds of DSL techniques to employ. Part I is a 150-page narrative overview that gives you a broad understanding of general principles. The reference material in Parts II through VI provides the details and examples you willneed to get started using the various techniques discussed. Both internal and external DSL topics are covered, in addition to alternative computational models and code generation. Although the general principles and patterns presented can be used with whatever programming language you happen to be using, most of the examples are in Java or C#.
908 citations