GPCE 2025
24th ACM SIGPLAN International Conference on Generative Programming: Concepts and Experiences (GPCE 2025)

Title Page

Welcome from the Chairs
Welcome to the 24th ACM SIGPLAN International Conference on Generative Programming: Concepts & Experiences (GPCE’25). GPCE is the premier 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 programming languages research communities.

GPCE 2025 Organization

Sponsors

Integrating Static Optimization and Dynamic Nature in JavaScript
Tadashi Saito and Hideya Iwasaki
(University of Electro-Communications, Japan; Meiji University, Japan)


Article Search

Retrofitting a Virtual Instrument DSL with Programming Abstractions
Mathias Vatter and Sebastian Erdweg
(JGU Mainz, Germany)
KSP is an imperative DSL in music production that enables realistic modelling of musical instruments in real-time using Kontakt as a runtime environment. Once a niche topic for hobbyists, the field has since professionalized, with Kontakt becoming an industry standard. Its scripting language, however, has not evolved much, lacking modern functional and data abstractions while remaining closed-source. This paper proposes transformations that introduce modularity and basic abstraction principles to KSP. This entails functions with parameters and return values, recursive data types, and the implementation of lexical scope to replace the current global variable management. The transformations have been implemented in a preprocessing compiler framework--preceding the actual KSP interpreter--to an extend, that allows for the new syntax elements to be used in real-world KSP scripts.

Article Search

P4DDG: Data-Dependent Grammars for Packet Specification and Parsing in P4
Tommaso Pacciani, Damian Frolich, L. Thomas van Binsbergen, and Chrysa Papagianni
(University of Amsterdam, Netherlands)


Article Search

Staged Gradual Typing
Hiroto Yaguchi and Yukiyoshi Kameyama
(University of Tsukuba, Japan)


Article Search

Comparative Analysis of Pre-trained Code Language Models for Automated Program Repair via Code Infill Generation
Iman Hemati Moghadam, Oebele Lijzenga, and Vadim Zaytsev
(Eindhoven University of Technology, Netherlands; Universiteit Twente, Netherlands)
Automated Program Repair (APR) has advanced significantly with the emergence of pre-trained Code Language Models (CLMs), enabling the generation of high-quality patches. However, selecting the most suitable CLM for APR remains challenging due to a range of factors, including accuracy, efficiency, and scalability, among others. These factors are interdependent and interact in complex ways, making the selection of a CLM for APR a multifaceted problem.
This study systematically evaluates 20 pre-trained CLMs, ranging from 60M to 16B parameters, on the HumanEval-Java benchmark (163 buggy Java methods). The evaluation examines bug-fixing accuracy, resource consumption, compilability, patch diversity, and sampling strategies (beam search vs. nucleus sampling).
Results indicate that larger models such as CodeLLaMA-13B and StarCoder generally perform better in bug fixing and compiler error handling, but scale alone does not guarantee effectiveness, as some (e.g., CodeGen2) perform poorly despite their size. Notably, memory usage increases with model size, but time consumption does not exhibit a clear correlation, suggesting that efficiency is influenced by architecture rather than scale alone. Additionally, nucleus sampling slightly outperforms beam search, though the difference is not statistically significant. Since no single CLM fixes all bugs, these findings highlight the potential of hybrid or ensemble-based CLM-driven APR approaches for more robust bug-fixing.

Article Search Info

A Stable Model Semantics for eFLINT Norm Specifications and Model Checking Scenarios
Christopher A. Esterhuyse, Tim Müller, and L. Thomas van Binsbergen
(University of Amsterdam, Netherlands)
Since its introduction at GPCE2020, the eFLINT norm specification language has been used in academic and industrial applications to specify and automate compliance for various norms, such as privacy regulations and data processing agreements. The eFLINT interpreter has been used to automate the analysis of real-time or historical cases by computing logical consequences and reporting normative violations.
To support future language and tooling developments, we contribute a formal definition of the language as a translation to first-order logic programming with stable model semantics. The described semantics aligns with the previous semi-formal descriptions of the language, but resolves issues relating to logical inference with negative antecedent and aggregation operators. Specifically, we formalise the connection between eFLINT's derivation rules and Horn clauses under the stable model semantics. Secondly, by repurposing the Clingo answer-set solver as a highly-optimised eFLINT interpreter, we extend the toolset for eFLINT with model-checking abstract properties in addition to case analysis.
We evaluate the new semantics and interpreter via an empirical comparison of the existing implementation to our prototype implementation. We observe that the expected subset of our tests have the equivalent behaviours.

Article Search Artifacts Available Artifacts Functional Results Reproduced

CoCoCoLa: Code Completion Control Language
Nhat Bui and Vadim Zaytsev
(University of Twente, Netherlands)


Article Search

Imperative Program Synthesis by Abstract Static Analysis and SMT Mutations
Aleksandar S. Dimovski
(Mother Teresa University, Skopje, North Macedonia)
This paper introduces a novel technique for synthesizing imperative programs that meet behavioral specifications given in the form of assumptions and assertions (logic formulas). In particular, we combine basic statement-directed enumerative search, static analysis via abstract interpretation, and expression-directed enumerative search via (incremental) SMT-based mutations to efficiently explore all candidate complete programs generated from an input program template (with statement and expression holes) until a solution is found. Firstly, the algorithm uses a basic enumerative search through the space of all possible statements, thus filling in all statement holes. In effect, we obtain partial programs with only missing (arithmetic and boolean) expressions, which are subsequently classified by a static analysis either as potential solutions or as definite failures. Finally, we repeatedly mutate the missing expressions in potential solutions and check if the resulting complete programs become bounded correct with respect to the given assertions.
We have implemented our technique in a prototype tool and evaluated it on a set of introductory C programs. The experimental results confirm the effectiveness of our technique for synthesizing various interesting C programs.

Article Search Artifacts Available Artifacts Functional Results Reproduced