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
16 Oct 2020
TL;DR: ROCCO is presented, a tool that migrates Eclipse-based graphical modelling editors to the web, to facilitate their integration with low-code platforms and an evaluation based on migrating nine editors created by third parties shows the usefulness of the tool.
Abstract: Domain-specific languages (DSLs) are languages tailored for particular domains. Many frameworks and tools have been proposed to develop editors for DSLs, especially for desktop IDEs, like Eclipse.We are witnessing the advent of low-code development platforms, which are cloud-based environments supporting rapid application development by using graphical languages and forms. While this approach is very promising, the creation of new low-code platforms may require the migration of existing desktop-based editors to the web. However, this is a technically challenging task.To fill this gap, we present ROCCO, a tool that migrates Eclipse-based graphical modelling editors to the web, to facilitate their integration with low-code platforms. The tool reads a meta-model annotated with EuGENia annotations, and generates a web editor using the DPG web framework used by the UGROUND company. In this paper, we present the approach, including tool support and an evaluation based on migrating nine editors created by third parties, which shows the usefulness of the tool.
2 citations
01 Jan 2014
TL;DR: The focus of this research is the synthesis engine, the layer in the DSVM which transforms i-DSML models into executable scripts for the next lower layer to process, where the semantic gap between the user-defined model and the services being provided by the underlying infrastructure is closed.
Abstract: OF THE DISSERTATION A GENERIC MODEL OF EXECUTION FOR SYNTHESIZING DOMAIN-SPECIFIC MODELS by Mark Allison Florida International University, 2014 Miami, Florida Professor Peter J. Clarke, Major Professor Software engineering researchers are challenged to provide increasingly more powerful levels of abstractions to address the rising complexity inherent in software solutions. One new development paradigm that places models as abstraction at the forefront of the development process is Model-Driven Software Development (MDSD). MDSD considers models as first class artifacts, extending the capability for engineers to use concepts from the problem domain of discourse to specify apropos solutions. A key component in MDSD is domain-specific modeling languages (DSMLs) which are languages with focused expressiveness, targeting a specific taxonomy of problems. The de facto approach used is to first transform DSML models to an intermediate artifact in a HLL e.g., Java or C++, then execute that resulting code. Our research group has developed a class of DSMLs, referred to as interpreted DSMLs (i-DSMLs), where models are directly interpreted by a specialized execution engine with semantics based on model changes at runtime. This execution engine uses a layered architecture and is referred to as a domain-specific virtual machine (DSVM). As the domain-specific model being executed descends the layers of the DSVM the semantic gap between the user-defined model and the services being provided by the underlying infrastructure is closed. The focus of this research is the synthesis engine, the layer in the DSVM which transforms i-DSML models into executable scripts for the next lower layer to process.
2 citations
Posted Content•
01 Jan 2019
2 citations
01 Jan 2015
TL;DR: This work shares the ideas for a general compilation approach along the Message Redelivery on Exception (MRoE) integration capability and basic message processing strategies, from which it derives compilation patterns that allow the generation of executable runtime code.
Abstract: Enterprise Application Integration plays an integral role for the communication between applications not only in service-oriented architectures. However, their modeling and configuration remain under- represented. In previous work, the integration control and data flow syntax and semantics have been expressed in the Business Process Model and Notation (BPMN) as a semantic model for message-based integration, while the concrete compilation to several runtime systems was left open. In this work we share our ideas for a general compilation approach along the Message Redelivery on Exception (MRoE) integration capability and basic message processing strategies, from which we derive compilation patterns. These patterns are used to translate BPMN models via an inter- mediate property graph model to a runtime system graph representation that allows the generation of executable runtime code.
2 citations
08 Sep 2014
TL;DR: This work presents a translation scheme from a pure functional domain-specific language (DSL) to C to preserve the structure of the input program as much as possible, resulting in code that closely resembles hand-written C code.
Abstract: We present a translation scheme from a pure functional domain-specific language (DSL) to C. The over-arching idea of this scheme is to preserve the structure of the input program as much as possible. This includes, among other things, to refrain from inlining user-written functions and to retain variable names as much as possible. We apply this translation scheme to GDSL, a DSL used for the specification of decoders for machine instructions. GDSL offers non-trivial language features such as monadic actions that our translation scheme maps one-to-one to C statements, resulting in code that closely resembles hand-written C code. Indeed, it is feasible to debug and profile the program at the C level and to interface the generated code with existing C code without marshaling data. Our translation scheme is therefore an attractive starting point for a light-weight DSL since no other language-specific tools besides the compiler are necessary. Moreover, the generated code is amenable to compiler optimizations found in off-the-shelf C compilers. This is illustrated by the performance achieved by a decoder for x86 machine instructions implemented in GDSL which is as fast as a production-quality decoding library shipped by Intel.
2 citations
Cites background from "Domain Specific Languages"
...GDSL o.ers non-trivial language features such as monadic actions that our translation scheme maps one-to-one to C statements, resulting incode that closely resembles hand-written C code....
[...]
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