Welcome to the 20th ACM SIGPLAN International Conference on Generative Programming: Concepts & Experiences (GPCE’21). GPCE is the premiere venue for researchers and practitioners interested in techniques that use program generation to increase programmer productivity, improve software quality, and shorten the time-to-market of software products. In addition to exploring cutting-edge techniques of generative software, GPCE seeks to foster cross-fertilization between the software engineering and the programming languages research communities.
Proceeding Downloads
Live programming and programming by example: better together (keynote)
Live programming is a paradigm in which values from program execution are shown to the programmer through continual feedback. Programming by example is a paradigm in which code is synthesized from example values showing a desired behavior. This talk ...
The life cycle of features in highly-configurable software systems evolving in space and time
- Gabriela K. Michelon,
- Wesley K. G. Assunção,
- David Obermann,
- Lukas Linsbauer,
- Paul Grünbacher,
- Alexander Egyed
Feature annotation based on preprocessor directives is the most common mechanism in Highly-Configurable Software Systems (HCSSs) to manage variability. However, it is challenging to understand, maintain, and evolve feature fragments guarded by #ifdef ...
Towards supporting SPL engineering in low-code platforms using a DSL approach
Low-code application platforms enable citizen developers to autonomously build complete applications, such as web applications or mobile applications. Some of these platforms also offer support for reuse to facilitate the development of similar ...
A variational database management system
Many problems require working with data that varies in its structure and content. Current approaches, such as schema evolution or data integration tools, are highly tailored to specific kinds of variation in databases. While these approaches work well ...
Metaprogramming with combinators
There are a wide array of methods for writing code generators. We advocate for a point in the design space, which we call metaprogramming with combinators, where programmers use (and write) combinator libraries that directly manipulate object language ...
Artifact and reference models for generative machine learning frameworks and build systems
Machine learning is a discipline which has become ubiquitous in the last few years. While the research of machine learning algorithms is very active and continues to reveal astonishing possibilities on a regular basis, the wide usage of these algorithms ...
Delta-based verification of software product families
The quest for feature- and family-oriented deductive verification of software product lines resulted in several proposals. In this paper we look at delta-oriented modeling of product lines and combine two new ideas: first, we extend Hähnle & Schaefer’s ...
Extracting the power of dependent types
Most existing programming languages provide little support to formally state and prove properties about programs. Adding such capabilities is far from trivial, as it requires significant re-engineering of the existing compilers and tools. This paper ...
Lifted termination analysis by abstract interpretation and its applications
This paper is focused on proving termination for program families with numerical features by using abstract interpretation. Furthermore, we present an interesting application of the above lifted termination analysis for resolving “sketches”, i.e. ...
Multi-stage programming with generative and analytical macros
In metaprogramming, code generation and code analysis are complementary. Traditionally, principled metaprogramming extensions for programming languages, like MetaML and BER MetaOCaml, offer strong foundations for code generation but lack equivalent ...
Compiling pattern matching to in-place modifications
Algebraic data types and pattern matching are popular tools to build programs manipulating complex datastructures in a safe yet efficient manner. On top of its safety advantages, compilation techniques can turn pattern matching into highly efficient ...
HACCLE: metaprogramming for secure multi-party computation
- Yuyan Bao,
- Kirshanthan Sundararajah,
- Raghav Malik,
- Qianchuan Ye,
- Christopher Wagner,
- Nouraldin Jaber,
- Fei Wang,
- Mohammad Hassan Ameri,
- Donghang Lu,
- Alexander Seto,
- Benjamin Delaware,
- Roopsha Samanta,
- Aniket Kate,
- Christina Garman,
- Jeremiah Blocki,
- Pierre-David Letourneau,
- Benoit Meister,
- Jonathan Springer,
- Tiark Rompf,
- Milind Kulkarni
Cryptographic techniques have the potential to enable distrusting parties to collaborate in fundamentally new ways, but their practical implementation poses numerous challenges. An important class of such cryptographic techniques is known as Secure ...
MADMAX: a DSL for explanatory decision making
MADMAX is a Haskell-embedded DSL for multi-attribute, multi-layered decision making. An important feature of this DSL is the ability to generate explanations of why a computed optimal solution is better than its alternatives.
The functional approach ...
On-stack replacement for program generators and source-to-source compilers
On-stack replacement (OSR) describes the ability to replace currently executing code with a different version, either a more optimized one (tiered execution) or a more general one (deoptimization to undo speculative optimization). While OSR is a key ...
Leveraging relational concept analysis for automated feature location in software product lines
Formal Concept Analysis (FCA) has been introduced for almost a decade as a suitable method for Feature Location (FL) on a collection of product variants. Even though FCA-based FL techniques allow to locate the core of a feature implementation, they do ...
Type-safe generation of modules in applicative and generative styles
The MetaML approach for multi-stage programming provides the static guarantee of type safety and scope safety for generated code, regardless of the values of static parameters. Modules are indispensable to build large-scale programs in ML-like languages,...
Understanding and improving model-driven IoT systems through accompanying digital twins
Developers questioning why their system behaves differently than expected often have to rely on time-consuming and error-prone manual analysis of log files. Understanding the behavior of Internet of Things (IoT) applications is a challenging task ...
Index Terms
- Proceedings of the 20th ACM SIGPLAN International Conference on Generative Programming: Concepts and Experiences