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
10 Nov 2016
TL;DR: This paper presents an approach for extracting a machine readable semantic representation of legislation, from unstructured document formats, and exploits common formats of legal documents to identify blocks of structural and semantic information and models them according to a popular legal meta-schema.
Abstract: Over the last years there has been a great increase on the number of freely available legal resources. Portals that allow users to search for legislation, using keywords are now a common place. However, in the vast majority of those portals, legal documents are not stored in a structured format with a rich set of meta data, but in presentation oriented manifestation, making impossible for the end users to inquiry semantics about the documents, such as date of enactment, date of repeal, jurisdiction, etc. or to reuse information and establish an interconnection with similar repositories. In this paper, we present an approach for extracting a machine readable semantic representation of legislation, from unstructured document formats. Our method exploits common formats of legal documents to identify blocks of structural and semantic information and models them according to a popular legal meta-schema. Our proposed method is highly extensible and achieves high accuracy for a variety of legal and para legal documents, especially legislation. Our evaluation results reveal that our methodology can be of great assistance for the automatic structuring and semantic indexing of legal resources.
19 citations
Cites methods from "Domain Specific Languages"
...The structure of a legal document as aforementioned described can be expressed by a domain-specific model and thus extracted by employing syntax rules (DSL) [20] [11]....
[...]
25 Jun 2012
TL;DR: This paper proposes architecture abstraction concepts that are supported through a domain-specific language (DSL) that only need to be changed, if the architecture changes, but can tolerate non-architectural changes in the underlying source code.
Abstract: In this paper we present an approach for supporting the semi-automated abstraction of architectural models throughout the software lifecycle. It addresses the problem that the design and the implementation of a software system often drift apart as software systems evolve, leading to architectural knowledge evaporation. Our approach provides concepts and tool support for the semi-automatic abstraction of architectural knowledge from implemented systems and keeping the abstracted architectural knowledge up-to-date. In particular, we propose architecture abstraction concepts that are supported through a domain-specific language (DSL). Our main focus is on providing architectural abstraction specifications in the DSL that only need to be changed, if the architecture changes, but can tolerate non-architectural changes in the underlying source code. The DSL and its tools support abstracting the source code into UML component models for describing the architecture. Once the software architect has defined an architectural abstraction in the DSL, we can automatically generate UML component models from the source code and check whether the architectural design constraints are fulfilled by the models. Our approach supports full traceability between source code elements and architectural abstractions, and allows software architects to compare different versions of the generated UML component model with each other. We evaluate our research results by studying the evolution of architectural abstractions in different consecutive versions and the execution times for five existing open source systems.
18 citations
20 May 2013
TL;DR: The Selective Embedded JIT Specialization (SEJITS) approach is used to automatically translate semiring operations and filters defined by programmers into a lower-level efficiency language, bypassing the upcall into Python, demonstrating the first known solution to the problem of obtaining high performance from a productivity language when applying graph algorithms selectively on semantic graphs.
Abstract: High performance is a crucial consideration when executing a complex analytic query on a massive semantic graph. In a semantic graph, vertices and edges carry attributes of various types. Analytic queries on semantic graphs typically depend on the values of these attributes; thus, the computation must view the graph through a filter that passes only those individual vertices and edges of interest. Knowledge Discovery Toolbox (KDT), a Python library for parallel graph computations, is customizable in two ways. First, the user can write custom graph algorithms by specifying operations between edges and vertices. These programmer-specified operations are called semiring operations due to KDT's underlying linear-algebraic abstractions. Second, the user can customize existing graph algorithms by writing filters that return true for those vertices and edges the user wants to retain during algorithm execution. For high productivity, both semiring operations and filters are written in a high-level language, resulting in relatively low performance due to the bottleneck of having to call into the Python virtual machine for each vertex and edge. In this work, we use the Selective Embedded JIT Specialization (SEJITS) approach to automatically translate semiring operations and filters defined by programmers into a lower-level efficiency language, bypassing the upcall into Python. We evaluate our approach by comparing it with the high-performance Combinatorial BLAS engine, and show our approach enables users to write in high-level languages and still obtain the high performance of low-level code. We also present a new roofline model for graph traversals, and show that our high-performance implementations do not significantly deviate from the roofline. Overall, we demonstrate the first known solution to the problem of obtaining high performance from a productivity language when applying graph algorithms selectively on semantic graphs.
18 citations
Cites background from "Domain Specific Languages"
...JIT Compilation of DSLs: Embedded DSLs [12] for domain-specific computations have a rich history, including DSLs that are compiled instead of interpreted [20]....
[...]
01 Aug 2014
TL;DR: An approach and tool for automatically identifying multi-language relevant artifacts, finding references between artifacts in different languages, and rename- refactoring them is reported on and insights into the incidence of multi- Language bindings in the case studies as well as the feasibility of automated multi- language rename refactorings are provided.
Abstract: Developing non-trivial software applications involves using multiple programming languages. Although each language is used to describe a particular aspect of the system, artifacts defined inside those languages reference each other across language boundaries; such references are often only resolved at runtime. However, it is important for developers to be aware of these references during development time for programming understanding, bug prevention, and refactoring. In this work, we report on a an approach and tool for automatically identifying multi-language relevant artifacts, finding references between artifacts in different languages, and rename- refactoring them, and b on an experimental evaluation of the approach on seven open-source case studies which use a total of six languages found in three frameworks. As our main result, we provide insights into the incidence of multi-language bindings in the case studies as well as the feasibility of automated multi-language rename refactorings.
18 citations
01 Jan 2017
TL;DR: Turnstile critically depends on the idea of linguistic reuse and exploits a macro system in a novel way to simultaneously type check and rewrite a surface program into a target language.
Abstract: We present Turnstile, a metalanguage for creating typed embedded languages. To implement the type system, programmers write type checking rules resembling traditional judgment syntax. To implement the semantics, they incorporate elaborations into these rules. Turnstile critically depends on the idea of linguistic reuse. It exploits a macro system in a novel way to simultaneously type check and rewrite a surface program into a target language. Reusing a macro system also yields modular implementations whose rules may be mixed and matched to create other languages. Combined with typical compiler and runtime reuse, Turnstile produces performant typed embedded languages with little effort.
18 citations
Cites methods from "Domain Specific Languages"
...We use Racket [12, 15], a production-quality Lisp and Scheme descendant, as our host language since Lisps are already a popular platform for creating embedded languages [17, 20]....
[...]
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