Performing systematic literature reviews with Researchr: Tool demonstration

This paper describes the workflow for performing systematic literature reviews with the researchr digital library environment.Software TechnologyElectrical Engineering, Mathematics and Computer Scienc

Understanding software through linguistic abstraction

Preprint submitted to "Science of Computer Programming", Elsevier, http://dx.doi.org/10.1016/j.scico.2013.12.001 In this essay, I argue that linguistic abstraction should be used systematically as a tool to capture our emerging understanding of domains of computation. Moreover, to enable that systematic application, we need to capture our understanding of the domain of linguistic abstraction itself in higher-level meta languages. The argument is illustrated with examples from the SDF, Stratego, Spoofax, and WebDSL projects in which I explore these ideas.Software Computer TechnologyElectrical Engineering, Mathematics and Computer Scienc

Domain-Specific Language Engineering: A Case Study in Agile DSL Development (Mark I)

The goal of domain-specific languages (DSLs) is to increase the productivity of software engineers by abstracting from low-level boilerplate code. Introduction of DSLs in the software development process requires a smooth workflow for the production of DSLs themselves. This tutorial gives an overview of all aspects of DSL engineering: domain analysis, language design, syntax definition, code generation, deployment, and evolution, discussing research challenges on the way. The concepts are illustrated with DSLs for web applications built using several DSLs for DSL engineering: SDF for syntax definition, Stratego/XT for code generation, and Nix for software deployment. Preprint accepted for publication in 2nd Summer School on Generative and Transformational Techniques in Software Engineering, 2 - 7 July, 2007, Braga, Portugal.Software TechnologyElectrical Engineering, Mathematics and Computer Scienc

System Identification using the Multivariate Simplotope B-Spline

In recent research efforts the multivariate simplex spline has shown great promise in system identification applications. It has high approximation power, while its linearity in the parameters allows for computationally efficient estimation of the coefficients. In this paper the multivariate simplotope spline is derived from this spline, and compared to its simplex counterpart in a system identification setting. Contrary to the simplex spline, the simplotope spline allows the user to incorporate expert knowledge of the system in his models. Whereas in the first spline all variables are included in a complete polynomial, in the latter the user can split the variables in decoupled subsets. By fitting models to specifically designed test functions it is shown that this can indeed improve the approximation performance in terms of both the error metrics and the number of B-coefficients required. This comes at the price of a higher total degree, and therefore an increased sensitivity to Runge's phenomenon in case of poor data distribution. Finally an attempt is made to apply the proposed methods to a set of flight data of the DelFly II, a flapping wing micro aerial vehicle. It is found that the used data set is not suitable for global system identification, as the data in concentrated in low-dimensional clusters in the five-dimensional state space. Therefore it is advised that a more suitable data set is obtained to validate the simplotope spline in a system identification setting.Control & SimulationAstrodynamics & Space Mission

Grammar Engineering Support for Precedence Rule Recovery and Compatibility Checking

A wide range of parser generators are used to generate parsers for programming languages. The grammar formalisms that come with parser generators provide different approaches for defining operator precedence. Some generators (e.g. YACC) support precedence declarations, others require the grammar to be unambiguous, thus encoding the precedence rules. Even if the grammar formalism provides precedence rules, a particular grammar might not use it. The result is grammar variants implementing the same language. For the C language, the GNU Compiler uses YACC with precedence rules, the C-Transformers uses SDF without priorities, while the SDF library does use priorities. For PHP, Zend uses YACC with precedence rules, whereas PHP-front uses SDF with priority and associativity declarations. The variance between grammars raises the question if the precedence rules of one grammar are compatible with those of another. This is usually not obvious, since some languages have complex precedence rules. Also, for some parser generators the semantics of precedence rules is defined operationally, which makes it hard to reason about their effect on the defined language. We present a method and tool for comparing the precedence rules of different grammars and parser generators. Although it is undecidable whether two grammars define the same language, this tool provides support for comparing and recovering precedence rules, which is especially useful for reliable migration of a grammar from one grammar formalism to another. We evaluate our method by the application to non-trivial mainstream programming languages, such as PHP and C. Presented at LDTA 2007 Seventh Workshop on Language Descriptions, Tools and Applications, 25-3-2007, Braga, PortugalSoftware TechnologyElectrical Engineering, Mathematics and Computer Scienc

Preventing Injection Attacks with Syntax Embeddings: A Host and Guest Language Independent Approach

Software written in one language often needs to construct sentences in another language, such as SQL queries, XML output, or shell command invocations. This is almost always done using unhygienic string manipulation, the concatenation of constants and client-supplied strings. A client can then supply specially crafted input that causes the constructed sentence to be interpreted in an unintended way, leading to an injection attack. We describe a more natural style of programming that yields code that is impervious to injections by construction. Our approach embeds the grammars of the guest languages (e.g., SQL) into that of the host language (e.g., Java) and automatically generates code that maps the embedded language to constructs in the host language that reconstruct the embedded sentences, adding escaping functions where appropriate. This approach is generic, meaning that it can be applied with relative ease to any combination of host and guest languages. Preprint accepted for publiction in: Generative Programming and Component Engineering, 6th International Conference, GPCE 2007, Salzburg, Austria, October 1-3, 2007Software TechnologyElectrical Engineering, Mathematics and Computer Scienc

IceDust 2: Derived Bidirectional Relations and Calculation Strategy Composition (Artifact)

Programming Language

Designing Syntax Embeddings and Assimilations for Language Libraries

Preprint of paper published in: Models in Software Engineering, Lecture Notes in Computer Science 5002, 2008; doi:10.1007/978-3-540-69073-3_5 Language libraries extend regular libraries with domain-specific notation. More precisely, a language library is a combination of a domain-specific language embedded in the general-purpose host language, a regular library implementing the underlying functionality, and an assimilation transformation that maps embedded DSL fragments to host language code. While the basic architecture for realizing language libraries is the same for all applications, there are many design choices to be made in the design of a particular combination of library, guest language syntax, host language, and assimilation. In this paper, we give an overview of the design space for syntax embeddings and assimilations for the realization of language libraries.Software Computer TechnologyElectrical Engineering, Mathematics and Computer Scienc

Fusing a Transformation Language with an Open Compiler

Program transformation systems provide powerful analysis and transformation frameworks as well as concise languages for language processing, but instantiating them for every subject language is an arduous task, most often resulting in halfcompleted frontends. Compilers provide mature frontends with robust parsers and type checkers, but solving language processing problems in general-purpose languages without transformation libraries is tedious. Reusing these frontends with existing transformation systems is therefore attractive. However, for this reuse to be optimal, the functional logic found in the frontend should be exposed to the transformation system – simple data serialization of the abstract syntax tree is not enough, since this fails to expose important compiler functionality, such as import graphs, symbol tables and the type checker. In this paper, we introduce a novel and general technique for combining term-based transformation systems with existing language frontends. The technique is presented in the context of a scriptable analysis and transformation framework for Java built on top of the Eclipse Java compiler. The framework consists of an adapter automatically extracted from the abstract syntax tree of the compiler and an interpreter for the Stratego program transformation language. The adapter allows the Stratego interpreter to rewrite directly on the compiler AST. We illustrate the applicability of our system with scripts written in Stratego that perform framework and library-specific analyses and transformations. This paper is a pre-print of: K. T. Kalleberg and E. Visser. Fusing a Transformation Language with an Open Compiler. In A. Sloane and A. Johnstone, editors, Seventh Workshop on Language Descriptions, Tools, and Applications (LDTA’07), pages 18–31, Braga, Portugal, March 2007.Software TechnologyElectrical Engineering, Mathematics and Computer Scienc

Declaratively Programming the Mobile Web with Mobl

A new generation of mobile touch devices, such as the iPhone, Android and iPad, are equipped with powerful, modern browsers. However, regular websites are not optimized for the specific features and constraints of these devices, such as limited screen estate, unreliable Internet access, touch-based interaction patterns, and features such as GPS. While recent advances in web technology enable web developers to build web applications that take advantage of the unique properties of mobile devices, developing such applications is not a clean, well-integrated experience. Developers are required to use many loosely coupled languages with limited tool support and application code is often verbose and imperative. We introduce mobl, a new language designed to declaratively construct mobile web applications. Mobl integrates languages for user interface design, data modeling and querying, scripting and web services into a single, unified language that is flexible, expressive, enables early detection of errors, and has good IDE support. We illustrate the design of the language with the implementation of ConfPlan, an application for keeping track of the schedule of conference events.Software TechnologyElectrical Engineering, Mathematics and Computer Scienc