Volume
OASIcs, Volume 134
Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025)
-
Part of:
Series:
Open Access Series in Informatics (OASIcs)
Conference: International Conference on the Art, Science, and Engineering of Programming
Event
Programming 2025, June 2-6, 2025, Prague 1, CzechiaEditors
Publication Details
- published at: 2025-09-17
- Publisher: Schloss Dagstuhl – Leibniz-Zentrum für Informatik
- ISBN: 978-3-95977-382-9
Access Numbers
- Detailed Access Statistics available here
-
Total Document Accesses (updated on a weekly basis):
0PDF Downloads
Documents
No documents found matching your filter selection.
Document
Complete Volume
OASIcs, Volume 134, Programming 2025, Complete Volume
Abstract
OASIcs, Volume 134, Programming 2025, Complete Volume
Cite as
Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025). Open Access Series in Informatics (OASIcs), Volume 134, pp. 1-326, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2025)
Copy BibTex To Clipboard
@Proceedings{edwards_et_al:OASIcs.Programming.2025,
title = {{OASIcs, Volume 134, Programming 2025, Complete Volume}},
booktitle = {Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025)},
pages = {1--326},
series = {Open Access Series in Informatics (OASIcs)},
ISBN = {978-3-95977-382-9},
ISSN = {2190-6807},
year = {2025},
volume = {134},
editor = {Edwards, Jonathan and Perera, Roly and Petricek, Tomas},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/OASIcs.Programming.2025},
URN = {urn:nbn:de:0030-drops-247027},
doi = {10.4230/OASIcs.Programming.2025},
annote = {Keywords: OASIcs, Volume 134, Programming 2025, Complete Volume}
}
Document
Front Matter
Front Matter, Table of Contents, Preface, Conference Organization
Abstract
Front Matter, Table of Contents, Preface, Conference Organization
Cite as
Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025). Open Access Series in Informatics (OASIcs), Volume 134, pp. 0:i-0:xxii, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2025)
Copy BibTex To Clipboard
@InProceedings{edwards_et_al:OASIcs.Programming.2025.0,
author = {Edwards, Jonathan and Perera, Roly and Petricek, Tomas},
title = {{Front Matter, Table of Contents, Preface, Conference Organization}},
booktitle = {Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025)},
pages = {0:i--0:xxii},
series = {Open Access Series in Informatics (OASIcs)},
ISBN = {978-3-95977-382-9},
ISSN = {2190-6807},
year = {2025},
volume = {134},
editor = {Edwards, Jonathan and Perera, Roly and Petricek, Tomas},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/OASIcs.Programming.2025.0},
URN = {urn:nbn:de:0030-drops-247014},
doi = {10.4230/OASIcs.Programming.2025.0},
annote = {Keywords: Front Matter, Table of Contents, Preface, Conference Organization}
}
Document
Extended Abstract
Comparing R Bytecode Compilers Written in R, Java, and Rust (Extended Abstract)
Abstract
This paper presents a comparative analysis of three implementations of the R bytecode compiler: the official R implementation, a Java-based compiler, and a Rust-based compiler. The R compiler, written in R itself, poses challenges in terms of performance and maintainability. We evaluate designs of the compilers, their trade-offs, and performance characteristics. The Rust version outperforms the Java version, which itself outperforms the R version.
Cite as
Pierre Donat-Bouillud, Filip Křikava, Jakob Hain, Adam Plodek, and Jan Vitek. Comparing R Bytecode Compilers Written in R, Java, and Rust (Extended Abstract). In Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025). Open Access Series in Informatics (OASIcs), Volume 134, pp. 1:1-1:6, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2025)
Copy BibTex To Clipboard
@InProceedings{donatbouillud_et_al:OASIcs.Programming.2025.1,
author = {Donat-Bouillud, Pierre and K\v{r}ikava, Filip and Hain, Jakob and Plodek, Adam and Vitek, Jan},
title = {{Comparing R Bytecode Compilers Written in R, Java, and Rust}},
booktitle = {Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025)},
pages = {1:1--1:6},
series = {Open Access Series in Informatics (OASIcs)},
ISBN = {978-3-95977-382-9},
ISSN = {2190-6807},
year = {2025},
volume = {134},
editor = {Edwards, Jonathan and Perera, Roly and Petricek, Tomas},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/OASIcs.Programming.2025.1},
URN = {urn:nbn:de:0030-drops-242854},
doi = {10.4230/OASIcs.Programming.2025.1},
annote = {Keywords: R, bytecode, compiler}
}
Document
Extended Abstract
Towards a Java Virtual Machine for Processing-In-Memory (Extended Abstract)
Abstract
Processing-in-Memory (PIM) is a computing paradigm in which computation takes place in or near memory devices, offering high-bandwidth yet energy-efficient data-parallel processing. Real-world PIM systems have recently emerged, and SPMD-style programming in C is supported there. However, high-level object-oriented programming in managed languages has never been studied. Pursuing high-level programming for offloading Java applications to PIM processors, we are developing a Java framework to support it. As a status report on our project, we present our prototype Java VM built upon a real-world PIM system and experimentally demonstrate its scalability. The experimental results showed the potential of our Java VM on the PIM system with thousands of PIM processors.
Cite as
Kazuki Ichinose, Shigeyuki Sato, and Tomoharu Ugawa. Towards a Java Virtual Machine for Processing-In-Memory (Extended Abstract). In Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025). Open Access Series in Informatics (OASIcs), Volume 134, pp. 2:1-2:5, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2025)
Copy BibTex To Clipboard
@InProceedings{ichinose_et_al:OASIcs.Programming.2025.2,
author = {Ichinose, Kazuki and Sato, Shigeyuki and Ugawa, Tomoharu},
title = {{Towards a Java Virtual Machine for Processing-In-Memory}},
booktitle = {Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025)},
pages = {2:1--2:5},
series = {Open Access Series in Informatics (OASIcs)},
ISBN = {978-3-95977-382-9},
ISSN = {2190-6807},
year = {2025},
volume = {134},
editor = {Edwards, Jonathan and Perera, Roly and Petricek, Tomas},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/OASIcs.Programming.2025.2},
URN = {urn:nbn:de:0030-drops-242862},
doi = {10.4230/OASIcs.Programming.2025.2},
annote = {Keywords: Java VM, Processing-in-Memory, Offloading, Data parallelism}
}
Document
Extended Abstract
A Pragmatic Approach to Replay Compilation (Extended Abstract)
Abstract
Dynamic compilers generate code based on the information provided by the virtual machine (VM) running the corresponding application. Due to the environment’s non-deterministic nature, every compilation result is typically unique. This is a problem when reproducibility is desired, such as when debugging a crash of the JIT compiler or diagnosing performance problems. As a solution, we present a pragmatic approach to replay compilation that is suitable for integration in a production-grade VM. Our approach is based on instrumenting the VM’s compiler interface, allowing us to record the compiler’s queries and their results to the VM. We serialize them and use them to replicate the compiler’s query results in a replayed compilation. Assuming the compiler is deterministic, this approach systematically ensures that the replayed compilation result is equivalent to the recorded one. The dynamic compiler is invoked directly without the need to execute the original application. A compiler developer can replay a compilation with additional diagnostic options or evaluate metrics such as compilation speed. We developed a working prototype for GraalVM, showing that replay compilation can be implemented without requiring extensive compiler or VM changes. We are working with the GraalVM developers to integrate it into the open-source compiler to unlock these benefits and new use cases for the community.
Cite as
Andrej Pečimúth, David Leopoldseder, and Petr Tůma. A Pragmatic Approach to Replay Compilation (Extended Abstract). In Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025). Open Access Series in Informatics (OASIcs), Volume 134, pp. 3:1-3:4, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2025)
Copy BibTex To Clipboard
@InProceedings{pecimuth_et_al:OASIcs.Programming.2025.3,
author = {Pe\v{c}im\'{u}th, Andrej and Leopoldseder, David and T\r{u}ma, Petr},
title = {{A Pragmatic Approach to Replay Compilation}},
booktitle = {Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025)},
pages = {3:1--3:4},
series = {Open Access Series in Informatics (OASIcs)},
ISBN = {978-3-95977-382-9},
ISSN = {2190-6807},
year = {2025},
volume = {134},
editor = {Edwards, Jonathan and Perera, Roly and Petricek, Tomas},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/OASIcs.Programming.2025.3},
URN = {urn:nbn:de:0030-drops-242874},
doi = {10.4230/OASIcs.Programming.2025.3},
annote = {Keywords: replay compilation, dynamic compilation, virtual machines}
}
Document
Extended Abstract
Debugging a Smalltalk VM Assisted by Large Automated Reasoning (Extended Abstract)
Abstract
We show how a full-scale automated-reasoning engine implemented in Smalltalk can be applied to assist in the programmer’s cognitive task of traversing abstraction levels. This approach follows naturally from our definition of debugging as any activity aimed towards understanding a program. We introduce the notion of "dimensions of abstraction", give two examples ("stratum" and "mode"), and show how it is applied in debugging a native compiler backend.
Cite as
Boris Shingarov and Jan Vraný. Debugging a Smalltalk VM Assisted by Large Automated Reasoning (Extended Abstract). In Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025). Open Access Series in Informatics (OASIcs), Volume 134, pp. 4:1-4:6, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2025)
Copy BibTex To Clipboard
@InProceedings{shingarov_et_al:OASIcs.Programming.2025.4,
author = {Shingarov, Boris and Vran\'{y}, Jan},
title = {{Debugging a Smalltalk VM Assisted by Large Automated Reasoning}},
booktitle = {Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025)},
pages = {4:1--4:6},
series = {Open Access Series in Informatics (OASIcs)},
ISBN = {978-3-95977-382-9},
ISSN = {2190-6807},
year = {2025},
volume = {134},
editor = {Edwards, Jonathan and Perera, Roly and Petricek, Tomas},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/OASIcs.Programming.2025.4},
URN = {urn:nbn:de:0030-drops-242881},
doi = {10.4230/OASIcs.Programming.2025.4},
annote = {Keywords: Smalltalk, Virtual Machine, Automated Reasoning, Debugging, ISA Specification}
}
Document
It’s OK to Want to Have a Good Time
Abstract
We reflect on our decade or so of experience advising students, corporate teams and policy makers, many of whom really just want to have a good time at work and want others to as well. However, they seem to be embarrassed to say so, they dress their work in the mantle of productivity, and mostly damage it in the process.
In this short opinion piece, we argue that it is long past time to say goodnight to Taylorism and ask what models of research aligned to something humane might replace it?
Cite as
Luke Church and Mariana Marasoiu. It’s OK to Want to Have a Good Time. In Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025). Open Access Series in Informatics (OASIcs), Volume 134, pp. 5:1-5:4, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2025)
Copy BibTex To Clipboard
@InProceedings{church_et_al:OASIcs.Programming.2025.5,
author = {Church, Luke and Marasoiu, Mariana},
title = {{It’s OK to Want to Have a Good Time}},
booktitle = {Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025)},
pages = {5:1--5:4},
series = {Open Access Series in Informatics (OASIcs)},
ISBN = {978-3-95977-382-9},
ISSN = {2190-6807},
year = {2025},
volume = {134},
editor = {Edwards, Jonathan and Perera, Roly and Petricek, Tomas},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/OASIcs.Programming.2025.5},
URN = {urn:nbn:de:0030-drops-242891},
doi = {10.4230/OASIcs.Programming.2025.5},
annote = {Keywords: productivity, happiness, Hegel}
}
Document
Exploration and Complexity Management in Graph-Based Programming Environments
Abstract
Programmers often rely on different environments depending on the nature of their tasks. For large-scale software projects, IDEs help manage complexity through structured abstractions like files, modules, and classes, and provide tools for code visualization and navigation. In contrast, exploratory programming tasks - such as data analysis, rapid prototyping, and design space exploration - are better served by interactive environments like REPLs and Notebooks, which support incremental development and immediate feedback. However, these tools tend to prioritize either complexity management or exploration, limiting their effectiveness across contexts.
This paper investigates a hybrid graph-based programming environment that bridges these two modes by building on Incremental Graph Code (IGC), a graph-based system for structuring, visualizing, and interacting with source code. We explore how IGC can support both complexity management and exploratory programming through three key features: projectional views for aggregating and navigating interrelated code and documentation, graph-type nodes for encapsulating subgraphs to manage structural complexity, and an exploratory programming view for managing branching executions and promoting experimentation. Together, these features suggest that graph-based environments like IGC can offer a unified platform for both systematic software engineering and dynamic, exploratory development.
Cite as
Max Boksem and L. Thomas van Binsbergen. Exploration and Complexity Management in Graph-Based Programming Environments. In Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025). Open Access Series in Informatics (OASIcs), Volume 134, pp. 6:1-6:18, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2025)
Copy BibTex To Clipboard
@InProceedings{boksem_et_al:OASIcs.Programming.2025.6,
author = {Boksem, Max and van Binsbergen, L. Thomas},
title = {{Exploration and Complexity Management in Graph-Based Programming Environments}},
booktitle = {Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025)},
pages = {6:1--6:18},
series = {Open Access Series in Informatics (OASIcs)},
ISBN = {978-3-95977-382-9},
ISSN = {2190-6807},
year = {2025},
volume = {134},
editor = {Edwards, Jonathan and Perera, Roly and Petricek, Tomas},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/OASIcs.Programming.2025.6},
URN = {urn:nbn:de:0030-drops-242906},
doi = {10.4230/OASIcs.Programming.2025.6},
annote = {Keywords: Graph-based Programming Environments, Exploratory Programming, Complexity Management, Incremental Graph Code (IGC), Projectional Views}
}
Document
In-Situ Visual Programming
Abstract
Most Visual Programming Environments (VPEs) available today aim to make software development more accessible for specific domains, such as automation, business intelligence, data science, education, or real-time media processing. In their niches, VPEs offer several advantages over traditional text-based programming, including shorter training times, immediate visual feedback, and lower barriers to entry. With this work, we introduce In-Situ Visual Programming (ISVP), a novel programming paradigm to enable users to create, modify, and contribute to software via visual programming in physical contexts. User-created and pre-built programs can be attached to and interlinked with physical objects - in an Augmented Reality (AR) environment. We believe that the spatial and contextual proximity of processing code and physical objects will make software development more intuitive, and we argue this position based on two model use cases.
Cite as
Ulrich Brandstätter and Bernhard Schenkenfelder. In-Situ Visual Programming. In Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025). Open Access Series in Informatics (OASIcs), Volume 134, pp. 7:1-7:11, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2025)
Copy BibTex To Clipboard
@InProceedings{brandstatter_et_al:OASIcs.Programming.2025.7,
author = {Brandst\"{a}tter, Ulrich and Schenkenfelder, Bernhard},
title = {{In-Situ Visual Programming}},
booktitle = {Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025)},
pages = {7:1--7:11},
series = {Open Access Series in Informatics (OASIcs)},
ISBN = {978-3-95977-382-9},
ISSN = {2190-6807},
year = {2025},
volume = {134},
editor = {Edwards, Jonathan and Perera, Roly and Petricek, Tomas},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/OASIcs.Programming.2025.7},
URN = {urn:nbn:de:0030-drops-242916},
doi = {10.4230/OASIcs.Programming.2025.7},
annote = {Keywords: Visual programming, End-user programming, Programming paradigm}
}
Document
Fuzzing as Editor Feedback
Abstract
Live programming requires concrete examples, but coming up with examples takes effort. However, there are ways to execute code without specifying examples, such as fuzzing. Fuzzing is a technique that synthesizes program inputs to find bugs in security-critical software.
While fuzzing focuses on finding crashes, it also produces valid inputs as a byproduct. Our approach is to make use of this to show examples, including edge cases, directly in the editor.
To provide examples for individual pieces of code, we implement fuzzing at the granularity of functions. We integrate it into the compiler pipeline and language tooling of Martinaise, a custom programming language with a limited feature set. Initially, our examples are random and then mutate based on coverage feedback to reach interesting code locations and become smaller.
We evaluate our tool in small case studies, showing generated examples for numbers, strings, and composite objects. Our fuzzed examples still feel synthetic, but since they are grounded in the dynamic behavior of code, they can cover the entire execution and show edge cases.
Cite as
Marcel Garus, Jens Lincke, and Robert Hirschfeld. Fuzzing as Editor Feedback. In Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025). Open Access Series in Informatics (OASIcs), Volume 134, pp. 8:1-8:15, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2025)
Copy BibTex To Clipboard
@InProceedings{garus_et_al:OASIcs.Programming.2025.8,
author = {Garus, Marcel and Lincke, Jens and Hirschfeld, Robert},
title = {{Fuzzing as Editor Feedback}},
booktitle = {Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025)},
pages = {8:1--8:15},
series = {Open Access Series in Informatics (OASIcs)},
ISBN = {978-3-95977-382-9},
ISSN = {2190-6807},
year = {2025},
volume = {134},
editor = {Edwards, Jonathan and Perera, Roly and Petricek, Tomas},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/OASIcs.Programming.2025.8},
URN = {urn:nbn:de:0030-drops-242926},
doi = {10.4230/OASIcs.Programming.2025.8},
annote = {Keywords: Fuzzing, Example-based Programming, Babylonian Programming, Dynamic Analysis, Code Coverage, Randomized Testing, Function-Level Fuzzing}
}
Document
COP Layer Encapsulating Non-Functional Requirements for Physical Systems on Hakoniwa Environment
Abstract
This paper contributes to solving two issues: (1) clearly defining Non-Functional Requirements (NFRs) and Functional Requirements (FRs), and (2) simulating on a practical IoT platform. Related to the first problem, we always feel annoyed with many irregular conditions and non-requirements for programming physical systems. Particularly, they sometimes cause cross-cutting concerns problems. Thus, we cannot concentrate on mainstream behavior. Regarding the second problem, the platform must deal with IoT problems. Modern physical systems are integrated with the Internet of Things (IoT), which connects multiple devices, sensors, and cloud services. As a result, these systems may face problems such as latency, race conditions, deadlocks, and more. To solve these problems, we propose a robot software development environment called CPy4NFR. For the first problem, we draw NFRs in feature models, and CPy4NFR generates layers of Context-Oriented Programming (COP). The programming language is called CPy, which is an extension of Python. Through this process, the relation between non-functional requirements and COP is clarified, and the cross-cutting concern problems are solved. Regarding the second problem, CPy programs with NFRs are executed on Hakoniwa. Hakoniwa deals with IoT problems, provides APIs for simulator environments such as Unity and Unreal Engine, and supports APIs for physical robot systems. In this paper, we apply CPy4NFR to develop a drone system with changing behavior at runtime. Finally, we discuss two problems and the proposed development environment.
Cite as
Yudai Yamada, Nobuhiko Ogura, Kenji Hisazumi, and Harumi Watanabe. COP Layer Encapsulating Non-Functional Requirements for Physical Systems on Hakoniwa Environment. In Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025). Open Access Series in Informatics (OASIcs), Volume 134, pp. 9:1-9:10, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2025)
Copy BibTex To Clipboard
@InProceedings{yamada_et_al:OASIcs.Programming.2025.9,
author = {Yamada, Yudai and Ogura, Nobuhiko and Hisazumi, Kenji and Watanabe, Harumi},
title = {{COP Layer Encapsulating Non-Functional Requirements for Physical Systems on Hakoniwa Environment}},
booktitle = {Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025)},
pages = {9:1--9:10},
series = {Open Access Series in Informatics (OASIcs)},
ISBN = {978-3-95977-382-9},
ISSN = {2190-6807},
year = {2025},
volume = {134},
editor = {Edwards, Jonathan and Perera, Roly and Petricek, Tomas},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/OASIcs.Programming.2025.9},
URN = {urn:nbn:de:0030-drops-242931},
doi = {10.4230/OASIcs.Programming.2025.9},
annote = {Keywords: Context-Oriented Programming, Non-Functional Requirement, Real-Time System}
}
Document
Shica - Improving the Programming Experience for Agent-Based, Distributed, Physical Computing Systems
Abstract
Agent-based and distributed computing systems play an important role in many fields. Programming these systems can be annoying because of the complexity of managing multiple asynchronous processes and state transitions, sometimes hidden inter-dependencies between program elements, and (often) unnecessarily terse, un-intuitive syntax.
In this paper we describe the design and implementation of Shica, an experimental language designed for physical computing that is fun to program. Shica unifies state-based, event-based, and distributed programming along with some elements of context-oriented.
We informally evaluate Shica’s characteristics including its suitability for deployment on resource-constrained, embedded devices and its contribution to improving the quality of the programming experience by maximizing scope, economy, and elegance of expression.
Cite as
Hiroto Shikada and Ian Piumarta. Shica - Improving the Programming Experience for Agent-Based, Distributed, Physical Computing Systems. In Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025). Open Access Series in Informatics (OASIcs), Volume 134, pp. 10:1-10:22, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2025)
Copy BibTex To Clipboard
@InProceedings{shikada_et_al:OASIcs.Programming.2025.10,
author = {Shikada, Hiroto and Piumarta, Ian},
title = {{Shica - Improving the Programming Experience for Agent-Based, Distributed, Physical Computing Systems}},
booktitle = {Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025)},
pages = {10:1--10:22},
series = {Open Access Series in Informatics (OASIcs)},
ISBN = {978-3-95977-382-9},
ISSN = {2190-6807},
year = {2025},
volume = {134},
editor = {Edwards, Jonathan and Perera, Roly and Petricek, Tomas},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/OASIcs.Programming.2025.10},
URN = {urn:nbn:de:0030-drops-242948},
doi = {10.4230/OASIcs.Programming.2025.10},
annote = {Keywords: Programming Languages, run-time Systems, agent-based Programming}
}
Document
Renkon-Pad: A Live and Self-Sustaining Programming Environment Based on Functional Reactive Programming
Abstract
Renkon-pad is a live programming environment based on a Functional Reactive Programming language called Renkon. In Renkon-pad, the user creates text boxes to write reactive expressions. The user can also create any number of "runner" windows (separate execution environments) to run the program. The user can modify the program and update a running runner or create a new one to experiment quickly.
The FRP-based model of the Renkon language is conducive to programming in node-and-wire dataflow diagrams. However, Renkon-pad does not employ a typical node-and-wire visual representation. The dependency relationships are expressed in code as text rather than by connecting boxes with wires. Additionally, a text box can contain any number of expressions. This design helps scale the size of a program that the user can handle in the environment. In other words, the programmer has greater flexibility in organizing their program in a logically meaningful way. The application analyzes the dependencies among expressions and visualizes the dependencies in the program to aid comprehension.
Renkon-pad is powerful enough to create and live-edit non-trivial applications, including itself. The bootstrapping version of Renkon-pad, with text box and runner window management, user interaction, interfacing with a virtual DOM library, the file save and load feature, and dependency visualization, is implemented in about 700 lines of Renkon and CSS definitions.
Cite as
Yoshiki Ohshima, Adam Bouhenguel, and Matthew Good. Renkon-Pad: A Live and Self-Sustaining Programming Environment Based on Functional Reactive Programming. In Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025). Open Access Series in Informatics (OASIcs), Volume 134, pp. 11:1-11:20, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2025)
Copy BibTex To Clipboard
@InProceedings{ohshima_et_al:OASIcs.Programming.2025.11,
author = {Ohshima, Yoshiki and Bouhenguel, Adam and Good, Matthew},
title = {{Renkon-Pad: A Live and Self-Sustaining Programming Environment Based on Functional Reactive Programming}},
booktitle = {Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025)},
pages = {11:1--11:20},
series = {Open Access Series in Informatics (OASIcs)},
ISBN = {978-3-95977-382-9},
ISSN = {2190-6807},
year = {2025},
volume = {134},
editor = {Edwards, Jonathan and Perera, Roly and Petricek, Tomas},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/OASIcs.Programming.2025.11},
URN = {urn:nbn:de:0030-drops-242956},
doi = {10.4230/OASIcs.Programming.2025.11},
annote = {Keywords: Live Programming, Functional Reactive Programming, Live Development Environment}
}
Document
Im-C - A Memory-Safe C Interpreter Providing a Better Learning, Testing, and Debugging Experience
Abstract
While it is a highly flexible and efficient language, C programming can be annoying for beginners who have difficultly finding, debugging, or understanding errors - especially those related to memory manipulation. This paper describes an initial phase of Im-C, a project whose goal is to develop a number of related environments that progress from easy-to-understand "C-with-objects" to a safe environment for both testing and learning to write "real" C programs, bringing more fun to the programming experience. In the current phase an experimental C interpreter has been developed to provide a foundation for real-time validation of C program behavior. The interpreter identifies errors related to memory manipulation, pointer operations and array access, by storing all values as objects containing meta-data, while preserving the semantics expected by C programmers. We validate the effectiveness of our interpreter by comparing its ability to detect a range of both common and obscure errors against the two most popular and mature tools currently available.
Cite as
Masaki Kunii and Ian Piumarta. Im-C - A Memory-Safe C Interpreter Providing a Better Learning, Testing, and Debugging Experience. In Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025). Open Access Series in Informatics (OASIcs), Volume 134, pp. 12:1-12:18, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2025)
Copy BibTex To Clipboard
@InProceedings{kunii_et_al:OASIcs.Programming.2025.12,
author = {Kunii, Masaki and Piumarta, Ian},
title = {{Im-C - A Memory-Safe C Interpreter Providing a Better Learning, Testing, and Debugging Experience}},
booktitle = {Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025)},
pages = {12:1--12:18},
series = {Open Access Series in Informatics (OASIcs)},
ISBN = {978-3-95977-382-9},
ISSN = {2190-6807},
year = {2025},
volume = {134},
editor = {Edwards, Jonathan and Perera, Roly and Petricek, Tomas},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/OASIcs.Programming.2025.12},
URN = {urn:nbn:de:0030-drops-242968},
doi = {10.4230/OASIcs.Programming.2025.12},
annote = {Keywords: C programming Language, debugging Tools, memory Safety}
}
Document
Dimensions of Examples: Toward a Framework for Qualifying Examples in Programming
Abstract
Programming requires understanding, using, and changing abstract source code and other representations of programs. Concrete examples demonstrate a particular instance of their abstract behavior. Hence, they play an important role in program comprehension, specification, and testing of requirements. Authoring examples entails a range of - often implicit - decisions about the content and presentation of the example. In this work, we attempt to structure this decision space by describing a set of dimensions that characterize examples in programming. As the manual effort of creating examples is increasingly automated, e.g., through the use of generative AI, we expect this catalog of dimensions to help users and tool developers parametrize, guide, and evaluate the generation of examples in terms of the vocabulary we present here.
Cite as
Toni Mattis, Lukas Böhme, Stefan Ramson, Tom Beckmann, Martin C. Rinard, and Robert Hirschfeld. Dimensions of Examples: Toward a Framework for Qualifying Examples in Programming. In Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025). Open Access Series in Informatics (OASIcs), Volume 134, pp. 13:1-13:11, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2025)
Copy BibTex To Clipboard
@InProceedings{mattis_et_al:OASIcs.Programming.2025.13,
author = {Mattis, Toni and B\"{o}hme, Lukas and Ramson, Stefan and Beckmann, Tom and Rinard, Martin C. and Hirschfeld, Robert},
title = {{Dimensions of Examples: Toward a Framework for Qualifying Examples in Programming}},
booktitle = {Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025)},
pages = {13:1--13:11},
series = {Open Access Series in Informatics (OASIcs)},
ISBN = {978-3-95977-382-9},
ISSN = {2190-6807},
year = {2025},
volume = {134},
editor = {Edwards, Jonathan and Perera, Roly and Petricek, Tomas},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/OASIcs.Programming.2025.13},
URN = {urn:nbn:de:0030-drops-242973},
doi = {10.4230/OASIcs.Programming.2025.13},
annote = {Keywords: Examples, Live Programming, Evaluation}
}
Document
PShapeTrace: Linking Drawing Instructions with Visual Outcomes in Processing
Abstract
Processing is a Java-based programming language designed to facilitate learning programming through visual arts and creative coding. However, beginners must simultaneously learn both the programming language itself and image-processing concepts such as coordinate systems, making it challenging to understand the correspondence between drawing instructions and their visual outcomes. To help beginners analyze the drawing process in their code, this study proposes a tool named PShapeTrace that observes the execution of Processing programs and visualizes the relationship between drawing instructions and their results. A user study was conducted to evaluate the tool. Participants reported that the tool was useful for completing programming tasks. The resulting System Usability Scale (SUS) score was 72.75, indicating acceptable usability.
Cite as
Takashi Ishio and Yuta Yamasaki. PShapeTrace: Linking Drawing Instructions with Visual Outcomes in Processing. In Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025). Open Access Series in Informatics (OASIcs), Volume 134, pp. 14:1-14:12, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2025)
Copy BibTex To Clipboard
@InProceedings{ishio_et_al:OASIcs.Programming.2025.14,
author = {Ishio, Takashi and Yamasaki, Yuta},
title = {{PShapeTrace: Linking Drawing Instructions with Visual Outcomes in Processing}},
booktitle = {Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025)},
pages = {14:1--14:12},
series = {Open Access Series in Informatics (OASIcs)},
ISBN = {978-3-95977-382-9},
ISSN = {2190-6807},
year = {2025},
volume = {134},
editor = {Edwards, Jonathan and Perera, Roly and Petricek, Tomas},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/OASIcs.Programming.2025.14},
URN = {urn:nbn:de:0030-drops-242982},
doi = {10.4230/OASIcs.Programming.2025.14},
annote = {Keywords: Traceability, dynamic analysis, graphical user interface}
}
Document
Encouraging Experimentation Through Programming by Proximity
Abstract
Exploratory programming involves evaluating a variety of approaches to identify those that advance the problem understanding. For this purpose, we investigated a notation for code designed to encourage experimentation with elements of a program. In our proof-of-concept, we evaluate the idea of program elements connecting by mere proximity through small case studies. We identify multiple constraints to enable connection through proximity and its limitations.
Cite as
Tom Beckmann, Leonard Geier, Stefan Ramson, Marcel Taeumel, and Robert Hirschfeld. Encouraging Experimentation Through Programming by Proximity. In Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025). Open Access Series in Informatics (OASIcs), Volume 134, pp. 15:1-15:15, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2025)
Copy BibTex To Clipboard
@InProceedings{beckmann_et_al:OASIcs.Programming.2025.15,
author = {Beckmann, Tom and Geier, Leonard and Ramson, Stefan and Taeumel, Marcel and Hirschfeld, Robert},
title = {{Encouraging Experimentation Through Programming by Proximity}},
booktitle = {Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025)},
pages = {15:1--15:15},
series = {Open Access Series in Informatics (OASIcs)},
ISBN = {978-3-95977-382-9},
ISSN = {2190-6807},
year = {2025},
volume = {134},
editor = {Edwards, Jonathan and Perera, Roly and Petricek, Tomas},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/OASIcs.Programming.2025.15},
URN = {urn:nbn:de:0030-drops-242991},
doi = {10.4230/OASIcs.Programming.2025.15},
annote = {Keywords: Visual Programming, Proximity, Experimentation Support}
}
Document
Exploring a Quantum Programming Language with Concurrency
Abstract
In quantum programming, as in the classical case, concurrent control is a form of program coordination that proves well suited to express complex composition patterns. This paper introduces a quantum programming language with explicit parallel and synchronization primitives and its semantics. The language is explored through a Maude implementation, and illustrated with two non trivial examples.
Cite as
Manisha Jain, Vitor Fernandes, Alexandre Madeira, and Luís S. Barbosa. Exploring a Quantum Programming Language with Concurrency. In Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025). Open Access Series in Informatics (OASIcs), Volume 134, pp. 16:1-16:9, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2025)
Copy BibTex To Clipboard
@InProceedings{jain_et_al:OASIcs.Programming.2025.16,
author = {Jain, Manisha and Fernandes, Vitor and Madeira, Alexandre and Barbosa, Lu{\'\i}s S.},
title = {{Exploring a Quantum Programming Language with Concurrency}},
booktitle = {Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025)},
pages = {16:1--16:9},
series = {Open Access Series in Informatics (OASIcs)},
ISBN = {978-3-95977-382-9},
ISSN = {2190-6807},
year = {2025},
volume = {134},
editor = {Edwards, Jonathan and Perera, Roly and Petricek, Tomas},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/OASIcs.Programming.2025.16},
URN = {urn:nbn:de:0030-drops-243001},
doi = {10.4230/OASIcs.Programming.2025.16},
annote = {Keywords: Quantum programming, semantics prototyping, Maude}
}
Document
Locus: A Proposal for Quantum Software Composition
Abstract
The way quantum programs based on circuits are built today has many analogies with how assembler routines were developed in the past. This way of writing programs is not only tedious but also makes it difficult to achieve good quality attributes such as reusability or maintainability. One of the main advances in improving the quality of classical software, as well as increasing programmers' productivity, was raising the level of abstraction in programming languages. This allowed developers to move away from direct bit-level operations - such as rotation, shifting, addition, or carry handling - toward working with a set of basic data types like Integer, Float, or Character, along with well-defined operations on them. We believe that introducing similar mechanisms in the field of Quantum Programming will help to achieve comparable benefits in quantum software. This paper presents the authors' preliminary efforts in this direction, introducing the concept of locus.
Cite as
Javier Zayas Gallardo, Francisco Chicano, Carlos Canal, and Juan Manuel Murillo. Locus: A Proposal for Quantum Software Composition. In Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025). Open Access Series in Informatics (OASIcs), Volume 134, pp. 17:1-17:10, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2025)
Copy BibTex To Clipboard
@InProceedings{zayasgallardo_et_al:OASIcs.Programming.2025.17,
author = {Zayas Gallardo, Javier and Chicano, Francisco and Canal, Carlos and Murillo, Juan Manuel},
title = {{Locus: A Proposal for Quantum Software Composition}},
booktitle = {Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025)},
pages = {17:1--17:10},
series = {Open Access Series in Informatics (OASIcs)},
ISBN = {978-3-95977-382-9},
ISSN = {2190-6807},
year = {2025},
volume = {134},
editor = {Edwards, Jonathan and Perera, Roly and Petricek, Tomas},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/OASIcs.Programming.2025.17},
URN = {urn:nbn:de:0030-drops-243018},
doi = {10.4230/OASIcs.Programming.2025.17},
annote = {Keywords: Locus, Quantum programming, Quantum circuits}
}
Document
Quantum Table: A Tangible Quantum Circuit Demonstrator
Abstract
Quantum computing has considerable potential, but its abstract nature often intimidates beginners, and existing quantum circuit simulator interfaces can be overwhelming for them. To address this accessibility issue, we have developed an intuitive simulator that integrates the principles of a tangible, collaborative tabletop workbench with quantum circuits. This simulator allows users to manipulate circuits through physical interaction, providing real-time visual feedback. The use of tangible user interfaces (TUIs) in complex systems has been shown to improve the user experience by allowing users to control and represent data flows through physical objects. Inspired by the tangible workbench’s use of dynamic visual cues, our system employs similar techniques to help users understand quantum operations through direct manipulation and visual representation. The integration of tangible interaction with quantum circuit simulation is a novel approach to making quantum computing more accessible and engaging.
Cite as
Stefan Hillmich, Raphael Zefferer, Mathias Gartner, Bernhard Schenkenfelder, Sonja Bruckner, and Ulrich Brandstätter. Quantum Table: A Tangible Quantum Circuit Demonstrator. In Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025). Open Access Series in Informatics (OASIcs), Volume 134, pp. 18:1-18:3, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2025)
Copy BibTex To Clipboard
@InProceedings{hillmich_et_al:OASIcs.Programming.2025.18,
author = {Hillmich, Stefan and Zefferer, Raphael and Gartner, Mathias and Schenkenfelder, Bernhard and Bruckner, Sonja and Brandst\"{a}tter, Ulrich},
title = {{Quantum Table: A Tangible Quantum Circuit Demonstrator}},
booktitle = {Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025)},
pages = {18:1--18:3},
series = {Open Access Series in Informatics (OASIcs)},
ISBN = {978-3-95977-382-9},
ISSN = {2190-6807},
year = {2025},
volume = {134},
editor = {Edwards, Jonathan and Perera, Roly and Petricek, Tomas},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/OASIcs.Programming.2025.18},
URN = {urn:nbn:de:0030-drops-243020},
doi = {10.4230/OASIcs.Programming.2025.18},
annote = {Keywords: quantum computing, quantum circuit simulation, education}
}
Document
Is There Hypothesis for Attribute Grammars?
Abstract
Software testing is essential to ensure software reliability and functionality. Numerous testing techniques have been proposed, and most programming languages provide built-in support for testing. However, these techniques have yet to be integrated into the powerful attribute grammar formalism.
This paper introduces a method to incorporate property-based testing into attribute grammars. We achieve this by embedding attribute grammars in Python which is combined with its powerful Hypothesis property-based testing framework. To validate our approach, we express properties of scope rules in a (nested) block-structured language, commonly found in many (functional) languages.
Cite as
Emanuel Rodrigues, José Nuno Macedo, and João Saraiva. Is There Hypothesis for Attribute Grammars?. In Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025). Open Access Series in Informatics (OASIcs), Volume 134, pp. 19:1-19:15, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2025)
Copy BibTex To Clipboard
@InProceedings{rodrigues_et_al:OASIcs.Programming.2025.19,
author = {Rodrigues, Emanuel and Macedo, Jos\'{e} Nuno and Saraiva, Jo\~{a}o},
title = {{Is There Hypothesis for Attribute Grammars?}},
booktitle = {Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025)},
pages = {19:1--19:15},
series = {Open Access Series in Informatics (OASIcs)},
ISBN = {978-3-95977-382-9},
ISSN = {2190-6807},
year = {2025},
volume = {134},
editor = {Edwards, Jonathan and Perera, Roly and Petricek, Tomas},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/OASIcs.Programming.2025.19},
URN = {urn:nbn:de:0030-drops-243036},
doi = {10.4230/OASIcs.Programming.2025.19},
annote = {Keywords: Property-based Testing, Attribute Grammars, Strategic Term Rewriting}
}
Document
On the Effectiveness of Interpreter-Guided Compiler Testing
Abstract
Guaranteeing that a compiler behaves correctly is a complex task often approached through test generation and fuzzing. Compiler test generation must not only ensure that a compiler generates code that does not break, but also that it implements the programming language semantics. Recently, interpreter-guided test generation has been proposed to test JIT compilers: Concolic-execution on the interpreter yields test cases for the language semantics which are then validated between differential testing of the interpreter and compiler. In previous work, this solution has been shown to find interpreter/compiler differences. However, little has been said about the effectiveness and the solution limits.
In this paper we study the behavior of this technique, to shed light on future improvements and research. We experiment with this technique on the JIT compiler for the Pharo programming language, on two different backends: ARMv7 and x86. We explore how effective the solution is in terms of compiler coverage and its limitations, and we discuss how future research can overcome them. Moreover, we investigate how this technique combined with random constraint mutations increases backend compiler coverage.
Cite as
Federico Lochbaum and Guillermo Polito. On the Effectiveness of Interpreter-Guided Compiler Testing. In Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025). Open Access Series in Informatics (OASIcs), Volume 134, pp. 20:1-20:15, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2025)
Copy BibTex To Clipboard
@InProceedings{lochbaum_et_al:OASIcs.Programming.2025.20,
author = {Lochbaum, Federico and Polito, Guillermo},
title = {{On the Effectiveness of Interpreter-Guided Compiler Testing}},
booktitle = {Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025)},
pages = {20:1--20:15},
series = {Open Access Series in Informatics (OASIcs)},
ISBN = {978-3-95977-382-9},
ISSN = {2190-6807},
year = {2025},
volume = {134},
editor = {Edwards, Jonathan and Perera, Roly and Petricek, Tomas},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/OASIcs.Programming.2025.20},
URN = {urn:nbn:de:0030-drops-243040},
doi = {10.4230/OASIcs.Programming.2025.20},
annote = {Keywords: Virtual Machines, Concolic Testing, JIT compilers, interpreters, Differential Testing, Constraint Mutations, Compiler Coverage}
}
Document
A Comparison of Three Program Query Languages to Detect Python Programming Misconceptions
Abstract
Detecting and addressing common misconceptions in beginner programmers' code is key to improve their learning experience. This paper evaluates the effectiveness of three static program query languages and tools: Flake8, Regex and CodeQL, for identifying such misconceptions in Python code. We implemented a set of 20 common misconceptions using each language and compared them on a variety of criteria, including accuracy, performance, expressiveness, learning curve and query readability. Our analysis highlights strengths and limitations of each approach, providing insights into the most effective method for detecting programming misconceptions and enhancing feedback quality for learners.
Cite as
Quentin Colla, Kim Mens, and Julien Liénard. A Comparison of Three Program Query Languages to Detect Python Programming Misconceptions. In Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025). Open Access Series in Informatics (OASIcs), Volume 134, pp. 21:1-21:15, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2025)
Copy BibTex To Clipboard
@InProceedings{colla_et_al:OASIcs.Programming.2025.21,
author = {Colla, Quentin and Mens, Kim and Li\'{e}nard, Julien},
title = {{A Comparison of Three Program Query Languages to Detect Python Programming Misconceptions}},
booktitle = {Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025)},
pages = {21:1--21:15},
series = {Open Access Series in Informatics (OASIcs)},
ISBN = {978-3-95977-382-9},
ISSN = {2190-6807},
year = {2025},
volume = {134},
editor = {Edwards, Jonathan and Perera, Roly and Petricek, Tomas},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/OASIcs.Programming.2025.21},
URN = {urn:nbn:de:0030-drops-243052},
doi = {10.4230/OASIcs.Programming.2025.21},
annote = {Keywords: Static Program Analysis, Program Query Language, Python Programming, Programming Misconceptions}
}
Document
Identifying Security Issues in Elixir Web Applications
Abstract
The security of software products is extremely important in the era of internet-based applications. Building secure web applications is not straightforward. Several guidelines and tools were developed to support this process. The biggest challenge for those tools is to not overwhelm the developers with false-positive hits. This paper aims to investigate the use of static analysis for accurate vulnerability identification in the case of Elixir web applications.
Cite as
Smiljana Knežev, István Bozó, and Melinda Tóth. Identifying Security Issues in Elixir Web Applications. In Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025). Open Access Series in Informatics (OASIcs), Volume 134, pp. 22:1-22:15, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2025)
Copy BibTex To Clipboard
@InProceedings{knezev_et_al:OASIcs.Programming.2025.22,
author = {Kne\v{z}ev, Smiljana and Boz\'{o}, Istv\'{a}n and T\'{o}th, Melinda},
title = {{Identifying Security Issues in Elixir Web Applications}},
booktitle = {Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025)},
pages = {22:1--22:15},
series = {Open Access Series in Informatics (OASIcs)},
ISBN = {978-3-95977-382-9},
ISSN = {2190-6807},
year = {2025},
volume = {134},
editor = {Edwards, Jonathan and Perera, Roly and Petricek, Tomas},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/OASIcs.Programming.2025.22},
URN = {urn:nbn:de:0030-drops-243068},
doi = {10.4230/OASIcs.Programming.2025.22},
annote = {Keywords: Static analysis, Elixir, security vulnerabilities, XSS}
}
Document
The Pyttern Program Query Language
Abstract
Despite the availability of numerous tools and languages for detecting structural patterns in programs, their complexity often presents a steep learning curve. This highlights the need for a program query language that is easier to learn, use, and read while remaining sufficiently expressive for defining and detecting relevant structural coding patterns in program code. To address this challenge, we present Pyttern, a query language that extends Python syntax with regular-expression-inspired wildcards, enabling intuitive pattern-based querying of Python code. Its implementation relies upon a custom pushdown automaton describing how to match patterns over program parse trees, thus providing a robust foundation for structural code analysis. We evaluate Pyttern’s usability and effectiveness through a study involving 35 master’s students, who were asked to write seven different patterns to identify known programming misconceptions. The results demonstrate that Pyttern is both easy to learn and practical to use, at least for analysing small-scale programs.
Cite as
Julien Liénard, Kim Mens, and Siegfried Nijssen. The Pyttern Program Query Language. In Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025). Open Access Series in Informatics (OASIcs), Volume 134, pp. 23:1-23:15, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2025)
Copy BibTex To Clipboard
@InProceedings{lienard_et_al:OASIcs.Programming.2025.23,
author = {Li\'{e}nard, Julien and Mens, Kim and Nijssen, Siegfried},
title = {{The Pyttern Program Query Language}},
booktitle = {Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025)},
pages = {23:1--23:15},
series = {Open Access Series in Informatics (OASIcs)},
ISBN = {978-3-95977-382-9},
ISSN = {2190-6807},
year = {2025},
volume = {134},
editor = {Edwards, Jonathan and Perera, Roly and Petricek, Tomas},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/OASIcs.Programming.2025.23},
URN = {urn:nbn:de:0030-drops-243075},
doi = {10.4230/OASIcs.Programming.2025.23},
annote = {Keywords: Pyttern, Program Query Languages, Python, Pattern Matching, Parse Tree, Pushdown Automaton, Static Code Analysis, Wildcards, Tree Pattern Matching}
}
Document
Extended Abstract
Toward a Typed Intermediate Language for R (Extended Abstract)
Abstract
Compilers for dynamic languages often rely on intermediate representations with explicit type annotations to facilitate writing program transformations. This paper documents the design of a new typed intermediate representation for a just-in-time compiler for the R programming language called FIŘ. Type annotations, in FIŘ, capture properties such as sharing, the potential for effects, and compiler speculations. In this extended abstract, we focus on the sharing properties that may be used to optimize away some copies of values.
Cite as
Mickaël Laurent, Jakob Hain, Filip Krikava, Sebastián Krynski, and Jan Vitek. Toward a Typed Intermediate Language for R (Extended Abstract). In Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025). Open Access Series in Informatics (OASIcs), Volume 134, pp. 24:1-24:4, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2025)
Copy BibTex To Clipboard
@InProceedings{laurent_et_al:OASIcs.Programming.2025.24,
author = {Laurent, Micka\"{e}l and Hain, Jakob and Krikava, Filip and Krynski, Sebasti\'{a}n and Vitek, Jan},
title = {{Toward a Typed Intermediate Language for R}},
booktitle = {Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025)},
pages = {24:1--24:4},
series = {Open Access Series in Informatics (OASIcs)},
ISBN = {978-3-95977-382-9},
ISSN = {2190-6807},
year = {2025},
volume = {134},
editor = {Edwards, Jonathan and Perera, Roly and Petricek, Tomas},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/OASIcs.Programming.2025.24},
URN = {urn:nbn:de:0030-drops-243086},
doi = {10.4230/OASIcs.Programming.2025.24},
annote = {Keywords: JIT, compilation, static typing, ownership, copy-on-write, dynamic language}
}
Document
Who Owns the Contents of a Doubly-Linked List?
Abstract
Despite their popularity, systems enforcing full ownership guarantees such as Rust leave many users frustrated with the inability to represent notionally self-referential data structures - e.g., doubly-linked lists - using first-class references. This frustration has motivated a number of proposals to relax on full ownership to support idioms common in languages with pervasive reference semantics. In this paper, we take a look at the way value-oriented languages address this issue and study representations of arbitrary graph-like data structures without references.
Cite as
Dimi Racordon. Who Owns the Contents of a Doubly-Linked List?. In Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025). Open Access Series in Informatics (OASIcs), Volume 134, pp. 25:1-25:10, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2025)
Copy BibTex To Clipboard
@InProceedings{racordon:OASIcs.Programming.2025.25,
author = {Racordon, Dimi},
title = {{Who Owns the Contents of a Doubly-Linked List?}},
booktitle = {Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025)},
pages = {25:1--25:10},
series = {Open Access Series in Informatics (OASIcs)},
ISBN = {978-3-95977-382-9},
ISSN = {2190-6807},
year = {2025},
volume = {134},
editor = {Edwards, Jonathan and Perera, Roly and Petricek, Tomas},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/OASIcs.Programming.2025.25},
URN = {urn:nbn:de:0030-drops-243092},
doi = {10.4230/OASIcs.Programming.2025.25},
annote = {Keywords: self-referential data structures, ownership, mutable value semantics, performance}
}
Document
Extended Abstract
Mutable Value Semantics Through a Runtime-Enforced Framework in Scala (Extended Abstract)
Abstract
This work presents a minimal, runtime-based, framework for enforcing mutable value semantics in Scala. Unlike languages with MVS foundations, Scala lacks support for ownership and borrowing, often leading to aliasing issues and unintended mutations. This library addresses these challenges by defining a single abstraction that enforces MVS semantics entirely at runtime via precise assertions. We showcase the framework’s guarantees with a practical example, a mutable linked list.
Cite as
Hamza Remmal. Mutable Value Semantics Through a Runtime-Enforced Framework in Scala (Extended Abstract). In Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025). Open Access Series in Informatics (OASIcs), Volume 134, pp. 26:1-26:3, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2025)
Copy BibTex To Clipboard
@InProceedings{remmal:OASIcs.Programming.2025.26,
author = {Remmal, Hamza},
title = {{Mutable Value Semantics Through a Runtime-Enforced Framework in Scala}},
booktitle = {Companion Proceedings of the 9th International Conference on the Art, Science, and Engineering of Programming (Programming 2025)},
pages = {26:1--26:3},
series = {Open Access Series in Informatics (OASIcs)},
ISBN = {978-3-95977-382-9},
ISSN = {2190-6807},
year = {2025},
volume = {134},
editor = {Edwards, Jonathan and Perera, Roly and Petricek, Tomas},
publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
address = {Dagstuhl, Germany},
URL = {https://drops.dagstuhl.de/entities/document/10.4230/OASIcs.Programming.2025.26},
URN = {urn:nbn:de:0030-drops-243105},
doi = {10.4230/OASIcs.Programming.2025.26},
annote = {Keywords: Mutable Value Semantics, Value Independence, Runtime Verification}
}