scholarly journals An Embedded Domain Specific Language for General Purpose Vectorization

2017 ◽  
pp. 515-537 ◽  
Author(s):  
Przemysław Karpiński ◽  
John McDonald
Keyword(s):  
General Purpose ◽  
Domain Specific Language ◽  
Specific Language ◽  
Domain Specific

Code Refinement of Stencil Codes

2014 ◽  
Vol 24 (03) ◽  
pp. 1441003 ◽  
Author(s):  
Marcel Köster ◽  
Roland Leißa ◽  
Sebastian Hack ◽  
Richard Membarth ◽  
Philipp Slusallek
Keyword(s):  
Programming Language ◽  
General Purpose ◽  
Peak Performance ◽  
Domain Specific Language ◽  
Competitive Performance ◽  
Specific Language ◽  
Popular Method ◽  
Domain Specific ◽  
Stencil Codes ◽  
Target Platform

A straightforward implementation of an algorithm in a general-purpose programming language does usually not deliver peak performance: Compilers often fail to automatically tune the code for certain hardware peculiarities like memory hierarchy or vector execution units. Manually tuning the code is firstly error-prone as well as time-consuming and secondly taints the code by exposing those peculiarities to the implementation. A popular method to avoid these problems is to implement the algorithm in a Domain-Specific Language (DSL). A DSL compiler can then automatically tune the code for the target platform. In this article we show how to embed a DSL for stencil codes in another language. In contrast to prior approaches we only use a single language for this task which offers explicit control over code refinement. This is used to specialize stencils for particular scenarios. Our results show that our specialized programs achieve competitive performance compared to hand-tuned CUDA programs while maintaining a convenient coding experience.

scholarly journals Comparing general-purpose and domain-specific languages: An empirical study

2010 ◽  
Vol 7 (2) ◽  
pp. 247-264 ◽  
Author(s):  
Tomaz Kosar ◽  
Nuno Oliveira ◽  
Marjan Mernik ◽  
Varanda Pereira ◽  
Matej Crepinsek ◽  
...  
Keyword(s):  
User Interfaces ◽  
General Purpose ◽  
Domain Specific Language ◽  
Problem Domain ◽  
Domain Specific Languages ◽  
Cognitive Dimension ◽  
Specific Language ◽  
Domain Specific ◽  
Implementation Approach ◽  
Open Issue

Many domain-specific languages, that try to bring feasible alternatives for existing solutions while simplifying programming work, have come up in recent years. Although, these little languages seem to be easy to use, there is an open issue whether they bring advantages in comparison to the application libraries, which are the most commonly used implementation approach. In this work, we present an experiment, which was carried out to compare such a domain-specific language with a comparable application library. The experiment was conducted with 36 programmers, who have answered a questionnaire on both implementation approaches. The questionnaire is more than 100 pages long. For a domain-specific language and the application library, the same problem domain has been used - construction of graphical user interfaces. In terms of a domain-specific language, XAML has been used and C# Forms for the application library. A cognitive dimension framework has been used for a comparison between XAML and C# Forms.

scholarly journals The Kansas University rewrite engine

2014 ◽  
Vol 24 (4) ◽  
pp. 434-473 ◽  
Author(s):  
NEIL SCULTHORPE ◽  
NICOLAS FRISBY ◽  
ANDY GILL
Keyword(s):  
Programming Languages ◽  
General Purpose ◽  
Generic Programming ◽  
Domain Specific Language ◽  
Transformation System ◽  
Specific Language ◽  
Domain Specific ◽  
Main Challenge ◽  
Engineering Effort ◽  
Transformation Systems

AbstractWhen writing transformation systems, a significant amount of engineering effort goes into setting up the infrastructure needed to direct individual transformations to specific targets in the data being transformed. Strategic programming languages provide general-purpose infrastructure for this task, which the author of a transformation system can use for any algebraic data structure. The Kansas University Rewrite Engine (KURE) is a typed strategic programming language, implemented as a Haskell-embedded domain-specific language. KURE is designed to support typed transformations over typed data, and the main challenge is how to make such transformations compatible with generic traversal strategies that should operate over any type. Strategic programming in a typed setting has much in common with datatype-generic programming. Compared to other approaches to datatype-generic programming, the distinguishing feature of KURE's solution is that the user can configure the behaviour of traversals based on the location of each datum in the tree, beyond their behaviour being determined by the type of each datum. This article describes KURE's approach to assigning types to generic traversals, and the implementation of that approach. We also compare KURE, its design choices, and their consequences, with other approaches to strategic and datatype-generic programming.

scholarly journals PyFlies: A Domain-Specific Language for Designing Experiments in Psychology

2021 ◽  
Vol 11 (17) ◽  
pp. 7823
Author(s):  
Igor Dejanović ◽  
Mirjana Dejanović ◽  
Jovana Vidaković ◽  
Siniša Nikolić
Keyword(s):  
Programming Languages ◽  
Flanker Task ◽  
General Purpose ◽  
Domain Specific Language ◽  
Code Generator ◽  
Specific Language ◽  
Domain Specific ◽  
Programming Skills ◽  
Textual Form

The majority of studies in psychology are nowadays performed using computers. In the past, access to good quality software was limited, but in the last two decades things have changed and today we have an array of good and easily accessible open-source software to choose from. However, experiment builders are either GUI-centric or based on general-purpose programming languages which require programming skills. In this paper, we investigate an approach based on domain-specific languages which enables a text-based experiment development using domain-specific concepts, enabling practitioners with limited or no programming skills to develop psychology tests. To investigate our approach, we created PyFlies, a domain-specific language for designing experiments in psychology, which we present in this paper. The language is tailored for the domain of psychological studies. The aim is to capture the essence of the experiment design in a concise and highly readable textual form. The editor for the language is built as an extension for Visual Studio Code, one of the most popular programming editors today. From the experiment description, various targets can be automatically produced. In this version, we provide a code generator for the PsychoPy library while generators for other target platforms are planned. We discuss the language, its concepts, syntax, some current limitations, and development directions. We investigate the language using a case study of the implementation of the Eriksen flanker task.

An Evaluation of a Pure Embedded Domain-Specific Language for Strategic Term Rewriting

2012 ◽  
pp. 81-108
Author(s):  
Shirren Premaratne ◽  
Anthony M. Sloane ◽  
Leonard G. C. Hamey
Keyword(s):  
Programming Languages ◽  
Term Rewriting ◽  
General Purpose ◽  
Domain Specific Language ◽  
Specific Language ◽  
Domain Specific ◽  
Trade Offs ◽  
Implementation Approach ◽  
Performance Penalty ◽  
Embedded Implementation

Domain-specific languages are often implemented by embedding them in general-purpose programming languages. The Kiama library used in this chapter for the Scala programming language contains a rewriting component that is an embedded implementation of the Stratego term rewriting language. The authors evaluate the trade-offs inherent in this approach and its practicality via a non-trivial case study. An existing Stratego implementation of a compiler for the Apply image processing language was translated into a Kiama implementation. The chapter examines the linguistic differences between the two versions of the Stratego domain-specific language, and compares the size, speed, and memory usage of the two Apply compiler implementations. The authors’ experience shows that the embedded language implementation inflicts constraints that mean a precise duplication of Stratego is impossible, but the main flavor of the language is preserved. The implementation approach allows for writing code of similar size, but imposes a performance penalty. Nevertheless, the performance is still at a practically useful level and scales for large inputs in the same way as the Stratego implementation.

Domain-Specific Language Abstractions for Compression

2021 ◽  
Author(s):  
Jessica Ray ◽  
Ajav Brahmakshatriya ◽  
Richard Wang ◽  
Shoaib Kamil ◽  
Albert Reuther ◽  
...  
Keyword(s):  
Domain Specific Language ◽  
Specific Language ◽  
Domain Specific

Proxemic Environments Modelling based on a Graphical Domain-Specific Language

2020 ◽  
Author(s):  
Paulo Perez ◽  
Philippe Roose ◽  
Yudith Cardinale ◽  
Marc Dalmau ◽  
Dominique Masson ◽  
...  
Keyword(s):  
Domain Specific Language ◽  
Specific Language ◽  
Domain Specific
Sign in / Sign up

Export Citation Format

Share Document