‹Programming› Companion '26: "Literate Exploratory Programming ..."
Literate Exploratory Programming for Asynchronous Collaboration
Christoph Thiede, Tom Beckmann, Marcel Taeumel, and Robert Hirschfeld
(Hasso Plattner Institute - University of Potsdam, Germany)
A programmer can effectively explore systems by pursuing different approaches, conducting many experiments, and interacting with artifacts of the (runtime) environment. However, multiple programmers working together on the same exploration goal face challenges when communicating asynchronously, as they have to reproduce and explain relevant experiments and artifacts from their exploration to share them with coworkers. We propose literate exploratory programming as a novel workflow that combines exploration and explanation activities and reduces communication overheads through a tracking mechanism for extracting artifacts from the exploratory session. Inspired by traditional literate programming, in which implementation and contextualization are tightly interwoven, our approach introduces exploratory journals: a programmer can share artifacts such as code, runtime objects, and active debugging sessions together with prose, and another programmer can later resume the exploration from there. We demonstrate the feasibility of our approach by implementing a prototype in Squeak/Smalltalk and applying it for a design discussion in an open-source community. Our work indicates that tool support can foster effective collaboration in asynchronous exploratory programming contexts.
Article Search
Video
Article: prog26px-id8-p
‹Programming› Companion '26: "Towards Least-Privilege WebAssembly ..."
Towards Least-Privilege WebAssembly Applications: Transparent Interposition for WebAssembly Components
Olav Blaak and Tom Van Cutsem
(DistriNet at KU Leuven, Belgium)
When a WebAssembly component is compromised, current security models cannot always prevent it from abusing the full set of capabilities granted at initialization. With the component model encouraging reuse of third-party components distributed via OCI registries, this creates supply chain risks similar to those that have plagued npm. Additionally, the WebAssembly System Interface (WASI) requires some capabilities to be granted statically and often allows components to discover these capabilities at run time through ambient authority, with no native support for dynamic revocation. This violates the principle of least authority and exacerbates the risk of software supply chain attacks. We present a transparent, language-agnostic, and runtime-agnostic prototype framework for interposing arbitrary logic at WebAssembly component boundaries. Our approach automatically wraps components while preserving their interfaces, enabling arbitrary logic insertion without modifying guest components or runtimes. Using the framework, we draw inspiration from previous work on higher-order contracts and propose an embedded DSL for specifying arbitrary logic in which we define fine-grained security policies that dynamically restrict capabilities. Our approach enables compositional reasoning about security and allows better enforcement of the principle of least authority for component-based WebAssembly programs.
Article Search
Article: prog26morevms-id3-p
‹Programming› Companion '26: "Towards Transferring Text ..."
Towards Transferring Text Comprehension Techniques to Program Comprehension
Teresa Dreyer, Joel Michel, and Christoph Bockisch
(University of Marburg, Germany)
The potential positive effect of text highlighting on comprehension and retention has been shown by psychological studies. As program code is a special case of text, in this concept paper we propose to investigate whether code comprehension can also benefit from highlighting in a similar way. To elicit requirements for a corresponding tool, we have studied the related literature from cognitive and educational psychology including studies concerned with highlighting on paper and in digital texts as well as literature on related software development tools. We propose Highlighter, a plugin for IntelliJ IDEA that fulfills these requirements and allows highlighting arbitrary sections of code in flexible styles inspired by on-paper highlighting as well as editing and browsing the highlights inspired by digital text highlighting tools. A field test including six users indicates that our plugin fulfills the requirements, is unobtrusive and seamlessly integrates with other operations in IDEs. The initial results are promising and a larger user study is now well prepared.
Article Search
Article: prog26px-id1-p
‹Programming› Companion '26: "Liveness in the Age of Agents: ..."
Liveness in the Age of Agents: Are We Back to Compile-and-Run Cycles?
Toni Mattis, Marcel Taeumel, Lukas Böhme, and Robert Hirschfeld
(Hasso Plattner Institute - University of Potsdam, Germany)
An experienced programmer who works happily motivated within a live programming environment can yield high-quality software within reasonable time. A novice can also perform well because live programming tools foster short feedback loops, which help translate thoughts into executable program code and thus the desired observable system behavior. In the age of agents, now, one might think that actual programming skills take a step back to let visions shine: express your goal in natural language and let the agents make even larger, coherent edits to the system.
However, agents will take their time to think, and programmers require skills to make informed decisions about an agent's generated results. How "live" is that? How "short" does this feedback loop feel?
In this paper, we take a look at Tanimoto's liveness levels 5 and 6 in combination with Norman's interaction "gulfs" to discuss the impact agents have on the overall programming experience. We realize that the agent support is far from predictive as prompts take noticeable effort to clarify (or derive) a programmer's current goals. We also conclude that while the interaction cycles might feel quite productive at times, the experienced "Gulf of Evaluation" can be too much for novices if the results are too sophisticated.
For the (near) future, we believe that the programming experience around agents can further be tailored to improve both prompting and reviewing so that this very promising technology does not take us back to the times where lengthy compile-and-run cycles disrupted our thoughts, flow, and motivation.
Article Search
Article: prog26px-id12-p
‹Programming› Companion '26: "The Promise of Static Profiling: ..."
The Promise of Static Profiling: Exploring the Limits
Milan Cugurovic, Aleksandar Prokopec, Boris Spasojevic, Vojin Jovanovic, and Milena Vujošević Janičić
(Oracle, Serbia; University of Belgrade, Serbia; Oracle, Switzerland)
Recent advances in machine learning have significantly enhanced the capabilities of static profilers, enabling them to capture complex program behaviors beyond traditional hand-crafted heuristics. While static profilers offer advantages such as easy integration and high resource efficiency compared with dynamic profilers, their accuracy remains limited because they rely on static program features and lack runtime information. Static profilers produce lower-quality profiles that lead to less optimized programs. However, the field still lacks a detailed breakdown across profile types and a systematic estimate of the potential of static profilers.
This paper provides the first comprehensive evaluation of the potential and practical upper bounds of static profiling techniques across a diverse range of program profiles, including branch execution probabilities, method call counts, profiles of virtual calls, and combinations of these profiles. We propose an idealized framework for static profiling and identify new avenues that extend beyond conventional branch prediction. Our results clarify the inherent trade-offs between static and dynamic approaches and reveal opportunities to expand the role of static profiling within modern optimizing compilers.
Article Search
Article: prog26morevms-id1-p
‹Programming› Companion '26: "Towards Transferring Text ..."
Towards Transferring Text Comprehension Techniques to Program Comprehension
Teresa Dreyer, Joel Michel, and Christoph Bockisch
(University of Marburg, Germany)
The potential positive effect of text highlighting on comprehension and retention has been shown by psychological studies. As program code is a special case of text, in this concept paper we propose to investigate whether code comprehension can also benefit from highlighting in a similar way. To elicit requirements for a corresponding tool, we have studied the related literature from cognitive and educational psychology including studies concerned with highlighting on paper and in digital texts as well as literature on related software development tools. We propose Highlighter, a plugin for IntelliJ IDEA that fulfills these requirements and allows highlighting arbitrary sections of code in flexible styles inspired by on-paper highlighting as well as editing and browsing the highlights inspired by digital text highlighting tools. A field test including six users indicates that our plugin fulfills the requirements, is unobtrusive and seamlessly integrates with other operations in IDEs. The initial results are promising and a larger user study is now well prepared.
Article Search
Article: prog26px-id1-p
‹Programming› Companion '26: "PhysiCode Builder: A Framework ..."
PhysiCode Builder: A Framework for Rapid Prototyping of Tangible Programming Toolkits
Hina Hiratsuka and Kenji Hisazumi
(Shibaura Institute of Technology, Japan)
Tangible programming---where learners physically manipulate blocks to construct programs---provides intuitive, hands-on programming experiences for novice learners. However, existing materials are fixed to specific language specifications, making it difficult for educators to customize them according to their learning objectives. This paper proposes PhysiCode Builder, a framework for automatically generating customizable tangible programming materials. Our approach applies module-based language construction to the domain of tangible materials through a clear separation of roles: Configuration Developers define language specifications (requiring basic technical knowledge), while Material Creators---typically classroom educators---select from predefined configurations to generate materials without programming or 3D modeling expertise. The framework employs a feature model derived from analyzing existing tangible user interface (TUI) materials and separates abstract syntax (programming concepts) from concrete syntax (physical block representations) through a paradigm-agnostic metamodel design. In the proposed workflow, Material Creators would select desired feature modules through a configuration interface, and the core synthesis engine generates corresponding 3D printable block models and camera-based recognition software using TopCodes. A technical walkthrough demonstrates that material generation, previously requiring weeks of expert collaboration, can potentially be completed in minutes once appropriate module configurations are available. This approach aims to enable rapid prototyping and exploration of tangible programming experiences for diverse educational contexts.
Article Search
Article: prog26px-id7-p
‹Programming› Companion '26: "Literate Exploratory Programming ..."
Literate Exploratory Programming for Asynchronous Collaboration
Christoph Thiede, Tom Beckmann, Marcel Taeumel, and Robert Hirschfeld
(Hasso Plattner Institute - University of Potsdam, Germany)
A programmer can effectively explore systems by pursuing different approaches, conducting many experiments, and interacting with artifacts of the (runtime) environment. However, multiple programmers working together on the same exploration goal face challenges when communicating asynchronously, as they have to reproduce and explain relevant experiments and artifacts from their exploration to share them with coworkers. We propose literate exploratory programming as a novel workflow that combines exploration and explanation activities and reduces communication overheads through a tracking mechanism for extracting artifacts from the exploratory session. Inspired by traditional literate programming, in which implementation and contextualization are tightly interwoven, our approach introduces exploratory journals: a programmer can share artifacts such as code, runtime objects, and active debugging sessions together with prose, and another programmer can later resume the exploration from there. We demonstrate the feasibility of our approach by implementing a prototype in Squeak/Smalltalk and applying it for a design discussion in an open-source community. Our work indicates that tool support can foster effective collaboration in asynchronous exploratory programming contexts.
Article Search
Video
Article: prog26px-id8-p
‹Programming› Companion '26: "Liveness in the Age of Agents: ..."
Liveness in the Age of Agents: Are We Back to Compile-and-Run Cycles?
Toni Mattis, Marcel Taeumel, Lukas Böhme, and Robert Hirschfeld
(Hasso Plattner Institute - University of Potsdam, Germany)
An experienced programmer who works happily motivated within a live programming environment can yield high-quality software within reasonable time. A novice can also perform well because live programming tools foster short feedback loops, which help translate thoughts into executable program code and thus the desired observable system behavior. In the age of agents, now, one might think that actual programming skills take a step back to let visions shine: express your goal in natural language and let the agents make even larger, coherent edits to the system.
However, agents will take their time to think, and programmers require skills to make informed decisions about an agent's generated results. How "live" is that? How "short" does this feedback loop feel?
In this paper, we take a look at Tanimoto's liveness levels 5 and 6 in combination with Norman's interaction "gulfs" to discuss the impact agents have on the overall programming experience. We realize that the agent support is far from predictive as prompts take noticeable effort to clarify (or derive) a programmer's current goals. We also conclude that while the interaction cycles might feel quite productive at times, the experienced "Gulf of Evaluation" can be too much for novices if the results are too sophisticated.
For the (near) future, we believe that the programming experience around agents can further be tailored to improve both prompting and reviewing so that this very promising technology does not take us back to the times where lengthy compile-and-run cycles disrupted our thoughts, flow, and motivation.
Article Search
Article: prog26px-id12-p
‹Programming› Companion '26: "PhysiCode Builder: A Framework ..."
PhysiCode Builder: A Framework for Rapid Prototyping of Tangible Programming Toolkits
Hina Hiratsuka and Kenji Hisazumi
(Shibaura Institute of Technology, Japan)
Tangible programming---where learners physically manipulate blocks to construct programs---provides intuitive, hands-on programming experiences for novice learners. However, existing materials are fixed to specific language specifications, making it difficult for educators to customize them according to their learning objectives. This paper proposes PhysiCode Builder, a framework for automatically generating customizable tangible programming materials. Our approach applies module-based language construction to the domain of tangible materials through a clear separation of roles: Configuration Developers define language specifications (requiring basic technical knowledge), while Material Creators---typically classroom educators---select from predefined configurations to generate materials without programming or 3D modeling expertise. The framework employs a feature model derived from analyzing existing tangible user interface (TUI) materials and separates abstract syntax (programming concepts) from concrete syntax (physical block representations) through a paradigm-agnostic metamodel design. In the proposed workflow, Material Creators would select desired feature modules through a configuration interface, and the core synthesis engine generates corresponding 3D printable block models and camera-based recognition software using TopCodes. A technical walkthrough demonstrates that material generation, previously requiring weeks of expert collaboration, can potentially be completed in minutes once appropriate module configurations are available. This approach aims to enable rapid prototyping and exploration of tangible programming experiences for diverse educational contexts.
Article Search
Article: prog26px-id7-p
‹Programming› Companion '26: "A Behavior-Centric Programming ..."
A Behavior-Centric Programming Framework for Drone Systems with Digital Twin Backends
Ryota Uesugi, Nobuhiko Ogura, Kenji Hisazumi, and Harumi Watanabe
(Tokai University, Japan; Tokyo City University, Japan; Shibaura Institute of Technology, Japan)
This paper contributes to providing multiple views for a physical system's behavior dynamically to programmers and to enhance liveness and conformity in its programming. To develop physical systems, we need to consider many concerns such as weather, terrain, and traffic conditions. In current digital-twin-based development of autonomous systems, these are organized in layers. Also, our research group has contributed to this problem. However, even if we use such a development environment, we feel annoyed in some places. The cause is that we cannot easily distinguish the behavior of the physical system before and after changing programs. For observing behavior, programmers need to connect components or external systems. Also, if programmers want to focus only on system behavior, they need several actions to select the mode. Additionally, we cannot dynamically change behavior in popular development environments based on general digital twins. The programming of physical systems is naturally exploratory. Therefore, to provide a more comfortable development environment for exploratory programming, we pose the following research issues. (1) Dynamic multiple views: When we change a program, we can observe its behavior in multiple views, and the behavior of each view is also changed simultaneously. (2) Liveness and conformity: When we construct a program, we can check whether the program is as intended in our image before execution to confirm the conformity. Then, the program immediately executes without any bothersome actions to satisfy liveness. (3) Real drone: One program executes both on a digital twin and the real world. To address these issues, we propose a framework called Drone Behavior Analyzing Platform (DBAP) together with a domain-specific visual block programming language editor called Blocky Editor. To realize dynamic multiple views, other systems, including real drones in the Blocky Editor on DBAP, monitor changes to the program in the Blocky Editor. If each system recognizes the change, it changes its own behavior. Additionally, to execute the same program on both real and virtual drones, we use MAVLink, the communication protocol for unmanned systems. The feasibility of the framework is demonstrated by executing identical behavior programs on Hakoniwa and Unity-based simulators, as well as on a real drone system using ArduPilot.
Article Search
Article: prog26px-id9-p
‹Programming› Companion '26: "Code Layout Optimization Guided ..."
Code Layout Optimization Guided by Temporal Profiling Information
Marko Spasic, Miloje Joksimović, Peter Hofer, and Milena Vujošević Janičić
(University of Belgrade, Serbia; Oracle, Serbia; Oracle, Austria)
Code layout influences application startup performance, yet remains difficult to optimize due to dynamic and workload-dependent execution behavior. Poor method placement degrades instruction cache utilization and increases page faults, effects that are especially pronounced in latency-sensitive systems. Existing approaches based on static analysis or frequency-driven profiling often fail to capture the temporal structure of execution during startup.
We introduce Temporal Code Layout (TCL), a code placement strategy for GraalVM Native Image that reduces startup latency by exploiting the chronological order of method first invocation. Using lightweight timestamping instrumentation in GraalIR, we record first-call events during profiling and arrange methods according to their execution order. Experimental results show consistent improvements in time to first response by reducing instruction cache misses and page faults during early execution.
Article Search
Article: prog26morevms-id2-p
‹Programming› Companion '26: "Code Layout Optimization Guided ..."
Code Layout Optimization Guided by Temporal Profiling Information
Marko Spasic, Miloje Joksimović, Peter Hofer, and Milena Vujošević Janičić
(University of Belgrade, Serbia; Oracle, Serbia; Oracle, Austria)
Code layout influences application startup performance, yet remains difficult to optimize due to dynamic and workload-dependent execution behavior. Poor method placement degrades instruction cache utilization and increases page faults, effects that are especially pronounced in latency-sensitive systems. Existing approaches based on static analysis or frequency-driven profiling often fail to capture the temporal structure of execution during startup.
We introduce Temporal Code Layout (TCL), a code placement strategy for GraalVM Native Image that reduces startup latency by exploiting the chronological order of method first invocation. Using lightweight timestamping instrumentation in GraalIR, we record first-call events during profiling and arrange methods according to their execution order. Experimental results show consistent improvements in time to first response by reducing instruction cache misses and page faults during early execution.
Article Search
Article: prog26morevms-id2-p
‹Programming› Companion '26: "Code Layout Optimization Guided ..."
Code Layout Optimization Guided by Temporal Profiling Information
Marko Spasic, Miloje Joksimović, Peter Hofer, and Milena Vujošević Janičić
(University of Belgrade, Serbia; Oracle, Serbia; Oracle, Austria)
Code layout influences application startup performance, yet remains difficult to optimize due to dynamic and workload-dependent execution behavior. Poor method placement degrades instruction cache utilization and increases page faults, effects that are especially pronounced in latency-sensitive systems. Existing approaches based on static analysis or frequency-driven profiling often fail to capture the temporal structure of execution during startup.
We introduce Temporal Code Layout (TCL), a code placement strategy for GraalVM Native Image that reduces startup latency by exploiting the chronological order of method first invocation. Using lightweight timestamping instrumentation in GraalIR, we record first-call events during profiling and arrange methods according to their execution order. Experimental results show consistent improvements in time to first response by reducing instruction cache misses and page faults during early execution.
Article Search
Article: prog26morevms-id2-p
‹Programming› Companion '26: "The Promise of Static Profiling: ..."
The Promise of Static Profiling: Exploring the Limits
Milan Cugurovic, Aleksandar Prokopec, Boris Spasojevic, Vojin Jovanovic, and Milena Vujošević Janičić
(Oracle, Serbia; University of Belgrade, Serbia; Oracle, Switzerland)
Recent advances in machine learning have significantly enhanced the capabilities of static profilers, enabling them to capture complex program behaviors beyond traditional hand-crafted heuristics. While static profilers offer advantages such as easy integration and high resource efficiency compared with dynamic profilers, their accuracy remains limited because they rely on static program features and lack runtime information. Static profilers produce lower-quality profiles that lead to less optimized programs. However, the field still lacks a detailed breakdown across profile types and a systematic estimate of the potential of static profilers.
This paper provides the first comprehensive evaluation of the potential and practical upper bounds of static profiling techniques across a diverse range of program profiles, including branch execution probabilities, method call counts, profiles of virtual calls, and combinations of these profiles. We propose an idealized framework for static profiling and identify new avenues that extend beyond conventional branch prediction. Our results clarify the inherent trade-offs between static and dynamic approaches and reveal opportunities to expand the role of static profiling within modern optimizing compilers.
Article Search
Article: prog26morevms-id1-p
‹Programming› Companion '26: "Vexa: Automated Configuration-to-Code ..."
Vexa: Automated Configuration-to-Code Generation for On-Demand State Management in Vue.js Applications
Yizhi Mei and Tetsuo Kamina
(Oita University, Japan)
As modern Vue.js applications grow in complexity, managing the relationship between components and Vuex (an official Vue.js state management library) modules often requires cumbersome manual coordination. To address this challenge, we present Vexa (Vue.js External Expression Architect), a framework that introduces a configuration-driven development (CDD) approach to state management. Vexa enables automatic and on-demand loading of Vuex modules while providing transparent access to external data whose state is managed by those modules. Thus, it reduces manual development overhead through declarative design. By representing application dependencies using structured YAML configurations, Vexa performs dual-target code generation to produce both Vue components and Vuex modules. This not only improves maintainability, but also ensures consistency between UI components and state logic. A case study in demonstration-scale Vue.js applications shows that Vexa significantly improves overall development efficiency, without sacrificing flexibility.
Article Search
Article: prog26px-id5-p
‹Programming› Companion '26: "Value Support in the qBeta ..."
Value Support in the qBeta Language
Ole Lehrmann Madsen and Birger Møller-Pedersen
(Aarhus University, Denmark; University of Oslo, Norway)
Since the birth of object-oriented programming, it has been an issue to represent composite values in the same way as primitive values. Primitive values such as integers are embedded in the enclosing object, while composite values like points are represented by objects, which implies a structural overhead. In addition, there is often no clear distinction between reference assignment and value assignment and reference comparison and value comparison. It is an obvious approach to use the class mechanism to define value types. There are several efforts following this approach, but none of these have come up with a proposal without limitations. This includes the ability to define subtypes, virtual methods, avoid structural overhead, and clearly differentiate between reference and value assignment/comparison. In this paper, we provide a proposal on how to define values and value types using the mechanisms of object-oriented languages, with none of the above limitations. Equally important, the proposal reflects that objects and values are different kinds of entities; this is important for the modeling capabilities. The proposal is validated by an implementation.
Article Search
Article: prog26vimpl-id1-p
‹Programming› Companion '26: "Liveness in the Age of Agents: ..."
Liveness in the Age of Agents: Are We Back to Compile-and-Run Cycles?
Toni Mattis, Marcel Taeumel, Lukas Böhme, and Robert Hirschfeld
(Hasso Plattner Institute - University of Potsdam, Germany)
An experienced programmer who works happily motivated within a live programming environment can yield high-quality software within reasonable time. A novice can also perform well because live programming tools foster short feedback loops, which help translate thoughts into executable program code and thus the desired observable system behavior. In the age of agents, now, one might think that actual programming skills take a step back to let visions shine: express your goal in natural language and let the agents make even larger, coherent edits to the system.
However, agents will take their time to think, and programmers require skills to make informed decisions about an agent's generated results. How "live" is that? How "short" does this feedback loop feel?
In this paper, we take a look at Tanimoto's liveness levels 5 and 6 in combination with Norman's interaction "gulfs" to discuss the impact agents have on the overall programming experience. We realize that the agent support is far from predictive as prompts take noticeable effort to clarify (or derive) a programmer's current goals. We also conclude that while the interaction cycles might feel quite productive at times, the experienced "Gulf of Evaluation" can be too much for novices if the results are too sophisticated.
For the (near) future, we believe that the programming experience around agents can further be tailored to improve both prompting and reviewing so that this very promising technology does not take us back to the times where lengthy compile-and-run cycles disrupted our thoughts, flow, and motivation.
Article Search
Article: prog26px-id12-p
‹Programming› Companion '26: "Vexa: Automated Configuration-to-Code ..."
Vexa: Automated Configuration-to-Code Generation for On-Demand State Management in Vue.js Applications
Yizhi Mei and Tetsuo Kamina
(Oita University, Japan)
As modern Vue.js applications grow in complexity, managing the relationship between components and Vuex (an official Vue.js state management library) modules often requires cumbersome manual coordination. To address this challenge, we present Vexa (Vue.js External Expression Architect), a framework that introduces a configuration-driven development (CDD) approach to state management. Vexa enables automatic and on-demand loading of Vuex modules while providing transparent access to external data whose state is managed by those modules. Thus, it reduces manual development overhead through declarative design. By representing application dependencies using structured YAML configurations, Vexa performs dual-target code generation to produce both Vue components and Vuex modules. This not only improves maintainability, but also ensures consistency between UI components and state logic. A case study in demonstration-scale Vue.js applications shows that Vexa significantly improves overall development efficiency, without sacrificing flexibility.
Article Search
Article: prog26px-id5-p
‹Programming› Companion '26: "Towards Transferring Text ..."
Towards Transferring Text Comprehension Techniques to Program Comprehension
Teresa Dreyer, Joel Michel, and Christoph Bockisch
(University of Marburg, Germany)
The potential positive effect of text highlighting on comprehension and retention has been shown by psychological studies. As program code is a special case of text, in this concept paper we propose to investigate whether code comprehension can also benefit from highlighting in a similar way. To elicit requirements for a corresponding tool, we have studied the related literature from cognitive and educational psychology including studies concerned with highlighting on paper and in digital texts as well as literature on related software development tools. We propose Highlighter, a plugin for IntelliJ IDEA that fulfills these requirements and allows highlighting arbitrary sections of code in flexible styles inspired by on-paper highlighting as well as editing and browsing the highlights inspired by digital text highlighting tools. A field test including six users indicates that our plugin fulfills the requirements, is unobtrusive and seamlessly integrates with other operations in IDEs. The initial results are promising and a larger user study is now well prepared.
Article Search
Article: prog26px-id1-p
‹Programming› Companion '26: "Value Support in the qBeta ..."
Value Support in the qBeta Language
Ole Lehrmann Madsen and Birger Møller-Pedersen
(Aarhus University, Denmark; University of Oslo, Norway)
Since the birth of object-oriented programming, it has been an issue to represent composite values in the same way as primitive values. Primitive values such as integers are embedded in the enclosing object, while composite values like points are represented by objects, which implies a structural overhead. In addition, there is often no clear distinction between reference assignment and value assignment and reference comparison and value comparison. It is an obvious approach to use the class mechanism to define value types. There are several efforts following this approach, but none of these have come up with a proposal without limitations. This includes the ability to define subtypes, virtual methods, avoid structural overhead, and clearly differentiate between reference and value assignment/comparison. In this paper, we provide a proposal on how to define values and value types using the mechanisms of object-oriented languages, with none of the above limitations. Equally important, the proposal reflects that objects and values are different kinds of entities; this is important for the modeling capabilities. The proposal is validated by an implementation.
Article Search
Article: prog26vimpl-id1-p
‹Programming› Companion '26: "A Behavior-Centric Programming ..."
A Behavior-Centric Programming Framework for Drone Systems with Digital Twin Backends
Ryota Uesugi, Nobuhiko Ogura, Kenji Hisazumi, and Harumi Watanabe
(Tokai University, Japan; Tokyo City University, Japan; Shibaura Institute of Technology, Japan)
This paper contributes to providing multiple views for a physical system's behavior dynamically to programmers and to enhance liveness and conformity in its programming. To develop physical systems, we need to consider many concerns such as weather, terrain, and traffic conditions. In current digital-twin-based development of autonomous systems, these are organized in layers. Also, our research group has contributed to this problem. However, even if we use such a development environment, we feel annoyed in some places. The cause is that we cannot easily distinguish the behavior of the physical system before and after changing programs. For observing behavior, programmers need to connect components or external systems. Also, if programmers want to focus only on system behavior, they need several actions to select the mode. Additionally, we cannot dynamically change behavior in popular development environments based on general digital twins. The programming of physical systems is naturally exploratory. Therefore, to provide a more comfortable development environment for exploratory programming, we pose the following research issues. (1) Dynamic multiple views: When we change a program, we can observe its behavior in multiple views, and the behavior of each view is also changed simultaneously. (2) Liveness and conformity: When we construct a program, we can check whether the program is as intended in our image before execution to confirm the conformity. Then, the program immediately executes without any bothersome actions to satisfy liveness. (3) Real drone: One program executes both on a digital twin and the real world. To address these issues, we propose a framework called Drone Behavior Analyzing Platform (DBAP) together with a domain-specific visual block programming language editor called Blocky Editor. To realize dynamic multiple views, other systems, including real drones in the Blocky Editor on DBAP, monitor changes to the program in the Blocky Editor. If each system recognizes the change, it changes its own behavior. Additionally, to execute the same program on both real and virtual drones, we use MAVLink, the communication protocol for unmanned systems. The feasibility of the framework is demonstrated by executing identical behavior programs on Hakoniwa and Unity-based simulators, as well as on a real drone system using ArduPilot.
Article Search
Article: prog26px-id9-p
‹Programming› Companion '26: "A Tool for Transforming the ..."
A Tool for Transforming the Type of a Container in C++ Code
Ábel Szauter and Norbert Pataki
(Eötvös Loránd University, Hungary)
C++ provides a rich and handy library called Standard Template Library that is based on the generic programming paradigm. STL includes many useful containers like vector, linked lists, etc. The selection of the utilized container may have a significant impact on the developed applications' performance regarding runtime, memory consumption and management, etc. Unfortunately, the architecture of the library does not support altering this selection in a straighforward way. Evaluation of the selection can be quite difficult. Different containers may have methods with the same name, but they can differ in the provided methods and iterator capabilities. In this paper, we present a static analyzer tool that aims at the manipulation of a container type by changing it in existing code bases. The proposed tool is based on the Clang compiler infrastructure. For making the transformation seemless, we provide some class templates to hide the differences of methods.
Article Search
Article: prog26sclit-id1-p
‹Programming› Companion '26: "A Logical Foundation for Type-Safe ..."
A Logical Foundation for Type-Safe Cross-Language Interoperability (Keynote)
Brigitte Pientka
(McGill University, Canada)
Today’s software systems are complex and often made up of parts written in different programming languages with different computational and memory management strategies. This allows programmers to combine different languages and choose the most suitable one for a given problem. While this flexibility offers clear advantages, it also introduces significant challenges, as different programming languages may use different runtime environments, such as different VMs or hardware backends, which are hard to combine.
Unfortunately, most existing foundations for interoperability assume that we compile languages into a common, uniform, low-level language, and do not scale easily to a cross-language interoperability where there is no such uniform backend. In this work, we propose a logical foundation for cross-language interoperability where we retain the operational semantics of each part. It is grounded in adjoint logic -- a logic that unifies a wide collection of logics through the up-shift and down-shift modalities. Taking a Curry-Howard view, we can use the down-shift modality to model foreign function calls, and the up-shift modality to model runtime code generation and execution. This naturally gives rise to a static and an operational semantics where we can guarantee that languages respect their user-defined boundaries. Finally, we outline how we have used this foundation to reason about the interoperability between languages with fundamentally different runtime implementations such as functional languages and concurrent process languages or functional languages and quantum circuit description languages.
Article Search
Article: prog26key-key1-p
‹Programming› Companion '26: "The Promise of Static Profiling: ..."
The Promise of Static Profiling: Exploring the Limits
Milan Cugurovic, Aleksandar Prokopec, Boris Spasojevic, Vojin Jovanovic, and Milena Vujošević Janičić
(Oracle, Serbia; University of Belgrade, Serbia; Oracle, Switzerland)
Recent advances in machine learning have significantly enhanced the capabilities of static profilers, enabling them to capture complex program behaviors beyond traditional hand-crafted heuristics. While static profilers offer advantages such as easy integration and high resource efficiency compared with dynamic profilers, their accuracy remains limited because they rely on static program features and lack runtime information. Static profilers produce lower-quality profiles that lead to less optimized programs. However, the field still lacks a detailed breakdown across profile types and a systematic estimate of the potential of static profilers.
This paper provides the first comprehensive evaluation of the potential and practical upper bounds of static profiling techniques across a diverse range of program profiles, including branch execution probabilities, method call counts, profiles of virtual calls, and combinations of these profiles. We propose an idealized framework for static profiling and identify new avenues that extend beyond conventional branch prediction. Our results clarify the inherent trade-offs between static and dynamic approaches and reveal opportunities to expand the role of static profiling within modern optimizing compilers.
Article Search
Article: prog26morevms-id1-p
‹Programming› Companion '26: "Comparing Large Language Models ..."
Comparing Large Language Models and Traditional Clone Detection Tools for Intra- and Cross-Language Code Clone Detection
Luka Vranković and Gordana Rakić
(University of Novi Sad, Serbia)
Code clone detection is one of the fundamental problems in software maintenance. While traditional code clone detection techniques have achieved competitive results in identifying syntactic similarity, their ability to handle semantic and cross-language clones remains constrained. The emergence of large language models (LLMs) introduces new opportunities for exploring semantic relationships in source code, which at first glance appear suitable for clone detection tasks.
In this paper, we present an empirical comparison between LLM-based clone detection and a representative traditional tool (LICCA) across both intra-language and cross-language scenarios. We analyze the respective strengths and limitations of the two approaches and examine the impact of prompt formulation on detection performance. The experimental results suggest that integrating traditional clone detection tools with LLM-based semantic analysis may help address complementary strengths and limitations observed across the evaluated approaches.
Article Search
Article: prog26sclit-id2-p
‹Programming› Companion '26: "Code Layout Optimization Guided ..."
Code Layout Optimization Guided by Temporal Profiling Information
Marko Spasic, Miloje Joksimović, Peter Hofer, and Milena Vujošević Janičić
(University of Belgrade, Serbia; Oracle, Serbia; Oracle, Austria)
Code layout influences application startup performance, yet remains difficult to optimize due to dynamic and workload-dependent execution behavior. Poor method placement degrades instruction cache utilization and increases page faults, effects that are especially pronounced in latency-sensitive systems. Existing approaches based on static analysis or frequency-driven profiling often fail to capture the temporal structure of execution during startup.
We introduce Temporal Code Layout (TCL), a code placement strategy for GraalVM Native Image that reduces startup latency by exploiting the chronological order of method first invocation. Using lightweight timestamping instrumentation in GraalIR, we record first-call events during profiling and arrange methods according to their execution order. Experimental results show consistent improvements in time to first response by reducing instruction cache misses and page faults during early execution.
Article Search
Article: prog26morevms-id2-p
‹Programming› Companion '26: "The Promise of Static Profiling: ..."
The Promise of Static Profiling: Exploring the Limits
Milan Cugurovic, Aleksandar Prokopec, Boris Spasojevic, Vojin Jovanovic, and Milena Vujošević Janičić
(Oracle, Serbia; University of Belgrade, Serbia; Oracle, Switzerland)
Recent advances in machine learning have significantly enhanced the capabilities of static profilers, enabling them to capture complex program behaviors beyond traditional hand-crafted heuristics. While static profilers offer advantages such as easy integration and high resource efficiency compared with dynamic profilers, their accuracy remains limited because they rely on static program features and lack runtime information. Static profilers produce lower-quality profiles that lead to less optimized programs. However, the field still lacks a detailed breakdown across profile types and a systematic estimate of the potential of static profilers.
This paper provides the first comprehensive evaluation of the potential and practical upper bounds of static profiling techniques across a diverse range of program profiles, including branch execution probabilities, method call counts, profiles of virtual calls, and combinations of these profiles. We propose an idealized framework for static profiling and identify new avenues that extend beyond conventional branch prediction. Our results clarify the inherent trade-offs between static and dynamic approaches and reveal opportunities to expand the role of static profiling within modern optimizing compilers.
Article Search
Article: prog26morevms-id1-p
‹Programming› Companion '26: "A Tool for Transforming the ..."
A Tool for Transforming the Type of a Container in C++ Code
Ábel Szauter and Norbert Pataki
(Eötvös Loránd University, Hungary)
C++ provides a rich and handy library called Standard Template Library that is based on the generic programming paradigm. STL includes many useful containers like vector, linked lists, etc. The selection of the utilized container may have a significant impact on the developed applications' performance regarding runtime, memory consumption and management, etc. Unfortunately, the architecture of the library does not support altering this selection in a straighforward way. Evaluation of the selection can be quite difficult. Different containers may have methods with the same name, but they can differ in the provided methods and iterator capabilities. In this paper, we present a static analyzer tool that aims at the manipulation of a container type by changing it in existing code bases. The proposed tool is based on the Clang compiler infrastructure. For making the transformation seemless, we provide some class templates to hide the differences of methods.
Article Search
Article: prog26sclit-id1-p
‹Programming› Companion '26: "Literate Exploratory Programming ..."
Literate Exploratory Programming for Asynchronous Collaboration
Christoph Thiede, Tom Beckmann, Marcel Taeumel, and Robert Hirschfeld
(Hasso Plattner Institute - University of Potsdam, Germany)
A programmer can effectively explore systems by pursuing different approaches, conducting many experiments, and interacting with artifacts of the (runtime) environment. However, multiple programmers working together on the same exploration goal face challenges when communicating asynchronously, as they have to reproduce and explain relevant experiments and artifacts from their exploration to share them with coworkers. We propose literate exploratory programming as a novel workflow that combines exploration and explanation activities and reduces communication overheads through a tracking mechanism for extracting artifacts from the exploratory session. Inspired by traditional literate programming, in which implementation and contextualization are tightly interwoven, our approach introduces exploratory journals: a programmer can share artifacts such as code, runtime objects, and active debugging sessions together with prose, and another programmer can later resume the exploration from there. We demonstrate the feasibility of our approach by implementing a prototype in Squeak/Smalltalk and applying it for a design discussion in an open-source community. Our work indicates that tool support can foster effective collaboration in asynchronous exploratory programming contexts.
Article Search
Video
Article: prog26px-id8-p
‹Programming› Companion '26: "Liveness in the Age of Agents: ..."
Liveness in the Age of Agents: Are We Back to Compile-and-Run Cycles?
Toni Mattis, Marcel Taeumel, Lukas Böhme, and Robert Hirschfeld
(Hasso Plattner Institute - University of Potsdam, Germany)
An experienced programmer who works happily motivated within a live programming environment can yield high-quality software within reasonable time. A novice can also perform well because live programming tools foster short feedback loops, which help translate thoughts into executable program code and thus the desired observable system behavior. In the age of agents, now, one might think that actual programming skills take a step back to let visions shine: express your goal in natural language and let the agents make even larger, coherent edits to the system.
However, agents will take their time to think, and programmers require skills to make informed decisions about an agent's generated results. How "live" is that? How "short" does this feedback loop feel?
In this paper, we take a look at Tanimoto's liveness levels 5 and 6 in combination with Norman's interaction "gulfs" to discuss the impact agents have on the overall programming experience. We realize that the agent support is far from predictive as prompts take noticeable effort to clarify (or derive) a programmer's current goals. We also conclude that while the interaction cycles might feel quite productive at times, the experienced "Gulf of Evaluation" can be too much for novices if the results are too sophisticated.
For the (near) future, we believe that the programming experience around agents can further be tailored to improve both prompting and reviewing so that this very promising technology does not take us back to the times where lengthy compile-and-run cycles disrupted our thoughts, flow, and motivation.
Article Search
Article: prog26px-id12-p
‹Programming› Companion '26: "Literate Exploratory Programming ..."
Literate Exploratory Programming for Asynchronous Collaboration
Christoph Thiede, Tom Beckmann, Marcel Taeumel, and Robert Hirschfeld
(Hasso Plattner Institute - University of Potsdam, Germany)
A programmer can effectively explore systems by pursuing different approaches, conducting many experiments, and interacting with artifacts of the (runtime) environment. However, multiple programmers working together on the same exploration goal face challenges when communicating asynchronously, as they have to reproduce and explain relevant experiments and artifacts from their exploration to share them with coworkers. We propose literate exploratory programming as a novel workflow that combines exploration and explanation activities and reduces communication overheads through a tracking mechanism for extracting artifacts from the exploratory session. Inspired by traditional literate programming, in which implementation and contextualization are tightly interwoven, our approach introduces exploratory journals: a programmer can share artifacts such as code, runtime objects, and active debugging sessions together with prose, and another programmer can later resume the exploration from there. We demonstrate the feasibility of our approach by implementing a prototype in Squeak/Smalltalk and applying it for a design discussion in an open-source community. Our work indicates that tool support can foster effective collaboration in asynchronous exploratory programming contexts.
Article Search
Video
Article: prog26px-id8-p
‹Programming› Companion '26: "A Behavior-Centric Programming ..."
A Behavior-Centric Programming Framework for Drone Systems with Digital Twin Backends
Ryota Uesugi, Nobuhiko Ogura, Kenji Hisazumi, and Harumi Watanabe
(Tokai University, Japan; Tokyo City University, Japan; Shibaura Institute of Technology, Japan)
This paper contributes to providing multiple views for a physical system's behavior dynamically to programmers and to enhance liveness and conformity in its programming. To develop physical systems, we need to consider many concerns such as weather, terrain, and traffic conditions. In current digital-twin-based development of autonomous systems, these are organized in layers. Also, our research group has contributed to this problem. However, even if we use such a development environment, we feel annoyed in some places. The cause is that we cannot easily distinguish the behavior of the physical system before and after changing programs. For observing behavior, programmers need to connect components or external systems. Also, if programmers want to focus only on system behavior, they need several actions to select the mode. Additionally, we cannot dynamically change behavior in popular development environments based on general digital twins. The programming of physical systems is naturally exploratory. Therefore, to provide a more comfortable development environment for exploratory programming, we pose the following research issues. (1) Dynamic multiple views: When we change a program, we can observe its behavior in multiple views, and the behavior of each view is also changed simultaneously. (2) Liveness and conformity: When we construct a program, we can check whether the program is as intended in our image before execution to confirm the conformity. Then, the program immediately executes without any bothersome actions to satisfy liveness. (3) Real drone: One program executes both on a digital twin and the real world. To address these issues, we propose a framework called Drone Behavior Analyzing Platform (DBAP) together with a domain-specific visual block programming language editor called Blocky Editor. To realize dynamic multiple views, other systems, including real drones in the Blocky Editor on DBAP, monitor changes to the program in the Blocky Editor. If each system recognizes the change, it changes its own behavior. Additionally, to execute the same program on both real and virtual drones, we use MAVLink, the communication protocol for unmanned systems. The feasibility of the framework is demonstrated by executing identical behavior programs on Hakoniwa and Unity-based simulators, as well as on a real drone system using ArduPilot.
Article Search
Article: prog26px-id9-p
‹Programming› Companion '26: "Towards Least-Privilege WebAssembly ..."
Towards Least-Privilege WebAssembly Applications: Transparent Interposition for WebAssembly Components
Olav Blaak and Tom Van Cutsem
(DistriNet at KU Leuven, Belgium)
When a WebAssembly component is compromised, current security models cannot always prevent it from abusing the full set of capabilities granted at initialization. With the component model encouraging reuse of third-party components distributed via OCI registries, this creates supply chain risks similar to those that have plagued npm. Additionally, the WebAssembly System Interface (WASI) requires some capabilities to be granted statically and often allows components to discover these capabilities at run time through ambient authority, with no native support for dynamic revocation. This violates the principle of least authority and exacerbates the risk of software supply chain attacks. We present a transparent, language-agnostic, and runtime-agnostic prototype framework for interposing arbitrary logic at WebAssembly component boundaries. Our approach automatically wraps components while preserving their interfaces, enabling arbitrary logic insertion without modifying guest components or runtimes. Using the framework, we draw inspiration from previous work on higher-order contracts and propose an embedded DSL for specifying arbitrary logic in which we define fine-grained security policies that dynamically restrict capabilities. Our approach enables compositional reasoning about security and allows better enforcement of the principle of least authority for component-based WebAssembly programs.
Article Search
Article: prog26morevms-id3-p
‹Programming› Companion '26: "The Art, Science, and Craftsmanship ..."
The Art, Science, and Craftsmanship of Typography (Keynote)
Didier Verna
(EPITA Research Lab, France)
Typography (putting mostly textual content into shape) is an art because we are ultimately trying to create beautiful documents. Typography is also a craftsmanship because for a large part, beauty is in the eye of the reader, so experimentation is of paramount importance. Finally, typography is a science because most of the concrete problems that we need to solve are both chaotic in nature, and of exponential complexity.
In this talk, I will travel through the history of typography (past, present, and future), raising the audience's awareness of its inner art, science, and craftsmanship. I will also try to emphasize on the importance of conscientious typography. In a world obsessed with communication, the beauty of a document is not a purely esthetic matter. Because beautiful texts are more pleasant to read, they are also easier to understand.
Article Search
Article: prog26key-key2-p
‹Programming› Companion '26: "Comparing Large Language Models ..."
Comparing Large Language Models and Traditional Clone Detection Tools for Intra- and Cross-Language Code Clone Detection
Luka Vranković and Gordana Rakić
(University of Novi Sad, Serbia)
Code clone detection is one of the fundamental problems in software maintenance. While traditional code clone detection techniques have achieved competitive results in identifying syntactic similarity, their ability to handle semantic and cross-language clones remains constrained. The emergence of large language models (LLMs) introduces new opportunities for exploring semantic relationships in source code, which at first glance appear suitable for clone detection tasks.
In this paper, we present an empirical comparison between LLM-based clone detection and a representative traditional tool (LICCA) across both intra-language and cross-language scenarios. We analyze the respective strengths and limitations of the two approaches and examine the impact of prompt formulation on detection performance. The experimental results suggest that integrating traditional clone detection tools with LLM-based semantic analysis may help address complementary strengths and limitations observed across the evaluated approaches.
Article Search
Article: prog26sclit-id2-p
‹Programming› Companion '26: "The Promise of Static Profiling: ..."
The Promise of Static Profiling: Exploring the Limits
Milan Cugurovic, Aleksandar Prokopec, Boris Spasojevic, Vojin Jovanovic, and Milena Vujošević Janičić
(Oracle, Serbia; University of Belgrade, Serbia; Oracle, Switzerland)
Recent advances in machine learning have significantly enhanced the capabilities of static profilers, enabling them to capture complex program behaviors beyond traditional hand-crafted heuristics. While static profilers offer advantages such as easy integration and high resource efficiency compared with dynamic profilers, their accuracy remains limited because they rely on static program features and lack runtime information. Static profilers produce lower-quality profiles that lead to less optimized programs. However, the field still lacks a detailed breakdown across profile types and a systematic estimate of the potential of static profilers.
This paper provides the first comprehensive evaluation of the potential and practical upper bounds of static profiling techniques across a diverse range of program profiles, including branch execution probabilities, method call counts, profiles of virtual calls, and combinations of these profiles. We propose an idealized framework for static profiling and identify new avenues that extend beyond conventional branch prediction. Our results clarify the inherent trade-offs between static and dynamic approaches and reveal opportunities to expand the role of static profiling within modern optimizing compilers.
Article Search
Article: prog26morevms-id1-p
‹Programming› Companion '26: "A Behavior-Centric Programming ..."
A Behavior-Centric Programming Framework for Drone Systems with Digital Twin Backends
Ryota Uesugi, Nobuhiko Ogura, Kenji Hisazumi, and Harumi Watanabe
(Tokai University, Japan; Tokyo City University, Japan; Shibaura Institute of Technology, Japan)
This paper contributes to providing multiple views for a physical system's behavior dynamically to programmers and to enhance liveness and conformity in its programming. To develop physical systems, we need to consider many concerns such as weather, terrain, and traffic conditions. In current digital-twin-based development of autonomous systems, these are organized in layers. Also, our research group has contributed to this problem. However, even if we use such a development environment, we feel annoyed in some places. The cause is that we cannot easily distinguish the behavior of the physical system before and after changing programs. For observing behavior, programmers need to connect components or external systems. Also, if programmers want to focus only on system behavior, they need several actions to select the mode. Additionally, we cannot dynamically change behavior in popular development environments based on general digital twins. The programming of physical systems is naturally exploratory. Therefore, to provide a more comfortable development environment for exploratory programming, we pose the following research issues. (1) Dynamic multiple views: When we change a program, we can observe its behavior in multiple views, and the behavior of each view is also changed simultaneously. (2) Liveness and conformity: When we construct a program, we can check whether the program is as intended in our image before execution to confirm the conformity. Then, the program immediately executes without any bothersome actions to satisfy liveness. (3) Real drone: One program executes both on a digital twin and the real world. To address these issues, we propose a framework called Drone Behavior Analyzing Platform (DBAP) together with a domain-specific visual block programming language editor called Blocky Editor. To realize dynamic multiple views, other systems, including real drones in the Blocky Editor on DBAP, monitor changes to the program in the Blocky Editor. If each system recognizes the change, it changes its own behavior. Additionally, to execute the same program on both real and virtual drones, we use MAVLink, the communication protocol for unmanned systems. The feasibility of the framework is demonstrated by executing identical behavior programs on Hakoniwa and Unity-based simulators, as well as on a real drone system using ArduPilot.
Article Search
Article: prog26px-id9-p