GPCE 2019 - 18th International Conference on Generative Programming: Concepts & Experiences

Break

A function has been used as an entry point of the interface to a library written in a different, or foreign, language. This interface is important for a new language because it lacks libraries and thus needs to borrow libraries written in a foreign language when the programmer develops a practical application in that new language. However, a modern library often uses unique language mechanism of the implementation language. This makes the use of the library difficult through a traditional function-based interface from the new language. This paper presents our approach to this problem. We use a domain specific language (DSL) embedded in the new language and migrate the DSL code to access to the library written in the foreign language. This paper also presents our framework for migrating the DSL code to a foreign language environment. The framework supports DSL-specific syntax checking for the migrated DSL code.

Shigeru Chiba

Graduate School of Information Science and Technology, The University of Tokyo

Japan

Programming languages with sufficiently expressive type theories provide users with essentially two levels of data ‘bundling’. This applies in particular to dependently-typed languages such as Agda, Coq, and Idris, where one can choose to make certain constituents of a record either parameters or fields. For example, we can speak of graphs /over/ a particular vertex set, or speak of arbitrary graphs wherein the vertex set is a component. These create isomorphic types, but differ with respect to convenience. Traditionally, a library designer would make this choice between parameters and fields; if a user wants a different variant, they are forced to build conversion utilities as well as duplicate functionality. In our earlier example about graph datatypes, if a library only provides a Haskell-like typeclass view of graphs /over/ a vertex set, yet a user wishes to work with the category of graphs, they must now package a vertex set as a component in a record along with a graph over that set.

We design and implement a language feature that allows both the library designer and the user to make the choice of information exposure only when necessary and otherwise leave the distinguishing line between parameters and fields unspecified. Our language feature is currently prototypically implemented as a meta-program that is not only easily incorporated into Agda’s Emacs ecosystem, but is also unobtrusive to Agda users.

Musa Al-hassy

McMaster University

Wolfram Kahl

McMaster University

Canada

Jacques Carette

McMaster University

Canada

This short paper explores parallel nondeterministic programming as an extension to the C programming language; it provides new constructs for specification of code containing ambiguous choice as first introduced by McCarthy. A translator to plain C code was implemented as an extension to the AbleC language specification. Translation involves a transformation to continuation passing style, providing lazy choice by storing continuation closures in a separate task buffer. This exploration considers various strengths of search-ordering semantics, and their impact on correctness. Multiple search evaluation drivers were implemented, including single-threaded depth-first search, a combined breadth- and depth-first approach, as well as two approaches to parallelism. Multiple nondeterministic benchmark applications were created using the extension, including N-Queens, SAT, and triangle peg solitaire. The simplest parallel search driver, using independent threads, showed the best performance in most cases, providing a significant speedup over the sequential versions. The parallel search driver with the addition of task sharing between threads typically often showed similar performance.

Lucas Kramer

University of Minnesota

Eric Van Wyk

University of Minnesota, USA

United States

Domain Specific Languages (DSLs) have proven useful in the domain of data science, as witnessed by the popularity of SQL, and emergence of DSLs like Trifacta Data Wrangler Language. However, implementing and maintaining a DSL incurs a significant effort which limits their utility in context of fast-changing data science frameworks and libraries.

We propose an approach and a Python-based library/tool NLDSL which simplifies and streamlines implementation of DSLs modeling pipelines of operations. NLDSL offers an “easy to use” interface to add new pipeline operations. In particular, syntax description and operation implementation are bundled together as annotated and terse Python functions, which simplifies extending and maintaining a DSL. To support ad hoc DSL elements, NLDSL offers a mechanism to define DSL-level functions which are then treated as first-class DSL elements.

Our tool automatically supports each DSL by code completions and in-editor documentation in a multitude of IDEs implementing the Microsoft’s Language Server Protocol. To circumvent the problem of a limited expressiveness of a external DSL, our tool allows embedding DSL statements in the source code comments of a general purpose language and to translate the DSL to such a language during editing.

We demonstrate and evaluate our approach and tool by implementing a DSL for data tables which is translated to either Pandas or to PySpark code. A preliminary evaluation shows that this DSL can be defined in a concise and maintainable way, and that it can cover a majority of processing steps of popular Spark/Pandas tutorials.

Artur Andrzejak

Heidelberg University

Germany

Kevin Kiefer

Diego Costa

Heidelberg University

Oliver Wenz

Heidelberg University

We propose a novel approach for compiling MATLAB and similar languages that are characterized by multi-dimensional arrays with dynamic shapes and element types. We stage an evaluator for a subset of the MATLAB language using the Lightweight Modular Staging (LMS) framework to produce a compiler that generates C code. But the first Futamura projection alone does not lead to efficient code: we need to refine the rigid stage distinction based on inferred type and shape information to remove costly runtime checks.

To this end, we introduce a stage-polymorphic data structure, that we refer to as metacontainer, to represent MATLAB tensors and their type and shape information. We use metacontainers to efficiently ``inject'', in a high-level intermediate representation (IR) of a MATLAB program, constructs for inferring shape and type information.

Once type and shape information are inferred, metacontainers are also used as the primary abstraction for lowering the computation, performing type, shape and ISA specialization. Our prototype MATLAB compiler MGen produces static C code that supports all primitive types, heavily overloaded operators, many other dynamic aspects of the language, and explicit vectorization for SIMD architectures.

Alen Stojanov

ETH Zurich

Switzerland

Tiark Rompf

Purdue University

United States

Markus Püschel

ETH Zürich

Switzerland

This paper presents a technique for realizing reflection in attribute grammars. It is implemented and evaluated in the Silver attribute grammar system in the form of a reflect function mapping typed syntax trees and other values into a generic representation and a reify function for the inverse mapping. This is especially useful in meta-programming systems in which syntax trees are properly typed, both in the meta-language of the system and in the implementation to which the meta-language is translated. This is the case in Silver, a strongly typed language that translates to Java.

We demonstrates its usefulness in several ways. The first is in an extension to Silver for writing language extensions for the AbleC extensible C specification. This allows language developers to specify complete C syntax trees using the concrete syntax of C, with typed holes, instead of writing abstract syntax trees, saving almost 18,000 lines of specifications. Secondly, a scrap-your-boilerplate style substitution mechanism is also described. The third use is in serialization and deserialization of the interface files Silver generates to support separate compilation; a custom interface language was replaced by a generic reflection-based implementation saving around 2,000 lines of specifications. Finally, an experimental implementation of staged interpreters for a small staged functional language is discussed.

Lucas Kramer

University of Minnesota

Ted Kaminski

University of Minnesota

United States

Eric Van Wyk

University of Minnesota, USA

United States

This paper introduces polymorphic extractors, a technique for tackling two main issues with the existing pattern matching implemented in functional languages. First, this technique defines semantical pattern matching rather than a syntactical one. Second, this technique solves the portability issue when defining a set of patterns based on different underlying data-structure design choices. Furthermore, polymorphic extractors can be further improved by performing optimisations and multi-stage programming on them. The key technique behind polymorphic extractors is using the tagless-final technique (a.k.a. polymorphic embedding/object algebra) for defining different views or extractors over expression terms.

Amir Shaikhha

University of Oxford

Interactive distributed software ranging from multi-user collaborative apps (e.g., Google Docs) to software for real-time organizations (e.g., Uber apps) typically rely on centralized data storages and callback-driven interactions to enable lively collaborations. However, callback-driven interactions are infamous for leading to complexity hell and centralized storage of data is deficient in terms of offline availability, low latency, user-control on data privacy and overall architecturally not a good match in the era of programmable network devices and powerful mobile end-devices. On the other hand, while decentralized storage of data seems a natural choice for handling the problems with offline availability, low latency, and data privacy, when building decentralized applications developers cannot anymore rely on solutions for fault-tolerance and concurrency control built-into centralized data storage systems and would have to treat those at the application layer. In the talk, I will argue for the effectiveness of declarative programming abstractions inspired by the functional reactive programming not only in managing the complexity that comes with enabling interactivity and real-time liveness without the callback hell but also in enabling the language runtime to automatically handle intricate aspects of distributed decentralized software such as concurrency control and fault-tolerance with strong “out-of-the-box” consistency guarantees. I will do so by introducing such abstractions in the context of REScala, a library-based extension to the Scala programming language.

Mira MeziniKeynote Speaker

Technische Universität Darmstadt

Germany

I am a Professor of Computer Science at the Technical University of Darmstadt, Germany.

My research focuses on software development paradigms and tools.

On the paradigms side, I develop programming languages to enable the visions of “software as a service (SaaS)” and “software product-lines” by providing large-scale module concepts with built-in support for adaptability and extensibility.

On the tools side, I work on intelligent software-development environments that guide developers to increase the development productivity and the software quality. Such environment leverage web-based resources to automatically generate and recommend established programming rules and patterns; they also enable architects to explicitly specify such patterns to be enforced during development.

I have (co)authored over 100 scientific publications in renowned publication venues in software engineering and programming languages. I regularly serve on steering committees, program committees, and editorial boards of top tier conferences and journals in software engineering and programming languages.

In model-based software engineering, models are central artifacts used for management, design and implementation. To meet new requirements, engineers need to plan and perform model evolution. So far, model evolution histories are captured using Version Control Systems (VCSs), e.g., Git. However, these systems are unsuitable for planning model evolution as they do not have a notion of future changes. Furthermore, formally assigning responsibilities to engineers for performing evolution of model parts is achieved by using additional tools for access control. To remedy these shortcomings, we provide a method to generate evolution-aware modeling notations by augmenting existing metamodels with concepts for capturing past and planned evolution as first-class entity. Our method enables engineers to seamlessly plan future model evolution while actively developing the current model state, both using a centralized access point for evolution. In our evaluation, we provide an implementation of our method in the tool TemporalRegulator3000, show applicability for real-world metamodels, and capture the entire evolution time line of corresponding models.

Michael Nieke

TU Braunschweig, Germany

Adrian Hoff

TU Braunschweig

Christoph Seidl

Technische Universität Braunschweig

Distinguished Paper Award

In modern runtime systems, memory layout calculations are hand-coded in low-level systems languages. The primitives in these languages are not powerful enough to describe a rich set of layouts, leading developers to rely on ad-hoc macros as well as numerous interrelated static constants and other boilerplate code. A memory management policy must also carefully orchestrate all the different address calculations to modify memory cooperatively, a task ill-suited to the low-level systems languages at hand which do not provide the proper safety mechanisms.

In this paper we introduce Floorplan, a declarative language for specifying memory layouts at a high level. Constraints formerly implemented by describing how to compute locations are, in Floorplan, defined declaratively using explicit layout constructs. The challenge here was to discover layout constructs capable of sufficiently and soundly enabling the automatic generation of address calculations, including code deemed unsafe according to the memory safety paradigm of Rust. Floorplan is implemented as a compiler for generating a Rust library from a Floorplan specification. In a case study of an existing implementation of the immix garbage collection algorithm, Floorplan eliminates 55 out of the 63 unsafe lines of code: 100% of the unsafe lines of code pertaining to memory safety.

Karl Cronburg

Tufts University

United States

Sam Guyer

Tufts University

United States

Language-oriented programming is a paradigm which advocates using domain-specific languages (DSLs) for developing the different components of a software system. Language workbenches are key tools for facilitating the development of DSLs. However, none of the existing language workbenches deliver an efficient development process for performance-oriented DSLs.

In this paper, we present a framework for generating optimizing compilers for performance-oriented embedded domain-specific languages (EDSLs). This framework provides facilities to automatically generate the boilerplate code required for building DSL compilers on top of the existing extensible optimizing compilers. We evaluate the practicality of our framework by demonstrating two real-world use-cases successfully built with it.

Amir Shaikhha

University of Oxford

Vojin Jovanovic

Oracle Labs

Switzerland

Christoph E. Koch

EPFL

Many software systems are today variational. They can produce a potentially large variety of related programs (variants) by selecting suitable configuration options (features) at compile time. Specialized variability-aware (lifted, family-based) static analyses allow analyzing all variants of the family, simultaneously, in a single run without generating any of the variants explicitly. The elements of the lifted analysis domain represent tuples (i.e. disjunction of properties), which maintain one property from an existing single-program analysis domain per variant. Nevertheless, explicit property enumeration in tuples, one by one for all variants, immediately yields to combinatorial explosion given that the number of variants can grow exponentially with the number of features. Therefore, such lifted analyses may be too costly or even infeasible for families with a large number of variants.

In this work, we propose a more efficient lifted static analysis where sharing is explicitly possible between analysis elements corresponding to different variants. This is achieved by giving an symbolic representation of the lifted analysis domain, which can efficiently handle disjunctive properties in program families. The elements of the new lifted domain are binary decision diagrams where decision nodes are labeled with features, and the leaf nodes belong to an existing single-program analysis domain. We have developed such efficient lifted analysis which uses APRON and BDDAPRON libraries for implementing the new lifted analysis domain. The APRON library, used for the leaves, is a widely accepted API for numerical abstract domains (e.g. polyhedra, octagons, intervals), while the BDDAPRON is an extension of APRON which adds the power domain of Boolean formulae and any APRON domain. Through experiments applied to C program families, we show that our new BDD-based approach outperforms the old tuple-based approach for lifted analysis.

Aleksandar S. Dimovski

A feature model describes commonalities and variability within a software product line (SPL) and represents the configuration options at one point in time. A temporal feature model (TFM) additionally represents feature model evolution, e.g., the change history or the planning of future releases. The increasing number of different TFM notations hampers research collaborations due to a lack of interoperability regarding notations, editors and analyses. We present a common API for TFMs, which provides the core of a TFM ecosystem, to harmonize notations. Our approach allows to work seamlessly with different TFM notations to perform, track, analyze and replay evolution. We identified the requirements for the API based on systematically classifying and comparing capabilities of existing TFM approaches. Our evaluation demonstrates the expressiveness and utility of our approach by presenting implementations for several existing (T)FM notations and replaying evolution histories from two case study systems.

Daniel Hinterreiter

Johannes Kepler University Linz

Austria

Michael Nieke

TU Braunschweig, Germany

Lukas Linsbauer

Austria

Christoph Seidl

Technische Universität Braunschweig

Herbert Prähofer

Johannes Kepler University Linz

Paul Grünbacher

Johannes Kepler University Linz, Austria

Austria

Feature models are a de facto standard for representing the commonalities and variability of product lines and configurable software systems. Requirements-level features are commonly implemented in multiple source code artifacts, which results in complex dependencies at the code-level. Furthermore, as developers need to change and evolve features frequently, it is challenging to keep feature models consistent with their implementation. We present and evaluate an approach combining feature-to-code mappings and code dependency analyses to inform engineers about possible inconsistencies in the feature model. Our focus are code-level changes requiring updates in feature dependencies and constraints. Our approach uses static code analysis and a variation control system to lift complex code-level dependencies to feature models. We present the suggested dependencies to the engineer in two ways: directly as links between features in a feature model and as a heatmap visualizing the dependency changes of all features in a model. We present results of an evaluation on the Pick-and-Place Unit system, which demonstrates the utility or our approach and the quality of the suggestions.

Kevin Feichtinger

Johannes Kepler University Linz

Daniel Hinterreiter

Johannes Kepler University Linz

Austria

Lukas Linsbauer

Austria

Herbert Prähofer

Johannes Kepler University Linz

Paul Grünbacher

Johannes Kepler University Linz, Austria

Austria