Domain-specific language integration with compile-time parser generator library

Domain specific languages (DSLs) offer the potential for using a small, specialized and highly expressive programming language to concisely represent solutions for a particular domain of problems. The DSL approach is in stark contrast to that of a general programming language that attempts to provide a means to represent solutions for a broad range of problems. DSLs may incorporate constructs and syntactical features that not only relate to the problem context, but also to the execution platform. DSLs thus provide a potential for reducing development time and thereby cutting business costs. At present this approach is likely more appropriate to prototyping and rapid experimental work; but as technologies to implement DSLs improve they may become more beneficial and cost effective for developing marketable products. In this paper we present a DSL, called OptiSDR, aimed to improve developer productivity for development of software defined radio (SDR) applications deployed on heterogeneous computing architectures (HCAs). OptiSDR is designed for HCAs that adhere to certain combinations of processing devices, namely FPGAs, graphics processing units, and multi-core general purpose processors. Our aim to improve developer productivity in multiple ways was achieved, with development cycles for parallel DSP routines for SDR reduced to few hours as opposed to days for CUDA-C development cycles. OptiSDR uses automatic code generation for structured parallel SDR patterns, and performs automatic profiling to generate faster execution kernels with speed-ups of more than 50× compared to other sequential implementations while reducing manual effort in porting and tuning code. Therefore this paper reports on a study confirming the potential to speed up when using OptiSDR for prototyping SDR applications.

LanguageGame is a tool for a non-professional computer user to make a new programming language. Playing with LanguageGame allows a user to make an original new programming language. In order to give an instruction to a computer, now we have many ways such as selecting menu, push button, drag icon or so. Recent researches of computer user interface have developed various methods of interacting with computer. Above all, with using WYSIWYG (What You See Is What You Get) way, user interface becomes very rich and useful for non-engineer users. But yet, the most fundamental way of having a dialog with computer is to input a sequence of command kind of programming language. Using WYSIWIG style has advantages when a user uses a computer instead of real paper. But to deal with more abstract or involved matter, using a programming language has more benefit because symbols are more stable and we can use powerful idea as a recursiveness or a reference with such language. The importance of programming language could never change however GUI will be more improved. There are various languages in the world, and there are many interesting aspects and tastes in each language. As the grammars of the programming language are very interesting, developing a language must be more fun. Of course making a language seemed to be difficult. And it was planned to develop a parser generator that common people can make their own language easily. A parser generator is one of the most basic software in computer. Historically, various programming languages have been developed. And to make developing their parser easily, the technique of automatic parser generation was found. Now the parser generator becomes established technology. LanguageGame is such a parser generator that has graphical user interface. Contrary to popular professional parser generator like yacc/lex in UNIX platform, it is intended to use non-professional computer users, students and children. Playing with LanguageGame, users can learn and build simple parser with pretty graphical interface, drag-and-drop and graphical syntax tree representation. In current implementation, LanguageGame is developed on Squeak - a free open environment of Smalltalk. Hereby, the user grammar with LanguageGame can use all objects like a sketch and sound in Squeak.

Application Generator (AG) can help save time of software development. Some AG has its own DSL (Domain Specific Language) to direct the generated application outcome. In this research, we developed a DSL using the syntax notation text with simple structure that can assist AG in the process of generating source code for desktop-based database application using Java. DSL development is applying the methodology of DSL development from Czarnecki. The development for AG involves three areas of knowledge, i.e. domain engineering, DSL, and AG (compiler). Domain engineering is required to understand the target application domain to be generated, i.e. MySQL database and Java programming language with Swing UI. The DSL is developed in five phases, i.e. decision-making, analysis, design, implementation, and development. The AG itself is developed in Java platform. The DSL and AG developed in this research has shown that the DSL can help programmer to develop Java desktop-based database applications by utilizing DSL to map MySQL database into Java Swing UI, and employ AG to generate applications directly from DSL source. It is expected that further development of this research is to support more flexible application development.

Computer science is undergoing a revolution today, in which language designers are shifting attention from general purpose programming languages to so-called domain-specific languages (DSLs). General-purpose languages like Java, C#, C++, and C have long been the primary focus of language research. The idea was to create one language that would be better suited for programming than any other language. Ironically, we now have so many different general purpose languages that it is hard to imagine how this goal could be attained. Instead of aiming to be the best for solving any kind of computing problem, DSLs aim to be particularly good for solving a specific class of problems, and in doing so they are often much more accessible to the general public than traditional programming languages.

A task-specific programming language (TSPL) is a domain-specific programming language (in programming languages terms) designed for a particular user task (in human-computer interaction terms). Users of task-specific programming are able to use the tool to complete useful tasks, without prior training, in a short enough period that one can imagine fitting it into a normal class (e.g., around 10 minutes). We are designing a set of task-specific programming languages for use in social studies and precalculus courses. Our goal is offer an alternative to more general purpose programming languages (such as Scratch or Python) for integrating computing into other disciplines. An example task-specific programming language for precalculus offers a concrete context: An image filter builder for learning basic matrix arithmetic (addition and subtraction) and matrix multiplication by a scalar. TSPLs allow us to imagine a research question which we couldn't ask previously: How much computing might students learn if they used a multiple TSPLs in each subject in each primary and secondary school grade?

Domain Specific Languages (DSLs) often consist of general constructs alongside domain-specific ones. A prominent example is a state machine consisting of states and transitions as well as expressions and statements. Adding general concepts to a DSL is a complex and time-consuming task. We propose an approach to develop such DSLs as extensions of a General Purpose Language (GPL). We believe that this approach significantly reduces development times. This is especially important in the first phases of DSL development when language constructs are evolving and not well conceived. Our development allows trying out different forms of constructs with an editor to be at hand at all times. The paper presents first results of the implementation of our approach on top of Eclipse. The feasibility is shown by applying it to the definition of state machines as an example DSL.

Programming language researchers often study real-world projects to see how language features have been adopted and are being used. Typically researchers choose a small number of projects to study, due to the immense challenges associated with finding, downloading, storing, processing, and querying large amounts of data. The Boa programming language and infrastructure was designed to solve these challenges and allow researchers to focus on simply asking the right questions. Boa provides a domain-specific language to abstract details of how to mine hundreds of thousands of projects and also abstracts how to efficiently query that data. We have previously used this platform to perform a large study of the adoption of Java's language features over time. In this demonstration, we will show you how we used Boa to quickly analyze billions of AST nodes and study the adoption of Java's language features.

High-Performance Computing (HPC) systems are becoming increasingly parallel and heterogeneous. As a consequence, HPC applications, such as simulation software, need to be especially designed towards these systems to achieve optimal performance. This, in turn, leads to higher complexity, making software engineers and scientists require a deep knowledge of the hardware and its technologies. As a remedy, domain-specific languages (DSLs) are a convenient technology for domain experts to describe settings and problems they want to solve using terms and models familiar to them. This specification is transformed into a target language, i. e., source code in another programming language or a binary executable, by a specialized compiler. We propose ExaSlang, a language for the specification of numerical solvers based on the multigrid method targeting distributed-memory systems. Furthermore, we present the transformation framework that drives the corresponding source-to-source compiler. It emits C++ code utilizing a hybrid OpenMP and MPI parallelization. Moreover, we substantiate our approach with scaling results of our code scaling up to the complete JUQUEEN cluster, consisting of 28,672 nodes, with a total of 458,752 cores.

This chapter introduces a novel approach for design of Domain-Specific Languages (DSL). It is very common in practice that the same problems emerge in different application domains (e.g. the modeling support for complex event processing is desirable in the domain of algorithmic trading, IT security assessment, robust monitoring, etc.). A DSL operates in one single domain, but the above-mentioned cross-domain challenges raise the question: is it possible to automate the design of DSLs which are so closely related? This approach demonstrates how a family of domain-specific languages can be developed for multiple domains from a single generic language metamodel with generative techniques. The basic idea is to refine the targeted domain with separating the problem domain from the context domain. This allows designing a generic language based on the problem and customizing it with the appropriate extensions for arbitrary contexts, thus defining as many DSLs and as many contexts as one extends the generic language for. The authors also present an ontology-based approach for establishing context-specific domain knowledge bases. The results are discussed through a case study, where a language for event processing is designed and extended for multiple context domains.

Refactoring is a powerful technique for improving the structural quality of software models and programs. Besides informal, example-driven descriptions of refactorings, a number of languages for specifying refactorings have been developed. Such refactoring languages are either specific to particular programming languages or to particular application purposes. In this paper, we present the generic refactoring language ReL. ReL is a domain-specific language which can be instantiated for any target language with Backus-Naur-style grammar. Thus obtained ReL instances are equally well suited for specifying refactorings and executing them. A tool chain for ReL supports the automatic instantiation for target languages as well as the parsing and execution of refactoring descriptions.

This is the 23rd Self-Assessment Procedure. 1 The purpose of this procedure is to let its readers test their knowledge of some of the more important features of significant programming languages. The features of imperative languages like Fortran, Algol 60, PL/I, Pascal, Modula-2, C, and Ada considered are data types, data structures, control structures, program units, scope of names, and parameter passing. Some of the corresponding features of functional languages like Lisp, logic programming languages like Prolog, and ohject-oriented programming languages like C++ and Smalltalk, are reviewed. Finally brief consideration is given to syntax and semantics, chiefly by reference to the Backus-Naur form, BNF. The features of programming languages affect all aspects of programming, including the ease of writing and maintaining programs, the reliahility of software, and the efficiency and portability of programs. Knowledge of programming language concepts and constructs is of importance to software developers, programmers, and designers of programming languages and compilers. The topic of this procedure should be of interest to any computer science student or practitioner who wishes to test his or her knowledge and learn more about one of the most important and broad areas in the computer field. The language used most often in the questions is Pascal, with Ada, Lisp, and Prolog also featured prominently. A glossary is included which defines some of the terms used in the procedure. The questions are either multiple-choice or short answer. Some of the multiple-choice questions allow for more than one correct answer.

The addition of support for genericity to mainstream programming languages has a notable influence in refactoring tools. This also applies to the JAVA programming language. Those versions of the language specification prior to JAVA 5 did not include support for generics. Therefore, refactoring tools had to evolve to modify their refactoring implementations according to the new language characteristics in order to assure the correct effects when transforming code containing generic definitions or using generic instantiations. This paper presents an evaluation of the behaviour of refactoring tools on source code that defines or uses generics. We compare the behaviour of five refactoring tools on a well known refactoring, Extract Method, and its implementation for the JAVA language. We distill the lessons learned from our evaluation into requirements that have to be taken into account by refactoring tools in order to fully conform to this new language feature.

In large-scale software applications, programmers often combine different programming languages because this allows them to use the most suitable language for a given problem, to gradually migrate existing projects from one language to another, or to reuse existing source code. However, different programming languages have fundamentally different implementations, which are hard to combine. The composition of language implementations often results in complex interfaces between languages, insufficient flexibility, or poor performance. We propose TruffleVM, a virtual machine (VM) that can execute different programming languages and is able to compose them in a seamless way. TruffleVM supports dynamically-typed languages (e.g., JavaScript and Ruby) as well as statically typed low-level languages (e.g., C). It consists of individual language implementations, which translate source code to an intermediate representation that is executed by a shared VM. TruffleVM composes these different language implementations via generic access . Generic access is a language-agnostic mechanism that language implementations use to access foreign data or call foreign functions. It features language-agnostic messages that the TruffleVM resolves to efficient foreign-language-specific operations at runtime. Generic access supports multiple languages, enables an efficient multi-language development, and ensures high performance. We evaluate generic access with two case studies. The first one explains the transparent composition of JavaScript, Ruby, and C. The second one shows an implementation of the C extensions application programming interface (API) for Ruby. We show that generic access guarantees good runtime performance. It avoids conversion or marshalling of foreign objects at the language boundary and allows the dynamic compiler to perform its optimizations across language boundaries.

Source Code Authorship Attribution can answer many interesting questions such as: Who wrote the malicious source code? Is the source code plagiarized, and does it infringe on copyright? Source Code Authorship Attribution is done by observing distinctive patterns of style in a source code whose author is unknown and comparing them with patterns learned from known authors' source codes. In this paper, we present an efficient approach to learn a novel representation using deep metric learning. The existing state of the art approaches tokenize the source code and work on the keyword level, limiting the elements of style they can consider. Our approach uses the raw character stream of source code. It can examine keywords and different stylistic features such as variable naming conventions or using tabs vs. spaces, enabling us to learn a richer representation than other keyword-based approaches. Our approach uses a character-level Convolutional Neural Network (CNN). We train the CNN to map the input character stream to a dense vector, mapping the source codes authored by the same author close to each other. In contrast, source codes written by different programmers are mapped farther apart in the embedding space. We then feed these source code vectors into the K-nearest neighbor (KNN) classifier that uses Manhattan-distance to perform authorship attribution. We validated our approach on Google Code Jam (GCJ) dataset across three different programming languages. We prepare our large-scale dataset in such a way that it does not induce type-I error. Our approach is more scalable and efficient than existing methods. We were able to achieve an accuracy of 84.94% across 20,458 authors, which is more than twice the scale of any previous study under a much more challenging setting.

MDA requires the ability to understand different languages such as general purpose languages, domain specific languages, modeling languages or programming languages. An underlying principle of MDA for integrating semantically in a unified and interoperable way such languages is using metamodeling techniques.