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
30 Mar 2020
TL;DR: This paper proposes a set of usability heuristics for DSLs and illustrates the approach with a case study, showing how they helped to identify many actual usability problems, even for a simple DSL.
Abstract: The usability of Domain-Specific Languages (DSLs) has been attracting considerable interest from researchers lately. In particular, our literature review found many usability studies that make use of subjective and empirical methods. However, we noted a lack of heuristic methods in the literature. In comparison, there exist several usability studies of Application Programming Interfaces (APIs) that have used heuristics with success, so we argue that this approach would be also useful for DSLs. Therefore, this paper proposes a set of usability heuristics for DSLs and illustrates the approach with a case study. We show how our heuristics helped us identify many actual usability problems, even for a simple DSL.
2 citations
01 Jan 2012
TL;DR: This thesis presents a new language workbench based on the GLL parsing algorithm, which is able to parse the full class of context-free grammars without any limitation and thus inherently supports modularity, and proposes a disambiguation mechanism based on pattern matching and rewriting within the resulting parse forest.
Abstract: One of the main difficulties in developing domain-specific languages is the use of deterministic parsing technologies in language workbenches. These deterministic parsers do not naturally support modularity, and impose restrictions on defining the grammar of a language. For example, LL(k) parsers cannot deal with left recursion or ambiguities, which have to be removed by rewriting the grammar. These modifications usually lead to a grammar definition which is not readable and may cause maintenance problems. More importantly, the parse trees from a modified grammar may be significantly different from the ones of the original, ambiguous grammar. This may cause problems in processing parse trees, for example, for mapping to EMF models. In this thesis, we present a new language workbench based on the GLL parsing algorithm. GLL is able to parse the full class of context-free grammars without any limitation and thus inherently supports modularity. Being a generalized parser, GLL produces a parse forest containing all the ambiguities. Our disambiguation method is based on pattern matching and rewriting within the resulting parse forest. One of the motivations for our disambiguation mechanism is solving hard parsing problems such as language embeddings and extensions. In addition, we present an error reporting mechanism for GLL-based parsers, an Eclipse plugin for developing new languages, and facilities for the mapping of ambiguous, complex concrete syntax to EMF models. Acknowledgements This thesis would have not been possible without the assistance of many people, whom I would like to gratefully acknowledge. First and foremost, I would like to thank my supervisor, Professor Mark van den Brand, for his invaluable guidance and advice during the course of this project. I particularly enjoyed his vast knowledge in parsing and the freedom he gave me to explore different disambiguation mechanisms. I also would like to thank Maarten Manders, who has provided me with his GLL implementation and helped me through the course of this project. His feedback on a first draft of this thesis was very useful. Without his initial work, I could come this far. I would like to express my gratitude for Professor Elizabeth Scott, who has provided me with crucial feedback on this thesis. Her comments have greatly contributed to the accuracy of the claims made in the disambiguation chapter. Furthermore, I appreciate the help of Professor Adrian Johnstone and fruitful discussions we had on GLL implementation. Implementing the disambiguation mechanism, which is the core part of this thesis, would have not been possible without the assistance of members of the Tom project. I would like to specifically thank Professor PierreEtienne Moreau, for his assistance during the island parsing project and my thesis. His knowledge on term rewriting had a significant impact on the successful implementation of the disambiguation mechanism. I also would like to thank Jean-Christophe Bach who has kindly helped me in learning Tom and applying it in my thesis. Part of this project is the continuation of my seminar course. I would like to thank Dr. Alexander Serebrenik, who has kindly provided me with valuable feedback on this work, during and after the seminar course. Last but not least, I express my appreciation for Dr. Serguei Roubtsov, a member of the examination committee, who has read and evaluated my work.
2 citations
Cites background from "Domain Specific Languages"
...Language workbenches [20] are tools that facilitate the development of domainspecific languages (DSLs)....
[...]
01 May 2022
TL;DR: MGE (Memory Graph Explorer) is presented, a memory analyzer and visualizer that combines a novel memory graph abstraction with an interactive visualization that works for corrupt data structures, and is particularly powerful for large, nested structures due to its support for interactive (un)folding.
Abstract: Analyzing heap dumps containing complex dynamic data structures is essential when debugging modern software systems. However, existing tools for visualizing memory graphs can neither deal with corrupt structures such as binary trees exhibiting cycles, nor do they offer adequate abstractions when being confronted with large heaps. This paper presents MGE (Memory Graph Explorer), a memory analyzer and visualizer that combines a novel memory graph abstraction with an interactive visualization. MGE borrows ideas from separation logic and shape analysis to reveal relationships between memory nodes, name recognized structures such as doubly-linked lists and binary trees, and summarize complex structures. This summarization works for corrupt data structures, too, and is particularly powerful for large, nested structures due to its support for interactive (un)folding. MGE's utility for aiding program comprehension is illustrated by real-world and textbook examples and contrasted with existing debuggers.
2 citations
19 Apr 2016
TL;DR: This work describes a framework for the interactive visualization and visual analysis of the run-time behavior of massively parallel programs, especially OpenCL kernels, that enables very specific, user-centered analysis, both in terms of the recording of theRuntime behavior and the visualization itself.
Abstract: The use of GPUs and the massively parallel computing paradigm have become wide-spread. We describe a framework for the interactive visualization and visual analysis of the run-time behavior of massively parallel programs, especially OpenCL kernels. This facilitates understanding a program's function and structure, finding the causes of possible slowdowns, locating program bugs, and interactively exploring and visually comparing different code variants in order to improve performance and correctness. Our approach enables very specific, user-centered analysis, both in terms of the recording of the run-time behavior and the visualization itself. Instead of having to manually write instrumented code to record data, simple code annotations tell the source-to-source compiler which code instrumentation to generate automatically. The visualization part of our framework then enables the interactive analysis of kernel run-time behavior in a way that can be very specific to a particular problem or optimization goal, such as analyzing the causes of memory bank conflicts or understanding an entire parallel algorithm.
2 citations
Posted Content•
TL;DR: Fence is proposed, an efficient bottom-up parsing algorithm with lexical and syntactic ambiguity support that enables the use of model-based language specification in practice.
Abstract: Model-based language specification has applications in the implementation of language processors, the design of domain-specific languages, model-driven software development, data integration, text mining, natural language processing, and corpus-based induction of models. Model-based language specification decouples language design from language processing and, unlike traditional grammar-driven approaches, which constrain language designers to specific kinds of grammars, it needs general parser generators able to deal with ambiguities. In this paper, we propose Fence, an efficient bottom-up parsing algorithm with lexical and syntactic ambiguity support that enables the use of model-based language specification in practice.
2 citations
Cites background from "Domain Specific Languages"
...Context-free grammars are formal grammars in which the productions are of the form N → (Σ∪N)∗ [3], where N is a finite set of nonterminal symbols, none of which appear in strings formed from the grammar; and Σ is a finite set of terminal symbols, also called tokens, that can appear in strings…...
[...]
...We define d as the dimension of a grammar, that is, the sum of the number of symbols that appear in the right hand side of the productions of the grammar....
[...]
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