‹Programming› Companion '24: "The Next-Gen Interactive Runtime ..."
The Next-Gen Interactive Runtime Simulator for Neural Network Programming
Sanaullah Sanaullah, Hasina Attaullah, and Thorsten Jungeblut
(Bielefeld University of Applied Sciences and Arts, Germany)
This abstract introduces a Next-Gen runtime tool research direction for neural network programming, which was presented in the Programming 2024 event. These runtime revolutionary tools allow users to conduct neural model evaluations and understand neuron behavior in run-time, neural network design, and training processes. By eliminating the need for extensive backend coding, one of the previously introduced runtime simulators called RAVSim, simplified the integration of custom datasets and enabled developers to focus on high-level tasks, accelerating advancements in artificial intelligence (AI) and computational neuroscience. With its innovative features and user-friendly interface, RAVSim supports researchers and developers in using SNNs full potential in diverse applications.
@InProceedings{‹Programming›24p8,
author = {Sanaullah Sanaullah and Hasina Attaullah and Thorsten Jungeblut},
title = {The Next-Gen Interactive Runtime Simulator for Neural Network Programming},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {8-10},
doi = {10.1145/3660829.3660833},
year = {2024},
}
Publisher's Version
Article: prog24posters-id1-p doi:10.1145/3660829.3660833
‹Programming› Companion '24: "Containers for GUI Models ..."
Containers for GUI Models
Knut Anders Stokke, Mikhail Barash, Jaakko Järvi, Elisabeth Stenholm, and Håkon Robbestad Gylterud
(University of Bergen, Norway; University of Turku, Finland)
We present an ongoing work towards a programming approach for Graphical User Interfaces (GUIs), where structural operations on GUI data structures (such as inserting, removing, or reorganizing) can be declaratively specified and their implementations automatically generated. Concretely, we investigate how the type-theoretical notion of containers, an abstract formalism for specifying data structures, can be used for defining manipulatable GUI structures that have (multi-way) dependencies between their elements.
@InProceedings{‹Programming›24p3,
author = {Knut Anders Stokke and Mikhail Barash and Jaakko Järvi and Elisabeth Stenholm and Håkon Robbestad Gylterud},
title = {Containers for GUI Models},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {3-5},
doi = {10.1145/3660829.3660830},
year = {2024},
}
Publisher's Version
Article: prog24posters-id4-p doi:10.1145/3660829.3660830
‹Programming› Companion '24: "Programming Algorithmic Art ..."
Programming Algorithmic Art (Keynote)
Benoit Baudry
(Université de Montŕeal, Canada)
Some artists embrace randomness and geometric patterns. Many turn to programming as the appropriate medium to explore their ideas and create artworks. In this talk, we explore this artistic practice known as generative art or algorithmic art. We look at iconic examples of generative art and explore the current state of the art of programming abstractions and libraries that artists use.
@InProceedings{‹Programming›24p1,
author = {Benoit Baudry},
title = {Programming Algorithmic Art (Keynote)},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {1-1},
doi = {10.1145/3660829.3661026},
year = {2024},
}
Publisher's Version
Article: prog24key-key1-p doi:10.1145/3660829.3661026
‹Programming› Companion '24: "Ironies of Programming Automation: ..."
Ironies of Programming Automation: Exploring the Experience of Code Synthesis via Large Language Models
Alan T. McCabe, Moa Björkman, Joel Engström, Peng Kuang, Emma Söderberg, and Luke Church
(Lund University, Sweden; University of Cambridge, United Kingdom)
The widespread availability of large language models (LLMs) has presented the opportunity for novice programmers to make use of them for the purpose of understanding and synthesising code. In this paper, we discuss a small pilot study intended to explore the user experience of doing so in a limited way, and the attitudes of a group of novice programmers towards this style of programming. We also draw parallels to the seminal work of Lisanne Bainbridge, and discuss the way in which her "ironies of automation" are also present when attempting to automate the activity of programming.
@InProceedings{‹Programming›24p12,
author = {Alan T. McCabe and Moa Björkman and Joel Engström and Peng Kuang and Emma Söderberg and Luke Church},
title = {Ironies of Programming Automation: Exploring the Experience of Code Synthesis via Large Language Models},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {12-21},
doi = {10.1145/3660829.3660835},
year = {2024},
}
Publisher's Version
Article: prog24progai-p01-p doi:10.1145/3660829.3660835
‹Programming› Companion '24: "Faster Feedback with AI? A ..."
Faster Feedback with AI? A Test Prioritization Study
Toni Mattis, Lukas Böhme, Eva Krebs, Martin C. Rinard, and Robert Hirschfeld
(Hasso Plattner Institute, Germany; University of Potsdam, Germany; Massachusetts Institute of Technology, USA)
Feedback during programming is desirable, but its usefulness depends on immediacy and relevance to the task. Unit and regression testing are practices to ensure programmers can obtain feedback on their changes; however, running a large test suite is rarely fast, and only a few results are relevant. Identifying tests relevant to a change can help programmers in two ways: upcoming issues can be detected earlier during programming, and relevant tests can serve as examples to help programmers understand the code they are editing. In this work, we describe an approach to evaluate how well large language models (LLMs) and embedding models can judge the relevance of a test to a change. We construct a dataset by applying faulty variations of real-world code changes and measuring whether the model could nominate the failing tests beforehand. We found that, while embedding models perform best on such a task, even simple information retrieval models are surprisingly competitive. In contrast, pre-trained LLMs are of limited use as they focus on confounding aspects like coding styles. We argue that the high computational cost of AI models is not always justified, and tool developers should also consider non-AI models for code-related retrieval and recommendation tasks. Lastly, we generalize from unit tests to live examples and outline how our approach can benefit live programming environments.
@InProceedings{‹Programming›24p32,
author = {Toni Mattis and Lukas Böhme and Eva Krebs and Martin C. Rinard and Robert Hirschfeld},
title = {Faster Feedback with AI? A Test Prioritization Study},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {32-40},
doi = {10.1145/3660829.3660837},
year = {2024},
}
Publisher's Version
Article: prog24progai-p03-p doi:10.1145/3660829.3660837
‹Programming› Companion '24: "Ironies of Programming Automation: ..."
Ironies of Programming Automation: Exploring the Experience of Code Synthesis via Large Language Models
Alan T. McCabe, Moa Björkman, Joel Engström, Peng Kuang, Emma Söderberg, and Luke Church
(Lund University, Sweden; University of Cambridge, United Kingdom)
The widespread availability of large language models (LLMs) has presented the opportunity for novice programmers to make use of them for the purpose of understanding and synthesising code. In this paper, we discuss a small pilot study intended to explore the user experience of doing so in a limited way, and the attitudes of a group of novice programmers towards this style of programming. We also draw parallels to the seminal work of Lisanne Bainbridge, and discuss the way in which her "ironies of automation" are also present when attempting to automate the activity of programming.
@InProceedings{‹Programming›24p12,
author = {Alan T. McCabe and Moa Björkman and Joel Engström and Peng Kuang and Emma Söderberg and Luke Church},
title = {Ironies of Programming Automation: Exploring the Experience of Code Synthesis via Large Language Models},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {12-21},
doi = {10.1145/3660829.3660835},
year = {2024},
}
Publisher's Version
Article: prog24progai-p01-p doi:10.1145/3660829.3660835
‹Programming› Companion '24: "A Constraint Programming Approach ..."
A Constraint Programming Approach for QUBO Solving and Quantum Annealing
Philippe Codognet
(JFLI – CNRS, France; Sorbonne University, France; University of Tokyo, Japan)
Quantum Annealing is an alternative type of computation in which problems are encoded in quantum Hamiltonians (energy functions) and quantum dynamics is used to find solutions (ground states of minimal energy). Quantum computers such as the D-Wave systems are indeed implementing those ideas in hardware, as well as "quantum-inspired" devices based on classical electronics such as Fujitsu’s Digital Annealing Unit. All those systems use the same modeling language: Quadratic Unconstrained Binary Optimization (QUBO). However, QUBO is a low-level language and for modeling combinatorial problems such as constraint satisfaction and constrained optimization problems, we need to introduce higher-level abstractions in order to define complex constraints. We present in this paper an experience report on the use of a constraint-based methodology coming from the Constraint Programming paradigm for solving combinatorial problems by quantum computing, in particular for systems based on quantum annealing. We give a general overview of our recent works on Quantum Annealing and QUBO modeling [17, 19–21, 23, 44] and try to formulate the lessons learned from these experiments and possible research directions.
@InProceedings{‹Programming›24p126,
author = {Philippe Codognet},
title = {A Constraint Programming Approach for QUBO Solving and Quantum Annealing},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {126-132},
doi = {10.1145/3660829.3660850},
year = {2024},
}
Publisher's Version
Article: prog24qp-id5-p doi:10.1145/3660829.3660850
‹Programming› Companion '24: "A Virtual Machine for Higher-Order ..."
A Virtual Machine for Higher-Order Reactors
Bjarno Oeyen, Jens Nicolay, and Wolfgang De Meuter
(Vrije Universiteit Brussel, Belgium)
We present the design of a Remus, a virtual machine for reactive (RP) programs --- signal-based programs that react automatically to changes --- that is currently under development. The design of Remus been tailored specifically for reactive programs: it has a dedicated instruction set and memory model that is compatible with the model of reactive programming. The virtual machine allows reactive programs to be evaluated without needing to compile them to native code, nor by running them on an existing (general-purpose) virtual machine that is not specific to RP. The model of the virtual machine makes it possible to reason over the various behavioural aspects of a reactive program, such as memory consumption, in a language-agnostic way. As an example, we propose a static analysis that aims to eliminate dynamic allocations that occur in dynamic reactive programs: i.e., programs where the dependencies between the signals that make up a program changes at run-time. We show that our virtual machine, supplemented by the results of the analysis, allows for (well-behaved) reactive programs to be evaluated in constant space (i.e. in bounded memory) even when dependencies change or new signals are created programmatically.
@InProceedings{‹Programming›24p52,
author = {Bjarno Oeyen and Jens Nicolay and Wolfgang De Meuter},
title = {A Virtual Machine for Higher-Order Reactors},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {52-56},
doi = {10.1145/3660829.3660840},
year = {2024},
}
Publisher's Version
Article: prog24morevms-id2-p doi:10.1145/3660829.3660840
‹Programming› Companion '24: "Implementing Babylonian/G ..."
Implementing Babylonian/G by Putting Examples into Game Contexts
Eva Krebs, Toni Mattis, Marius Dörbandt, Oliver Schulz, Martin C. Rinard, and Robert Hirschfeld
(Hasso Plattner Institute, Germany; University of Potsdam, Germany; Massachusetts Institute of Technology, USA)
In game development, there are several ways to debug and inspect systems. These include very specialized and often visual tools, e.g. an on-demand collision box visualization. More general software engineering tools are often also available, e.g. "printf" debugging. However, default tools found in game engines are often either very specialized (like the collision box tool) or more general, but less domain-specific and spatially distant (like "printf" debugging). Thus, we wanted to create a new tool that is as universal and easy to use as "printf" debugging but supports domain-specific representations and has the possibility to be integrated closer to the actual code parts or game elements that are involved. There are pre-existing programming environments similar to our goal: Babylonian Programming systems aim to enable developers to interact with concrete information directly in the code itself. In this paper, we introduce the resulting toolset: Babylonian/G, a Babylonian-inspired plug-in for the Godot game engine. This includes a new way of thinking about Babylonian examples in a game context, in-application probes, and the possibility of adding user input to examples.
@InProceedings{‹Programming›24p68,
author = {Eva Krebs and Toni Mattis and Marius Dörbandt and Oliver Schulz and Martin C. Rinard and Robert Hirschfeld},
title = {Implementing Babylonian/G by Putting Examples into Game Contexts},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {68-72},
doi = {10.1145/3660829.3660847},
year = {2024},
}
Publisher's Version
Article: prog24px-id11-p doi:10.1145/3660829.3660847
‹Programming› Companion '24: "Ironies of Programming Automation: ..."
Ironies of Programming Automation: Exploring the Experience of Code Synthesis via Large Language Models
Alan T. McCabe, Moa Björkman, Joel Engström, Peng Kuang, Emma Söderberg, and Luke Church
(Lund University, Sweden; University of Cambridge, United Kingdom)
The widespread availability of large language models (LLMs) has presented the opportunity for novice programmers to make use of them for the purpose of understanding and synthesising code. In this paper, we discuss a small pilot study intended to explore the user experience of doing so in a limited way, and the attitudes of a group of novice programmers towards this style of programming. We also draw parallels to the seminal work of Lisanne Bainbridge, and discuss the way in which her "ironies of automation" are also present when attempting to automate the activity of programming.
@InProceedings{‹Programming›24p12,
author = {Alan T. McCabe and Moa Björkman and Joel Engström and Peng Kuang and Emma Söderberg and Luke Church},
title = {Ironies of Programming Automation: Exploring the Experience of Code Synthesis via Large Language Models},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {12-21},
doi = {10.1145/3660829.3660835},
year = {2024},
}
Publisher's Version
Article: prog24progai-p01-p doi:10.1145/3660829.3660835
‹Programming› Companion '24: "Recent Evolution of Dart: ..."
Recent Evolution of Dart: A Pragmatic Story (Keynote)
Erik Ernst
(Google, Denmark)
This talk takes a look at a number of steps taken in recent years in the evolution of the Dart programming language, including null safety, local variable promotion and flow analysis, extension types, and more. Special emphasis is given to the pragmatic nature of many elements of these features, as opposed to the more ideal approach which is available to programming language designers who do not have an existing installed base of code, and a community of developers who do not want to change all of it just for fun. For example, the migration of null safety involved an additional kind of type that only existed during the transition period.
@InProceedings{‹Programming›24p2,
author = {Erik Ernst},
title = {Recent Evolution of Dart: A Pragmatic Story (Keynote)},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {2-2},
doi = {10.1145/3660829.3661027},
year = {2024},
}
Publisher's Version
Published Artifact
Artifacts Available
Article: prog24key-key2-p doi:10.1145/3660829.3661027
‹Programming› Companion '24: "BoaSpect: An Expressive Instrumentation ..."
BoaSpect: An Expressive Instrumentation Platform for JavaScript
Aäron Munsters, Angel Luis Scull Pupo, and Elisa Gonzalez Boix
(Vrije Universiteit Brussel, Belgium)
Instrumentation platforms facilitate the development and deployment of dynamic analyses. The state-of-the-art instrumentation platforms for JavaScript rely on different weaving approaches for instrumentation, offering different levels of analysis expressiveness. The main issue is that they are unable to observe and reason about abstract operations, i.e. operations that are not exposed as language constructs but are used within the runtime. However, abstract operations are pivotal to understanding JavaScript’s program behaviour. This paper demonstrates the importance of exposing the ToPrimitive abstract operation, which lies at the core of JavaScript’s type coercion. We introduce BoaSpect, an interpreter-based instrumentation platform for JavaScript, which provides increased expressiveness by exposing the ToPrimitive trap through the instrumentation interface. We demonstrate its potential by implementing a novel analysis in BoaSpect to identify a potential security exploit, and a taint analysis which can track information flows precisely in the presence of implicit type coercions.
@InProceedings{‹Programming›24p47,
author = {Aäron Munsters and Angel Luis Scull Pupo and Elisa Gonzalez Boix},
title = {BoaSpect: An Expressive Instrumentation Platform for JavaScript},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {47-51},
doi = {10.1145/3660829.3660839},
year = {2024},
}
Publisher's Version
Article: prog24morevms-id3-p doi:10.1145/3660829.3660839
‹Programming› Companion '24: "Lightweight Affine Types for ..."
Lightweight Affine Types for Safe Concurrency in Scala (Keynote)
Philipp Haller
(KTH Royal Institute of Technology, Sweden)
Type systems for linearity and aliasing control hold great promise to address some of the most pressing challenges in programming languages and software engineering, including the static prevention of data races and safe manual memory management. Extending the type systems of existing languages is a challenge, however, preventing many recent advances from practical use. This talk reports on efforts attempting to integrate lightweight affine types and uniqueness into Scala. Experience shows that creative combinations of advanced features of Scala’s type system can reduce the integration effort. Furthermore, co-designing type systems and concurrency models is beneficial to achieve a flexible design.
@InProceedings{‹Programming›24p133,
author = {Philipp Haller},
title = {Lightweight Affine Types for Safe Concurrency in Scala (Keynote)},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {133-133},
doi = {10.1145/3660829.3661033},
year = {2024},
}
Publisher's Version
Article: prog24vimpl-key2-p doi:10.1145/3660829.3661033
‹Programming› Companion '24: "Design of Flexible Code Block ..."
Design of Flexible Code Block Comparisons to Improve Code Review of Refactored Code
Lo Heander, Emma Söderberg, and Christofer Rydenfält
(Lund University, Sweden)
Code review occupies a significant amount of developers' work time and is an established practice in modern software development. Despite misaligments between users' goals and the code review tools and processes pointed out by recent research, the code review tooling has largely stayed the same since the early 90s. Improving these tools, even slightly, has the potential for a large impact spread out over time and the large developer community. In this paper, we use the Double Diamond design process to work together with a team of industry practitioners to find, refine, prototype, and evaluate ways to make it easier to compare refactored code blocks and find previously hard-to-see changes in them. The results show that a flexible comparison modal integrated into Gerrit could reduce the mental load of code review on refactored code. Potentially, it could also have effects on how code is written by no longer discouraging refactoring due to it complicating the review. The user interface created in this collaborative manner was also intuitive enough for all of the participants to be able to use it without any hints or instructions.
@InProceedings{‹Programming›24p57,
author = {Lo Heander and Emma Söderberg and Christofer Rydenfält},
title = {Design of Flexible Code Block Comparisons to Improve Code Review of Refactored Code},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {57-67},
doi = {10.1145/3660829.3660842},
year = {2024},
}
Publisher's Version
Article: prog24px-id6-p doi:10.1145/3660829.3660842
‹Programming› Companion '24: "Faster Feedback with AI? A ..."
Faster Feedback with AI? A Test Prioritization Study
Toni Mattis, Lukas Böhme, Eva Krebs, Martin C. Rinard, and Robert Hirschfeld
(Hasso Plattner Institute, Germany; University of Potsdam, Germany; Massachusetts Institute of Technology, USA)
Feedback during programming is desirable, but its usefulness depends on immediacy and relevance to the task. Unit and regression testing are practices to ensure programmers can obtain feedback on their changes; however, running a large test suite is rarely fast, and only a few results are relevant. Identifying tests relevant to a change can help programmers in two ways: upcoming issues can be detected earlier during programming, and relevant tests can serve as examples to help programmers understand the code they are editing. In this work, we describe an approach to evaluate how well large language models (LLMs) and embedding models can judge the relevance of a test to a change. We construct a dataset by applying faulty variations of real-world code changes and measuring whether the model could nominate the failing tests beforehand. We found that, while embedding models perform best on such a task, even simple information retrieval models are surprisingly competitive. In contrast, pre-trained LLMs are of limited use as they focus on confounding aspects like coding styles. We argue that the high computational cost of AI models is not always justified, and tool developers should also consider non-AI models for code-related retrieval and recommendation tasks. Lastly, we generalize from unit tests to live examples and outline how our approach can benefit live programming environments.
@InProceedings{‹Programming›24p32,
author = {Toni Mattis and Lukas Böhme and Eva Krebs and Martin C. Rinard and Robert Hirschfeld},
title = {Faster Feedback with AI? A Test Prioritization Study},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {32-40},
doi = {10.1145/3660829.3660837},
year = {2024},
}
Publisher's Version
Article: prog24progai-p03-p doi:10.1145/3660829.3660837
‹Programming› Companion '24: "Implementing Babylonian/G ..."
Implementing Babylonian/G by Putting Examples into Game Contexts
Eva Krebs, Toni Mattis, Marius Dörbandt, Oliver Schulz, Martin C. Rinard, and Robert Hirschfeld
(Hasso Plattner Institute, Germany; University of Potsdam, Germany; Massachusetts Institute of Technology, USA)
In game development, there are several ways to debug and inspect systems. These include very specialized and often visual tools, e.g. an on-demand collision box visualization. More general software engineering tools are often also available, e.g. "printf" debugging. However, default tools found in game engines are often either very specialized (like the collision box tool) or more general, but less domain-specific and spatially distant (like "printf" debugging). Thus, we wanted to create a new tool that is as universal and easy to use as "printf" debugging but supports domain-specific representations and has the possibility to be integrated closer to the actual code parts or game elements that are involved. There are pre-existing programming environments similar to our goal: Babylonian Programming systems aim to enable developers to interact with concrete information directly in the code itself. In this paper, we introduce the resulting toolset: Babylonian/G, a Babylonian-inspired plug-in for the Godot game engine. This includes a new way of thinking about Babylonian examples in a game context, in-application probes, and the possibility of adding user input to examples.
@InProceedings{‹Programming›24p68,
author = {Eva Krebs and Toni Mattis and Marius Dörbandt and Oliver Schulz and Martin C. Rinard and Robert Hirschfeld},
title = {Implementing Babylonian/G by Putting Examples into Game Contexts},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {68-72},
doi = {10.1145/3660829.3660847},
year = {2024},
}
Publisher's Version
Article: prog24px-id11-p doi:10.1145/3660829.3660847
‹Programming› Companion '24: "Unanticipated Progress Indication: ..."
Unanticipated Progress Indication: Continuous Responsiveness for Courageous Exploration
Marcel Taeumel, Jens Lincke, and Robert Hirschfeld
(Hasso Plattner Institute, Germany; University of Potsdam, Germany)
Scripting environments support exploration from smaller programs to larger systems. From original Smalltalk workspaces to modern Python notebooks, such tool support is known to foster understanding. However, programmers struggle with unforeseen effects from script execution, disrupting their thoughts. Unexpectedly long response times, in particular, cause frustration due to progress info not being provided automatically for ad-hoc scripting tasks. In Smalltalk systems, experienced programmers can interrupt an unresponsive environment to look for such info manually. We propose an automatic approach for progress indication, using a watchdog that periodically scans the stack of script workers for known heuristics to then derive task identity, label, and progress metrics. Using Squeak/Smalltalk as an object-oriented, single-threaded, cooperative scripting environment, we argue that simple heuristics for list enumeration or other patterns can (1) keep users informed while (2) leaving scripts untouched and (3) mostly retaining execution performance. We believe that Unanticipated Progress Indication will encourage programmers to experiment with library interfaces and domain artifacts more often, which will reduce their cognitive load for an expedient programming experience.
@InProceedings{‹Programming›24p80,
author = {Marcel Taeumel and Jens Lincke and Robert Hirschfeld},
title = {Unanticipated Progress Indication: Continuous Responsiveness for Courageous Exploration},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {80-86},
doi = {10.1145/3660829.3660843},
year = {2024},
}
Publisher's Version
Article: prog24px-id7-p doi:10.1145/3660829.3660843
‹Programming› Companion '24: "Multi-threaded OpenSmalltalk ..."
Multi-threaded OpenSmalltalk VM: Choosing a Strategy for Parallelization
Leon Matthes, Marcel Taeumel, Eliot Miranda, and Robert Hirschfeld
(Hasso Plattner Institute, Germany; University of Potsdam, Germany)
Dynamic, object-oriented programming languages are widely regarded as enjoyable and easy to use. These languages lend themselves well to exploration and very short iteration cycles and feedback loops. However, many of them have no or limited support for multithreading. Squeak, a modern Smalltalk programming environment that focuses on interactivity and programming experience, doesn't support multithreading. We discuss multiple high-level strategies employed by similar languages and runtime environments to support parallel execution. Existing research and implementations using the presented strategies are analyzed to find a good fit for the Squeak/Smalltalk ecosystem. Due to Squeak's strong focus on interactivity and programming experience, we decided for an approach with limited support for parallelization. Our focus on a straight-forward implementation is based on our observation that reduction of pause times is more important for the programming experience than a model for fully parallel execution.
@InProceedings{‹Programming›24p87,
author = {Leon Matthes and Marcel Taeumel and Eliot Miranda and Robert Hirschfeld},
title = {Multi-threaded OpenSmalltalk VM: Choosing a Strategy for Parallelization},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {87-93},
doi = {10.1145/3660829.3660846},
year = {2024},
}
Publisher's Version
Article: prog24px-id10-p doi:10.1145/3660829.3660846
‹Programming› Companion '24: "Examples out of Thin Air: ..."
Examples out of Thin Air: AI-Generated Dynamic Context to Assist Program Comprehension by Example
Toni Mattis, Eva Krebs, Martin C. Rinard, and Robert Hirschfeld
(Hasso Plattner Institute, Germany; University of Potsdam, Germany; Massachusetts Institute of Technology, USA)
Programmers often benefit from the availability of concrete run-time data alongside abstract source code. However, programmers need to manually exercise the program to reach an interesting state or write code that reproducibly executes a functionality with concrete inputs to be able to observe concrete data. This work aims to automate this process by leveraging generative AI. We present a framework and a preliminary Smalltalk-based prototype allowing programmers to obtain and run examples for the currently viewed source code section from a large language model. Our approach demonstrates how locally hosted LLMs can be fine-tuned and used for such a task with reasonable computational effort while minimizing common problems like hallucinations and out-of-date knowledge. The framework has direct applications in example-based live programming, where it can suggest new examples, and in learning settings where novices need to know how to use certain functionality.
@InProceedings{‹Programming›24p99,
author = {Toni Mattis and Eva Krebs and Martin C. Rinard and Robert Hirschfeld},
title = {Examples out of Thin Air: AI-Generated Dynamic Context to Assist Program Comprehension by Example},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {99-107},
doi = {10.1145/3660829.3660845},
year = {2024},
}
Publisher's Version
Article: prog24px-id9-p doi:10.1145/3660829.3660845
‹Programming› Companion '24: "Towards a DevOps Modeling ..."
Towards a DevOps Modeling Based on Context-Oriented Programming
Harumi Watanabe, Nobuhiko Ogura, and Kenji Hisazumi
(Tokai University, Japan; Tokyo City University, Japan; Sibaura Institute of Technology, Japan)
This article contributes to the initial step of applying Context-Oriented Programming to DevOps. In DevOps, we must maintain continuously. One of the critical problems in maintenance is caused by cross-cutting concerns. In recent programs, the cross-cutting concerns occur at runtime. To solve this problem, we focus on Context-Oriented Programming (COP). COP consists of layers, and it solves the runtime cross-cutting concern problem. However, the existing modeling methods are limited. In DevOps, we need a more strategic method. In the maintenance process, we must improve the software based on user data, in addition to bug fixing. This article introduces a method of DevOps modeling based on COP.
@InProceedings{‹Programming›24p6,
author = {Harumi Watanabe and Nobuhiko Ogura and Kenji Hisazumi},
title = {Towards a DevOps Modeling Based on Context-Oriented Programming},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {6-7},
doi = {10.1145/3660829.3660832},
year = {2024},
}
Publisher's Version
Article: prog24posters-id5-p doi:10.1145/3660829.3660832
‹Programming› Companion '24: "In-Line Compositional Visual ..."
In-Line Compositional Visual Programming
Michael Homer
(Victoria University of Wellington, New Zealand)
Concatenative programming inherently expresses composition of sub-tasks of a pipeline, but one uncommonly seen model of this paradigm includes all data values inline within the program. A visual environment for editing and evaluating programs in this model would inherently display state in place, and allow for easy tracing of data flow through the program by watching the values literally move as evaluation steps took place. We propose a visual approach for programming in this style, with function calls and data values interleaved on a single "track", with specific concrete arguments always adjacent when a function term is evaluated and various affordances for editing, evaluating, and debugging. We then show how extensions to this model to multiple tracks can ease programming in the model and even make available some more inscrutable programming-language features, such as concurrency and effect systems, in a more accessible way.
@InProceedings{‹Programming›24p73,
author = {Michael Homer},
title = {In-Line Compositional Visual Programming},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {73-79},
doi = {10.1145/3660829.3660841},
year = {2024},
}
Publisher's Version
Article: prog24px-id3-p doi:10.1145/3660829.3660841
‹Programming› Companion '24: "Developers’ Perspective ..."
Developers’ Perspective on Today’s and Tomorrow’s Programming Tool Assistance: A Survey
Peng Kuang, Emma Söderberg, and Martin Höst
(Lund University, Sweden; Malmö University, Sweden)
Software development is a complex activity that needs a lot of tool assistance. Over the years there has been a lot of effort put into development of automated assistance to help with activities such as detection of issues via program analysis, or refactoring of code. Recently, the landscape of developer tool assistance is being disrupted with the entry of AI tools, such as Copilot and ChatGPT, powered via Large Language Models. Other kinds of tool assistance, for instance, gaze-driven assistance, is around the corner. What are programmers’ perceptions on tool assistance today? What do they see as good directions for the future? In this paper, we present the results of a survey where we asked developers about their programming practices, experience with program analysis, and attitudes and views on enabling technologies, like AI and eye-tracking. We received 68 replies from a diverse group of developers from 12 countries. We found that 50% of the participants use program analysis and that many participants (N=28) already use AI-enabled tools for programming. We found that our participants were positive toward AI-powered tools, neutral toward eye-tracking, and negative toward gamification. We discuss these and other findings and point out directions for future work.
@InProceedings{‹Programming›24p108,
author = {Peng Kuang and Emma Söderberg and Martin Höst},
title = {Developers’ Perspective on Today’s and Tomorrow’s Programming Tool Assistance: A Survey},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {108-116},
doi = {10.1145/3660829.3660848},
year = {2024},
}
Publisher's Version
Info
Article: prog24px-id13-p doi:10.1145/3660829.3660848
‹Programming› Companion '24: "Retro-fitting Garbage Collection ..."
Retro-fitting Garbage Collection into Rust (Invited Talk)
Jacob Hughes
(King’s College London, United Kingdom)
Rust is a non-Garbage Collected (GCed) language, but the lack of GC makes expressing data-structures whose values have multiple owners awkward or inefficient. Adding GC to Rust has previously required sacrificing at least one of performance, soundness, or ergonomics. We identify the major challenge for practical GC for Rust as finalisers: mapping existing Rust destructors to GC finalisers seems natural but introduces subtle soundness, significant performance, and irritating ergonomic issues. In this talk, I’ll introduce Alloy, a new GC for Rust, and discuss how it provides solutions for each of these issues.
@InProceedings{‹Programming›24p42,
author = {Jacob Hughes},
title = {Retro-fitting Garbage Collection into Rust (Invited Talk)},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {42-42},
doi = {10.1145/3660829.3661030},
year = {2024},
}
Publisher's Version
Article: prog24morevms-key2-p doi:10.1145/3660829.3661030
‹Programming› Companion '24: "Model-Based Framework for ..."
Model-Based Framework for Continuous Adaptation and Evolution of Quantum-Classical Hybrid Systems
Fuyuki Ishikawa and Shinobu Saito
(National Institute of Informatics, Japan; NTT Computer and Data Science Laboratories, Japan)
Although quantum computing has been attracting increasing attention, hardware restrictions are tight in current implementations. Intensive design exploration is therefore essential to match requirements, such as the problem scale and acceptable error rate, with potential designs to combine quantum computing and classical computing. The design decision made in this way is often fragile as it is sensitive to the problem scale as well as still evolving quantum services. We need continuous design decision, or adaptation and evolution, given changes in requirements or environments. In this paper, we present a framework for model-based engineering to support the continuous adaptation and evolution of quantum-classical hybrid systems. Modeling in our framework involves not only potential designs, but also rationale or evidence of design decision, which often requires simulation and experiments. This focus allows for tracing and analyzing whether the past decision is still valid or not, or whether there is uncertainty and we need further simulation and experiments. The usage of the framework is demonstrated with an example problem from steel manufacturing.
@InProceedings{‹Programming›24p118,
author = {Fuyuki Ishikawa and Shinobu Saito},
title = {Model-Based Framework for Continuous Adaptation and Evolution of Quantum-Classical Hybrid Systems},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {118-125},
doi = {10.1145/3660829.3660849},
year = {2024},
}
Publisher's Version
Article: prog24qp-id3-p doi:10.1145/3660829.3660849
‹Programming› Companion '24: "Containers for GUI Models ..."
Containers for GUI Models
Knut Anders Stokke, Mikhail Barash, Jaakko Järvi, Elisabeth Stenholm, and Håkon Robbestad Gylterud
(University of Bergen, Norway; University of Turku, Finland)
We present an ongoing work towards a programming approach for Graphical User Interfaces (GUIs), where structural operations on GUI data structures (such as inserting, removing, or reorganizing) can be declaratively specified and their implementations automatically generated. Concretely, we investigate how the type-theoretical notion of containers, an abstract formalism for specifying data structures, can be used for defining manipulatable GUI structures that have (multi-way) dependencies between their elements.
@InProceedings{‹Programming›24p3,
author = {Knut Anders Stokke and Mikhail Barash and Jaakko Järvi and Elisabeth Stenholm and Håkon Robbestad Gylterud},
title = {Containers for GUI Models},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {3-5},
doi = {10.1145/3660829.3660830},
year = {2024},
}
Publisher's Version
Article: prog24posters-id4-p doi:10.1145/3660829.3660830
‹Programming› Companion '24: "The Next-Gen Interactive Runtime ..."
The Next-Gen Interactive Runtime Simulator for Neural Network Programming
Sanaullah Sanaullah, Hasina Attaullah, and Thorsten Jungeblut
(Bielefeld University of Applied Sciences and Arts, Germany)
This abstract introduces a Next-Gen runtime tool research direction for neural network programming, which was presented in the Programming 2024 event. These runtime revolutionary tools allow users to conduct neural model evaluations and understand neuron behavior in run-time, neural network design, and training processes. By eliminating the need for extensive backend coding, one of the previously introduced runtime simulators called RAVSim, simplified the integration of custom datasets and enabled developers to focus on high-level tasks, accelerating advancements in artificial intelligence (AI) and computational neuroscience. With its innovative features and user-friendly interface, RAVSim supports researchers and developers in using SNNs full potential in diverse applications.
@InProceedings{‹Programming›24p8,
author = {Sanaullah Sanaullah and Hasina Attaullah and Thorsten Jungeblut},
title = {The Next-Gen Interactive Runtime Simulator for Neural Network Programming},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {8-10},
doi = {10.1145/3660829.3660833},
year = {2024},
}
Publisher's Version
Article: prog24posters-id1-p doi:10.1145/3660829.3660833
‹Programming› Companion '24: "Faster Feedback with AI? A ..."
Faster Feedback with AI? A Test Prioritization Study
Toni Mattis, Lukas Böhme, Eva Krebs, Martin C. Rinard, and Robert Hirschfeld
(Hasso Plattner Institute, Germany; University of Potsdam, Germany; Massachusetts Institute of Technology, USA)
Feedback during programming is desirable, but its usefulness depends on immediacy and relevance to the task. Unit and regression testing are practices to ensure programmers can obtain feedback on their changes; however, running a large test suite is rarely fast, and only a few results are relevant. Identifying tests relevant to a change can help programmers in two ways: upcoming issues can be detected earlier during programming, and relevant tests can serve as examples to help programmers understand the code they are editing. In this work, we describe an approach to evaluate how well large language models (LLMs) and embedding models can judge the relevance of a test to a change. We construct a dataset by applying faulty variations of real-world code changes and measuring whether the model could nominate the failing tests beforehand. We found that, while embedding models perform best on such a task, even simple information retrieval models are surprisingly competitive. In contrast, pre-trained LLMs are of limited use as they focus on confounding aspects like coding styles. We argue that the high computational cost of AI models is not always justified, and tool developers should also consider non-AI models for code-related retrieval and recommendation tasks. Lastly, we generalize from unit tests to live examples and outline how our approach can benefit live programming environments.
@InProceedings{‹Programming›24p32,
author = {Toni Mattis and Lukas Böhme and Eva Krebs and Martin C. Rinard and Robert Hirschfeld},
title = {Faster Feedback with AI? A Test Prioritization Study},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {32-40},
doi = {10.1145/3660829.3660837},
year = {2024},
}
Publisher's Version
Article: prog24progai-p03-p doi:10.1145/3660829.3660837
‹Programming› Companion '24: "Implementing Babylonian/G ..."
Implementing Babylonian/G by Putting Examples into Game Contexts
Eva Krebs, Toni Mattis, Marius Dörbandt, Oliver Schulz, Martin C. Rinard, and Robert Hirschfeld
(Hasso Plattner Institute, Germany; University of Potsdam, Germany; Massachusetts Institute of Technology, USA)
In game development, there are several ways to debug and inspect systems. These include very specialized and often visual tools, e.g. an on-demand collision box visualization. More general software engineering tools are often also available, e.g. "printf" debugging. However, default tools found in game engines are often either very specialized (like the collision box tool) or more general, but less domain-specific and spatially distant (like "printf" debugging). Thus, we wanted to create a new tool that is as universal and easy to use as "printf" debugging but supports domain-specific representations and has the possibility to be integrated closer to the actual code parts or game elements that are involved. There are pre-existing programming environments similar to our goal: Babylonian Programming systems aim to enable developers to interact with concrete information directly in the code itself. In this paper, we introduce the resulting toolset: Babylonian/G, a Babylonian-inspired plug-in for the Godot game engine. This includes a new way of thinking about Babylonian examples in a game context, in-application probes, and the possibility of adding user input to examples.
@InProceedings{‹Programming›24p68,
author = {Eva Krebs and Toni Mattis and Marius Dörbandt and Oliver Schulz and Martin C. Rinard and Robert Hirschfeld},
title = {Implementing Babylonian/G by Putting Examples into Game Contexts},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {68-72},
doi = {10.1145/3660829.3660847},
year = {2024},
}
Publisher's Version
Article: prog24px-id11-p doi:10.1145/3660829.3660847
‹Programming› Companion '24: "Examples out of Thin Air: ..."
Examples out of Thin Air: AI-Generated Dynamic Context to Assist Program Comprehension by Example
Toni Mattis, Eva Krebs, Martin C. Rinard, and Robert Hirschfeld
(Hasso Plattner Institute, Germany; University of Potsdam, Germany; Massachusetts Institute of Technology, USA)
Programmers often benefit from the availability of concrete run-time data alongside abstract source code. However, programmers need to manually exercise the program to reach an interesting state or write code that reproducibly executes a functionality with concrete inputs to be able to observe concrete data. This work aims to automate this process by leveraging generative AI. We present a framework and a preliminary Smalltalk-based prototype allowing programmers to obtain and run examples for the currently viewed source code section from a large language model. Our approach demonstrates how locally hosted LLMs can be fine-tuned and used for such a task with reasonable computational effort while minimizing common problems like hallucinations and out-of-date knowledge. The framework has direct applications in example-based live programming, where it can suggest new examples, and in learning settings where novices need to know how to use certain functionality.
@InProceedings{‹Programming›24p99,
author = {Toni Mattis and Eva Krebs and Martin C. Rinard and Robert Hirschfeld},
title = {Examples out of Thin Air: AI-Generated Dynamic Context to Assist Program Comprehension by Example},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {99-107},
doi = {10.1145/3660829.3660845},
year = {2024},
}
Publisher's Version
Article: prog24px-id9-p doi:10.1145/3660829.3660845
‹Programming› Companion '24: "Ironies of Programming Automation: ..."
Ironies of Programming Automation: Exploring the Experience of Code Synthesis via Large Language Models
Alan T. McCabe, Moa Björkman, Joel Engström, Peng Kuang, Emma Söderberg, and Luke Church
(Lund University, Sweden; University of Cambridge, United Kingdom)
The widespread availability of large language models (LLMs) has presented the opportunity for novice programmers to make use of them for the purpose of understanding and synthesising code. In this paper, we discuss a small pilot study intended to explore the user experience of doing so in a limited way, and the attitudes of a group of novice programmers towards this style of programming. We also draw parallels to the seminal work of Lisanne Bainbridge, and discuss the way in which her "ironies of automation" are also present when attempting to automate the activity of programming.
@InProceedings{‹Programming›24p12,
author = {Alan T. McCabe and Moa Björkman and Joel Engström and Peng Kuang and Emma Söderberg and Luke Church},
title = {Ironies of Programming Automation: Exploring the Experience of Code Synthesis via Large Language Models},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {12-21},
doi = {10.1145/3660829.3660835},
year = {2024},
}
Publisher's Version
Article: prog24progai-p01-p doi:10.1145/3660829.3660835
‹Programming› Companion '24: "Developers’ Perspective ..."
Developers’ Perspective on Today’s and Tomorrow’s Programming Tool Assistance: A Survey
Peng Kuang, Emma Söderberg, and Martin Höst
(Lund University, Sweden; Malmö University, Sweden)
Software development is a complex activity that needs a lot of tool assistance. Over the years there has been a lot of effort put into development of automated assistance to help with activities such as detection of issues via program analysis, or refactoring of code. Recently, the landscape of developer tool assistance is being disrupted with the entry of AI tools, such as Copilot and ChatGPT, powered via Large Language Models. Other kinds of tool assistance, for instance, gaze-driven assistance, is around the corner. What are programmers’ perceptions on tool assistance today? What do they see as good directions for the future? In this paper, we present the results of a survey where we asked developers about their programming practices, experience with program analysis, and attitudes and views on enabling technologies, like AI and eye-tracking. We received 68 replies from a diverse group of developers from 12 countries. We found that 50% of the participants use program analysis and that many participants (N=28) already use AI-enabled tools for programming. We found that our participants were positive toward AI-powered tools, neutral toward eye-tracking, and negative toward gamification. We discuss these and other findings and point out directions for future work.
@InProceedings{‹Programming›24p108,
author = {Peng Kuang and Emma Söderberg and Martin Höst},
title = {Developers’ Perspective on Today’s and Tomorrow’s Programming Tool Assistance: A Survey},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {108-116},
doi = {10.1145/3660829.3660848},
year = {2024},
}
Publisher's Version
Info
Article: prog24px-id13-p doi:10.1145/3660829.3660848
‹Programming› Companion '24: "Unanticipated Progress Indication: ..."
Unanticipated Progress Indication: Continuous Responsiveness for Courageous Exploration
Marcel Taeumel, Jens Lincke, and Robert Hirschfeld
(Hasso Plattner Institute, Germany; University of Potsdam, Germany)
Scripting environments support exploration from smaller programs to larger systems. From original Smalltalk workspaces to modern Python notebooks, such tool support is known to foster understanding. However, programmers struggle with unforeseen effects from script execution, disrupting their thoughts. Unexpectedly long response times, in particular, cause frustration due to progress info not being provided automatically for ad-hoc scripting tasks. In Smalltalk systems, experienced programmers can interrupt an unresponsive environment to look for such info manually. We propose an automatic approach for progress indication, using a watchdog that periodically scans the stack of script workers for known heuristics to then derive task identity, label, and progress metrics. Using Squeak/Smalltalk as an object-oriented, single-threaded, cooperative scripting environment, we argue that simple heuristics for list enumeration or other patterns can (1) keep users informed while (2) leaving scripts untouched and (3) mostly retaining execution performance. We believe that Unanticipated Progress Indication will encourage programmers to experiment with library interfaces and domain artifacts more often, which will reduce their cognitive load for an expedient programming experience.
@InProceedings{‹Programming›24p80,
author = {Marcel Taeumel and Jens Lincke and Robert Hirschfeld},
title = {Unanticipated Progress Indication: Continuous Responsiveness for Courageous Exploration},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {80-86},
doi = {10.1145/3660829.3660843},
year = {2024},
}
Publisher's Version
Article: prog24px-id7-p doi:10.1145/3660829.3660843
‹Programming› Companion '24: "Dear Developers, What Do You ..."
Dear Developers, What Do You Mean by Photography? (Keynote)
Nicolas Malevé
(Aarhus University, Denmark)
Machine vision has mobilised photography in unprecedented ways throughout the last decade. Classification algorithms became increasingly apt at parsing visual input, and more recent products such as Dall-e or Stable Diffusion have proved efficient in generating culturally relevant imagery. Every day, computer vision researchers engage in a practice that promises to reshape visuality and organise digital images, making them intelligible and actionable. Their work changes our ways of seeing and of imagining. Yet the field has spent little time addressing theoretically the politics and affordances of photographic mediation. In machine vision papers, photographs function in different ways. They are treated as straightforward visual ‘samples’ of the real world. They can also be used as aesthetic objects and their realism is presented as a marker of style. Further, they are conceived as self-standing documents free from the contexts from which they originated or the authors who created them. The presentation will explore these treatments of the image from the point of view of photography and aesthetic theory. In doing this, the talk will open a discussion about what an image theory relevant to computer vision scientists and programmers could be like.
@InProceedings{‹Programming›24p11,
author = {Nicolas Malevé},
title = {Dear Developers, What Do You Mean by Photography? (Keynote)},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {11-11},
doi = {10.1145/3660829.3661028},
year = {2024},
}
Publisher's Version
Article: prog24progai-key1-p doi:10.1145/3660829.3661028
‹Programming› Companion '24: "Multi-threaded OpenSmalltalk ..."
Multi-threaded OpenSmalltalk VM: Choosing a Strategy for Parallelization
Leon Matthes, Marcel Taeumel, Eliot Miranda, and Robert Hirschfeld
(Hasso Plattner Institute, Germany; University of Potsdam, Germany)
Dynamic, object-oriented programming languages are widely regarded as enjoyable and easy to use. These languages lend themselves well to exploration and very short iteration cycles and feedback loops. However, many of them have no or limited support for multithreading. Squeak, a modern Smalltalk programming environment that focuses on interactivity and programming experience, doesn't support multithreading. We discuss multiple high-level strategies employed by similar languages and runtime environments to support parallel execution. Existing research and implementations using the presented strategies are analyzed to find a good fit for the Squeak/Smalltalk ecosystem. Due to Squeak's strong focus on interactivity and programming experience, we decided for an approach with limited support for parallelization. Our focus on a straight-forward implementation is based on our observation that reduction of pause times is more important for the programming experience than a model for fully parallel execution.
@InProceedings{‹Programming›24p87,
author = {Leon Matthes and Marcel Taeumel and Eliot Miranda and Robert Hirschfeld},
title = {Multi-threaded OpenSmalltalk VM: Choosing a Strategy for Parallelization},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {87-93},
doi = {10.1145/3660829.3660846},
year = {2024},
}
Publisher's Version
Article: prog24px-id10-p doi:10.1145/3660829.3660846
‹Programming› Companion '24: "Faster Feedback with AI? A ..."
Faster Feedback with AI? A Test Prioritization Study
Toni Mattis, Lukas Böhme, Eva Krebs, Martin C. Rinard, and Robert Hirschfeld
(Hasso Plattner Institute, Germany; University of Potsdam, Germany; Massachusetts Institute of Technology, USA)
Feedback during programming is desirable, but its usefulness depends on immediacy and relevance to the task. Unit and regression testing are practices to ensure programmers can obtain feedback on their changes; however, running a large test suite is rarely fast, and only a few results are relevant. Identifying tests relevant to a change can help programmers in two ways: upcoming issues can be detected earlier during programming, and relevant tests can serve as examples to help programmers understand the code they are editing. In this work, we describe an approach to evaluate how well large language models (LLMs) and embedding models can judge the relevance of a test to a change. We construct a dataset by applying faulty variations of real-world code changes and measuring whether the model could nominate the failing tests beforehand. We found that, while embedding models perform best on such a task, even simple information retrieval models are surprisingly competitive. In contrast, pre-trained LLMs are of limited use as they focus on confounding aspects like coding styles. We argue that the high computational cost of AI models is not always justified, and tool developers should also consider non-AI models for code-related retrieval and recommendation tasks. Lastly, we generalize from unit tests to live examples and outline how our approach can benefit live programming environments.
@InProceedings{‹Programming›24p32,
author = {Toni Mattis and Lukas Böhme and Eva Krebs and Martin C. Rinard and Robert Hirschfeld},
title = {Faster Feedback with AI? A Test Prioritization Study},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {32-40},
doi = {10.1145/3660829.3660837},
year = {2024},
}
Publisher's Version
Article: prog24progai-p03-p doi:10.1145/3660829.3660837
‹Programming› Companion '24: "Implementing Babylonian/G ..."
Implementing Babylonian/G by Putting Examples into Game Contexts
Eva Krebs, Toni Mattis, Marius Dörbandt, Oliver Schulz, Martin C. Rinard, and Robert Hirschfeld
(Hasso Plattner Institute, Germany; University of Potsdam, Germany; Massachusetts Institute of Technology, USA)
In game development, there are several ways to debug and inspect systems. These include very specialized and often visual tools, e.g. an on-demand collision box visualization. More general software engineering tools are often also available, e.g. "printf" debugging. However, default tools found in game engines are often either very specialized (like the collision box tool) or more general, but less domain-specific and spatially distant (like "printf" debugging). Thus, we wanted to create a new tool that is as universal and easy to use as "printf" debugging but supports domain-specific representations and has the possibility to be integrated closer to the actual code parts or game elements that are involved. There are pre-existing programming environments similar to our goal: Babylonian Programming systems aim to enable developers to interact with concrete information directly in the code itself. In this paper, we introduce the resulting toolset: Babylonian/G, a Babylonian-inspired plug-in for the Godot game engine. This includes a new way of thinking about Babylonian examples in a game context, in-application probes, and the possibility of adding user input to examples.
@InProceedings{‹Programming›24p68,
author = {Eva Krebs and Toni Mattis and Marius Dörbandt and Oliver Schulz and Martin C. Rinard and Robert Hirschfeld},
title = {Implementing Babylonian/G by Putting Examples into Game Contexts},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {68-72},
doi = {10.1145/3660829.3660847},
year = {2024},
}
Publisher's Version
Article: prog24px-id11-p doi:10.1145/3660829.3660847
‹Programming› Companion '24: "Examples out of Thin Air: ..."
Examples out of Thin Air: AI-Generated Dynamic Context to Assist Program Comprehension by Example
Toni Mattis, Eva Krebs, Martin C. Rinard, and Robert Hirschfeld
(Hasso Plattner Institute, Germany; University of Potsdam, Germany; Massachusetts Institute of Technology, USA)
Programmers often benefit from the availability of concrete run-time data alongside abstract source code. However, programmers need to manually exercise the program to reach an interesting state or write code that reproducibly executes a functionality with concrete inputs to be able to observe concrete data. This work aims to automate this process by leveraging generative AI. We present a framework and a preliminary Smalltalk-based prototype allowing programmers to obtain and run examples for the currently viewed source code section from a large language model. Our approach demonstrates how locally hosted LLMs can be fine-tuned and used for such a task with reasonable computational effort while minimizing common problems like hallucinations and out-of-date knowledge. The framework has direct applications in example-based live programming, where it can suggest new examples, and in learning settings where novices need to know how to use certain functionality.
@InProceedings{‹Programming›24p99,
author = {Toni Mattis and Eva Krebs and Martin C. Rinard and Robert Hirschfeld},
title = {Examples out of Thin Air: AI-Generated Dynamic Context to Assist Program Comprehension by Example},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {99-107},
doi = {10.1145/3660829.3660845},
year = {2024},
}
Publisher's Version
Article: prog24px-id9-p doi:10.1145/3660829.3660845
‹Programming› Companion '24: "Ironies of Programming Automation: ..."
Ironies of Programming Automation: Exploring the Experience of Code Synthesis via Large Language Models
Alan T. McCabe, Moa Björkman, Joel Engström, Peng Kuang, Emma Söderberg, and Luke Church
(Lund University, Sweden; University of Cambridge, United Kingdom)
The widespread availability of large language models (LLMs) has presented the opportunity for novice programmers to make use of them for the purpose of understanding and synthesising code. In this paper, we discuss a small pilot study intended to explore the user experience of doing so in a limited way, and the attitudes of a group of novice programmers towards this style of programming. We also draw parallels to the seminal work of Lisanne Bainbridge, and discuss the way in which her "ironies of automation" are also present when attempting to automate the activity of programming.
@InProceedings{‹Programming›24p12,
author = {Alan T. McCabe and Moa Björkman and Joel Engström and Peng Kuang and Emma Söderberg and Luke Church},
title = {Ironies of Programming Automation: Exploring the Experience of Code Synthesis via Large Language Models},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {12-21},
doi = {10.1145/3660829.3660835},
year = {2024},
}
Publisher's Version
Article: prog24progai-p01-p doi:10.1145/3660829.3660835
‹Programming› Companion '24: "Autocorrection in Projectional ..."
Autocorrection in Projectional Editors
André L. Santos and Ângelo Mendonça
(ISCTE-IUL, Portugal)
People often mistype words when using keyboards. Word processors commonly feature autocorrection that checks for dictionary-based spelling mistakes and automatically performs text replacement after the user types a word. Programs are mostly described using text, and hence, the programmer may introduce typos when writing program identifiers (or keywords). In this paper, we describe an approach to integrate autocorrection in a projectional editor, capable of fixing program identifier typos. We implemented two modes of autocorrection as an extension of Javardise, one that resembles word processor autocorrection and a more experimental one based on the substitution of individual user keystrokes.
@InProceedings{‹Programming›24p94,
author = {André L. Santos and Ângelo Mendonça},
title = {Autocorrection in Projectional Editors},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {94-98},
doi = {10.1145/3660829.3660844},
year = {2024},
}
Publisher's Version
Article: prog24px-id8-p doi:10.1145/3660829.3660844
‹Programming› Companion '24: "Multi-threaded OpenSmalltalk ..."
Multi-threaded OpenSmalltalk VM: Choosing a Strategy for Parallelization
Leon Matthes, Marcel Taeumel, Eliot Miranda, and Robert Hirschfeld
(Hasso Plattner Institute, Germany; University of Potsdam, Germany)
Dynamic, object-oriented programming languages are widely regarded as enjoyable and easy to use. These languages lend themselves well to exploration and very short iteration cycles and feedback loops. However, many of them have no or limited support for multithreading. Squeak, a modern Smalltalk programming environment that focuses on interactivity and programming experience, doesn't support multithreading. We discuss multiple high-level strategies employed by similar languages and runtime environments to support parallel execution. Existing research and implementations using the presented strategies are analyzed to find a good fit for the Squeak/Smalltalk ecosystem. Due to Squeak's strong focus on interactivity and programming experience, we decided for an approach with limited support for parallelization. Our focus on a straight-forward implementation is based on our observation that reduction of pause times is more important for the programming experience than a model for fully parallel execution.
@InProceedings{‹Programming›24p87,
author = {Leon Matthes and Marcel Taeumel and Eliot Miranda and Robert Hirschfeld},
title = {Multi-threaded OpenSmalltalk VM: Choosing a Strategy for Parallelization},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {87-93},
doi = {10.1145/3660829.3660846},
year = {2024},
}
Publisher's Version
Article: prog24px-id10-p doi:10.1145/3660829.3660846
‹Programming› Companion '24: "Magic Markup: Maintaining ..."
Magic Markup: Maintaining Document-External Markup with an LLM
Edward Misback, Zachary Tatlock, and Steven L. Tanimoto
(University of Washington, USA)
Text documents, including programs, typically have human-readable semantic structure. Historically, programmatic access to these semantics has required explicit in-document tagging. Especially in systems where the text has an execution semantics, this means it is an opt-in feature that is hard to support properly. Today, language models offer a new method: metadata can be bound to entities in changing text using a model's human-like understanding of semantics, with no requirements on the document structure. This method expands the applications of document annotation, a fundamental operation in program writing, debugging, maintenance, and presentation. We contribute a system that employs an intelligent agent to re-tag modified programs, enabling rich annotations to automatically follow code as it evolves. We also contribute a formal problem definition, an empirical synthetic benchmark suite, and our benchmark generator. Our system achieves an accuracy of 90% on our benchmarks and can replace a document's tags in parallel at a rate of 5 seconds per tag. While there remains significant room for improvement, we find performance reliable enough to justify further exploration of applications.
@InProceedings{‹Programming›24p22,
author = {Edward Misback and Zachary Tatlock and Steven L. Tanimoto},
title = {Magic Markup: Maintaining Document-External Markup with an LLM},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {22-31},
doi = {10.1145/3660829.3660836},
year = {2024},
}
Publisher's Version
Article: prog24progai-p02-p doi:10.1145/3660829.3660836
‹Programming› Companion '24: "Property-Based Testing and ..."
Property-Based Testing and Debugging of Quantum Programs (Keynote)
Mohammad Reza Mousavi
(King’s College London, United Kingdom)
We are witnessing the increased availability of powerful quantum computing facilities as a service; also, there are promising prospects of applying quantum computing in fields such as material- and drug discovery, as well as scheduling, and optimisation. With these promising prospects comes an inherent challenge of quality assurance of complex quantum programs. Quantum programs and programming frameworks are becoming more complex and this complexity creates a gap, calling for novel and rigorous testing and debugging frameworks. In this talk, we address this gap and propose, to our knowledge, the first applications of property-based testing and automated debugging to quantum programs. (Based on joint work with: Shahin Honarvar, Raja Nagarajan, and Gabriel Pontolillo)
@InProceedings{‹Programming›24p117,
author = {Mohammad Reza Mousavi},
title = {Property-Based Testing and Debugging of Quantum Programs (Keynote)},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {117-117},
doi = {10.1145/3660829.3661031},
year = {2024},
}
Publisher's Version
Article: prog24qp-key1-p doi:10.1145/3660829.3661031
‹Programming› Companion '24: "BoaSpect: An Expressive Instrumentation ..."
BoaSpect: An Expressive Instrumentation Platform for JavaScript
Aäron Munsters, Angel Luis Scull Pupo, and Elisa Gonzalez Boix
(Vrije Universiteit Brussel, Belgium)
Instrumentation platforms facilitate the development and deployment of dynamic analyses. The state-of-the-art instrumentation platforms for JavaScript rely on different weaving approaches for instrumentation, offering different levels of analysis expressiveness. The main issue is that they are unable to observe and reason about abstract operations, i.e. operations that are not exposed as language constructs but are used within the runtime. However, abstract operations are pivotal to understanding JavaScript’s program behaviour. This paper demonstrates the importance of exposing the ToPrimitive abstract operation, which lies at the core of JavaScript’s type coercion. We introduce BoaSpect, an interpreter-based instrumentation platform for JavaScript, which provides increased expressiveness by exposing the ToPrimitive trap through the instrumentation interface. We demonstrate its potential by implementing a novel analysis in BoaSpect to identify a potential security exploit, and a taint analysis which can track information flows precisely in the presence of implicit type coercions.
@InProceedings{‹Programming›24p47,
author = {Aäron Munsters and Angel Luis Scull Pupo and Elisa Gonzalez Boix},
title = {BoaSpect: An Expressive Instrumentation Platform for JavaScript},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {47-51},
doi = {10.1145/3660829.3660839},
year = {2024},
}
Publisher's Version
Article: prog24morevms-id3-p doi:10.1145/3660829.3660839
‹Programming› Companion '24: "A Virtual Machine for Higher-Order ..."
A Virtual Machine for Higher-Order Reactors
Bjarno Oeyen, Jens Nicolay, and Wolfgang De Meuter
(Vrije Universiteit Brussel, Belgium)
We present the design of a Remus, a virtual machine for reactive (RP) programs --- signal-based programs that react automatically to changes --- that is currently under development. The design of Remus been tailored specifically for reactive programs: it has a dedicated instruction set and memory model that is compatible with the model of reactive programming. The virtual machine allows reactive programs to be evaluated without needing to compile them to native code, nor by running them on an existing (general-purpose) virtual machine that is not specific to RP. The model of the virtual machine makes it possible to reason over the various behavioural aspects of a reactive program, such as memory consumption, in a language-agnostic way. As an example, we propose a static analysis that aims to eliminate dynamic allocations that occur in dynamic reactive programs: i.e., programs where the dependencies between the signals that make up a program changes at run-time. We show that our virtual machine, supplemented by the results of the analysis, allows for (well-behaved) reactive programs to be evaluated in constant space (i.e. in bounded memory) even when dependencies change or new signals are created programmatically.
@InProceedings{‹Programming›24p52,
author = {Bjarno Oeyen and Jens Nicolay and Wolfgang De Meuter},
title = {A Virtual Machine for Higher-Order Reactors},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {52-56},
doi = {10.1145/3660829.3660840},
year = {2024},
}
Publisher's Version
Article: prog24morevms-id2-p doi:10.1145/3660829.3660840
‹Programming› Companion '24: "A Formal Foundation of Reach ..."
A Formal Foundation of Reach Capabilities
Yichen Xu and Martin Odersky
(EPFL, Switzerland)
Though being seemingly orthogonal, the scoping restrictions enforced by capture checking and mutable variables give rise to surprising challenges when they interact. To obtain a system that is both sound and expressive, the Scala capture checker introduced reach capabilities. Although the empirical evaluation shows that the system is expressive enough to capture check the Scala standard library, its soundness remains unresolved: in fact, it has known soundness issues. Unfortunately, the core calculus models neither reach capabilities nor mutable variables, so a formal foundation for them is lacking. To bridge the gap between the implementation and the theory and to gain a better understanding of the reach capabilities approach, we present System CC∘, a mild extension to System CC<:□ that formalises reach capabilities. This abstract describes the system and prospects the formal properties that should be established for it.
@InProceedings{‹Programming›24p134,
author = {Yichen Xu and Martin Odersky},
title = {A Formal Foundation of Reach Capabilities},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {134-138},
doi = {10.1145/3660829.3660851},
year = {2024},
}
Publisher's Version
Article: prog24vimpl-p0-p doi:10.1145/3660829.3660851
‹Programming› Companion '24: "A Virtual Machine for Higher-Order ..."
A Virtual Machine for Higher-Order Reactors
Bjarno Oeyen, Jens Nicolay, and Wolfgang De Meuter
(Vrije Universiteit Brussel, Belgium)
We present the design of a Remus, a virtual machine for reactive (RP) programs --- signal-based programs that react automatically to changes --- that is currently under development. The design of Remus been tailored specifically for reactive programs: it has a dedicated instruction set and memory model that is compatible with the model of reactive programming. The virtual machine allows reactive programs to be evaluated without needing to compile them to native code, nor by running them on an existing (general-purpose) virtual machine that is not specific to RP. The model of the virtual machine makes it possible to reason over the various behavioural aspects of a reactive program, such as memory consumption, in a language-agnostic way. As an example, we propose a static analysis that aims to eliminate dynamic allocations that occur in dynamic reactive programs: i.e., programs where the dependencies between the signals that make up a program changes at run-time. We show that our virtual machine, supplemented by the results of the analysis, allows for (well-behaved) reactive programs to be evaluated in constant space (i.e. in bounded memory) even when dependencies change or new signals are created programmatically.
@InProceedings{‹Programming›24p52,
author = {Bjarno Oeyen and Jens Nicolay and Wolfgang De Meuter},
title = {A Virtual Machine for Higher-Order Reactors},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {52-56},
doi = {10.1145/3660829.3660840},
year = {2024},
}
Publisher's Version
Article: prog24morevms-id2-p doi:10.1145/3660829.3660840
‹Programming› Companion '24: "Towards a DevOps Modeling ..."
Towards a DevOps Modeling Based on Context-Oriented Programming
Harumi Watanabe, Nobuhiko Ogura, and Kenji Hisazumi
(Tokai University, Japan; Tokyo City University, Japan; Sibaura Institute of Technology, Japan)
This article contributes to the initial step of applying Context-Oriented Programming to DevOps. In DevOps, we must maintain continuously. One of the critical problems in maintenance is caused by cross-cutting concerns. In recent programs, the cross-cutting concerns occur at runtime. To solve this problem, we focus on Context-Oriented Programming (COP). COP consists of layers, and it solves the runtime cross-cutting concern problem. However, the existing modeling methods are limited. In DevOps, we need a more strategic method. In the maintenance process, we must improve the software based on user data, in addition to bug fixing. This article introduces a method of DevOps modeling based on COP.
@InProceedings{‹Programming›24p6,
author = {Harumi Watanabe and Nobuhiko Ogura and Kenji Hisazumi},
title = {Towards a DevOps Modeling Based on Context-Oriented Programming},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {6-7},
doi = {10.1145/3660829.3660832},
year = {2024},
}
Publisher's Version
Article: prog24posters-id5-p doi:10.1145/3660829.3660832
‹Programming› Companion '24: "Virtual Machines: Should We ..."
Virtual Machines: Should We Keep Doing Them? (Invited Talk)
Javier Primás
(University of Buenos Aires, Argentina)
Virtual machines are software components that require high development efforts in order to obtain efficient implementations. In the past decade, the GraalVM has made it possible to cut the costs of language implementation through the use of Java as the mother of all VMs. However, a pressing question remains: Can we replicate this success in a platform that is truly open, widely available and without requiring special support from the host environment? This talk delves into the Powerlang experiment, which explores a runtime system enabling languages to operate atop JavaScript. The aim is to get the most out the JIT and GC capabilities that JS implementations provide. Rather than striving to develop the fastest VM, we investigate strategies to optimize the performance of our language within engines like V8, and explore the benefits and disadvantages of this approach.
@InProceedings{‹Programming›24p41,
author = {Javier Primás},
title = {Virtual Machines: Should We Keep Doing Them? (Invited Talk)},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {41-41},
doi = {10.1145/3660829.3661029},
year = {2024},
}
Publisher's Version
Article: prog24morevms-key1-p doi:10.1145/3660829.3661029
‹Programming› Companion '24: "Faster Feedback with AI? A ..."
Faster Feedback with AI? A Test Prioritization Study
Toni Mattis, Lukas Böhme, Eva Krebs, Martin C. Rinard, and Robert Hirschfeld
(Hasso Plattner Institute, Germany; University of Potsdam, Germany; Massachusetts Institute of Technology, USA)
Feedback during programming is desirable, but its usefulness depends on immediacy and relevance to the task. Unit and regression testing are practices to ensure programmers can obtain feedback on their changes; however, running a large test suite is rarely fast, and only a few results are relevant. Identifying tests relevant to a change can help programmers in two ways: upcoming issues can be detected earlier during programming, and relevant tests can serve as examples to help programmers understand the code they are editing. In this work, we describe an approach to evaluate how well large language models (LLMs) and embedding models can judge the relevance of a test to a change. We construct a dataset by applying faulty variations of real-world code changes and measuring whether the model could nominate the failing tests beforehand. We found that, while embedding models perform best on such a task, even simple information retrieval models are surprisingly competitive. In contrast, pre-trained LLMs are of limited use as they focus on confounding aspects like coding styles. We argue that the high computational cost of AI models is not always justified, and tool developers should also consider non-AI models for code-related retrieval and recommendation tasks. Lastly, we generalize from unit tests to live examples and outline how our approach can benefit live programming environments.
@InProceedings{‹Programming›24p32,
author = {Toni Mattis and Lukas Böhme and Eva Krebs and Martin C. Rinard and Robert Hirschfeld},
title = {Faster Feedback with AI? A Test Prioritization Study},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {32-40},
doi = {10.1145/3660829.3660837},
year = {2024},
}
Publisher's Version
Article: prog24progai-p03-p doi:10.1145/3660829.3660837
‹Programming› Companion '24: "Implementing Babylonian/G ..."
Implementing Babylonian/G by Putting Examples into Game Contexts
Eva Krebs, Toni Mattis, Marius Dörbandt, Oliver Schulz, Martin C. Rinard, and Robert Hirschfeld
(Hasso Plattner Institute, Germany; University of Potsdam, Germany; Massachusetts Institute of Technology, USA)
In game development, there are several ways to debug and inspect systems. These include very specialized and often visual tools, e.g. an on-demand collision box visualization. More general software engineering tools are often also available, e.g. "printf" debugging. However, default tools found in game engines are often either very specialized (like the collision box tool) or more general, but less domain-specific and spatially distant (like "printf" debugging). Thus, we wanted to create a new tool that is as universal and easy to use as "printf" debugging but supports domain-specific representations and has the possibility to be integrated closer to the actual code parts or game elements that are involved. There are pre-existing programming environments similar to our goal: Babylonian Programming systems aim to enable developers to interact with concrete information directly in the code itself. In this paper, we introduce the resulting toolset: Babylonian/G, a Babylonian-inspired plug-in for the Godot game engine. This includes a new way of thinking about Babylonian examples in a game context, in-application probes, and the possibility of adding user input to examples.
@InProceedings{‹Programming›24p68,
author = {Eva Krebs and Toni Mattis and Marius Dörbandt and Oliver Schulz and Martin C. Rinard and Robert Hirschfeld},
title = {Implementing Babylonian/G by Putting Examples into Game Contexts},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {68-72},
doi = {10.1145/3660829.3660847},
year = {2024},
}
Publisher's Version
Article: prog24px-id11-p doi:10.1145/3660829.3660847
‹Programming› Companion '24: "Examples out of Thin Air: ..."
Examples out of Thin Air: AI-Generated Dynamic Context to Assist Program Comprehension by Example
Toni Mattis, Eva Krebs, Martin C. Rinard, and Robert Hirschfeld
(Hasso Plattner Institute, Germany; University of Potsdam, Germany; Massachusetts Institute of Technology, USA)
Programmers often benefit from the availability of concrete run-time data alongside abstract source code. However, programmers need to manually exercise the program to reach an interesting state or write code that reproducibly executes a functionality with concrete inputs to be able to observe concrete data. This work aims to automate this process by leveraging generative AI. We present a framework and a preliminary Smalltalk-based prototype allowing programmers to obtain and run examples for the currently viewed source code section from a large language model. Our approach demonstrates how locally hosted LLMs can be fine-tuned and used for such a task with reasonable computational effort while minimizing common problems like hallucinations and out-of-date knowledge. The framework has direct applications in example-based live programming, where it can suggest new examples, and in learning settings where novices need to know how to use certain functionality.
@InProceedings{‹Programming›24p99,
author = {Toni Mattis and Eva Krebs and Martin C. Rinard and Robert Hirschfeld},
title = {Examples out of Thin Air: AI-Generated Dynamic Context to Assist Program Comprehension by Example},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {99-107},
doi = {10.1145/3660829.3660845},
year = {2024},
}
Publisher's Version
Article: prog24px-id9-p doi:10.1145/3660829.3660845
‹Programming› Companion '24: "Containers for GUI Models ..."
Containers for GUI Models
Knut Anders Stokke, Mikhail Barash, Jaakko Järvi, Elisabeth Stenholm, and Håkon Robbestad Gylterud
(University of Bergen, Norway; University of Turku, Finland)
We present an ongoing work towards a programming approach for Graphical User Interfaces (GUIs), where structural operations on GUI data structures (such as inserting, removing, or reorganizing) can be declaratively specified and their implementations automatically generated. Concretely, we investigate how the type-theoretical notion of containers, an abstract formalism for specifying data structures, can be used for defining manipulatable GUI structures that have (multi-way) dependencies between their elements.
@InProceedings{‹Programming›24p3,
author = {Knut Anders Stokke and Mikhail Barash and Jaakko Järvi and Elisabeth Stenholm and Håkon Robbestad Gylterud},
title = {Containers for GUI Models},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {3-5},
doi = {10.1145/3660829.3660830},
year = {2024},
}
Publisher's Version
Article: prog24posters-id4-p doi:10.1145/3660829.3660830
‹Programming› Companion '24: "Design of Flexible Code Block ..."
Design of Flexible Code Block Comparisons to Improve Code Review of Refactored Code
Lo Heander, Emma Söderberg, and Christofer Rydenfält
(Lund University, Sweden)
Code review occupies a significant amount of developers' work time and is an established practice in modern software development. Despite misaligments between users' goals and the code review tools and processes pointed out by recent research, the code review tooling has largely stayed the same since the early 90s. Improving these tools, even slightly, has the potential for a large impact spread out over time and the large developer community. In this paper, we use the Double Diamond design process to work together with a team of industry practitioners to find, refine, prototype, and evaluate ways to make it easier to compare refactored code blocks and find previously hard-to-see changes in them. The results show that a flexible comparison modal integrated into Gerrit could reduce the mental load of code review on refactored code. Potentially, it could also have effects on how code is written by no longer discouraging refactoring due to it complicating the review. The user interface created in this collaborative manner was also intuitive enough for all of the participants to be able to use it without any hints or instructions.
@InProceedings{‹Programming›24p57,
author = {Lo Heander and Emma Söderberg and Christofer Rydenfält},
title = {Design of Flexible Code Block Comparisons to Improve Code Review of Refactored Code},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {57-67},
doi = {10.1145/3660829.3660842},
year = {2024},
}
Publisher's Version
Article: prog24px-id6-p doi:10.1145/3660829.3660842
‹Programming› Companion '24: "Model-Based Framework for ..."
Model-Based Framework for Continuous Adaptation and Evolution of Quantum-Classical Hybrid Systems
Fuyuki Ishikawa and Shinobu Saito
(National Institute of Informatics, Japan; NTT Computer and Data Science Laboratories, Japan)
Although quantum computing has been attracting increasing attention, hardware restrictions are tight in current implementations. Intensive design exploration is therefore essential to match requirements, such as the problem scale and acceptable error rate, with potential designs to combine quantum computing and classical computing. The design decision made in this way is often fragile as it is sensitive to the problem scale as well as still evolving quantum services. We need continuous design decision, or adaptation and evolution, given changes in requirements or environments. In this paper, we present a framework for model-based engineering to support the continuous adaptation and evolution of quantum-classical hybrid systems. Modeling in our framework involves not only potential designs, but also rationale or evidence of design decision, which often requires simulation and experiments. This focus allows for tracing and analyzing whether the past decision is still valid or not, or whether there is uncertainty and we need further simulation and experiments. The usage of the framework is demonstrated with an example problem from steel manufacturing.
@InProceedings{‹Programming›24p118,
author = {Fuyuki Ishikawa and Shinobu Saito},
title = {Model-Based Framework for Continuous Adaptation and Evolution of Quantum-Classical Hybrid Systems},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {118-125},
doi = {10.1145/3660829.3660849},
year = {2024},
}
Publisher's Version
Article: prog24qp-id3-p doi:10.1145/3660829.3660849
‹Programming› Companion '24: "The Next-Gen Interactive Runtime ..."
The Next-Gen Interactive Runtime Simulator for Neural Network Programming
Sanaullah Sanaullah, Hasina Attaullah, and Thorsten Jungeblut
(Bielefeld University of Applied Sciences and Arts, Germany)
This abstract introduces a Next-Gen runtime tool research direction for neural network programming, which was presented in the Programming 2024 event. These runtime revolutionary tools allow users to conduct neural model evaluations and understand neuron behavior in run-time, neural network design, and training processes. By eliminating the need for extensive backend coding, one of the previously introduced runtime simulators called RAVSim, simplified the integration of custom datasets and enabled developers to focus on high-level tasks, accelerating advancements in artificial intelligence (AI) and computational neuroscience. With its innovative features and user-friendly interface, RAVSim supports researchers and developers in using SNNs full potential in diverse applications.
@InProceedings{‹Programming›24p8,
author = {Sanaullah Sanaullah and Hasina Attaullah and Thorsten Jungeblut},
title = {The Next-Gen Interactive Runtime Simulator for Neural Network Programming},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {8-10},
doi = {10.1145/3660829.3660833},
year = {2024},
}
Publisher's Version
Article: prog24posters-id1-p doi:10.1145/3660829.3660833
‹Programming› Companion '24: "Autocorrection in Projectional ..."
Autocorrection in Projectional Editors
André L. Santos and Ângelo Mendonça
(ISCTE-IUL, Portugal)
People often mistype words when using keyboards. Word processors commonly feature autocorrection that checks for dictionary-based spelling mistakes and automatically performs text replacement after the user types a word. Programs are mostly described using text, and hence, the programmer may introduce typos when writing program identifiers (or keywords). In this paper, we describe an approach to integrate autocorrection in a projectional editor, capable of fixing program identifier typos. We implemented two modes of autocorrection as an extension of Javardise, one that resembles word processor autocorrection and a more experimental one based on the substitution of individual user keystrokes.
@InProceedings{‹Programming›24p94,
author = {André L. Santos and Ângelo Mendonça},
title = {Autocorrection in Projectional Editors},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {94-98},
doi = {10.1145/3660829.3660844},
year = {2024},
}
Publisher's Version
Article: prog24px-id8-p doi:10.1145/3660829.3660844
‹Programming› Companion '24: "Implementing Babylonian/G ..."
Implementing Babylonian/G by Putting Examples into Game Contexts
Eva Krebs, Toni Mattis, Marius Dörbandt, Oliver Schulz, Martin C. Rinard, and Robert Hirschfeld
(Hasso Plattner Institute, Germany; University of Potsdam, Germany; Massachusetts Institute of Technology, USA)
In game development, there are several ways to debug and inspect systems. These include very specialized and often visual tools, e.g. an on-demand collision box visualization. More general software engineering tools are often also available, e.g. "printf" debugging. However, default tools found in game engines are often either very specialized (like the collision box tool) or more general, but less domain-specific and spatially distant (like "printf" debugging). Thus, we wanted to create a new tool that is as universal and easy to use as "printf" debugging but supports domain-specific representations and has the possibility to be integrated closer to the actual code parts or game elements that are involved. There are pre-existing programming environments similar to our goal: Babylonian Programming systems aim to enable developers to interact with concrete information directly in the code itself. In this paper, we introduce the resulting toolset: Babylonian/G, a Babylonian-inspired plug-in for the Godot game engine. This includes a new way of thinking about Babylonian examples in a game context, in-application probes, and the possibility of adding user input to examples.
@InProceedings{‹Programming›24p68,
author = {Eva Krebs and Toni Mattis and Marius Dörbandt and Oliver Schulz and Martin C. Rinard and Robert Hirschfeld},
title = {Implementing Babylonian/G by Putting Examples into Game Contexts},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {68-72},
doi = {10.1145/3660829.3660847},
year = {2024},
}
Publisher's Version
Article: prog24px-id11-p doi:10.1145/3660829.3660847
‹Programming› Companion '24: "BoaSpect: An Expressive Instrumentation ..."
BoaSpect: An Expressive Instrumentation Platform for JavaScript
Aäron Munsters, Angel Luis Scull Pupo, and Elisa Gonzalez Boix
(Vrije Universiteit Brussel, Belgium)
Instrumentation platforms facilitate the development and deployment of dynamic analyses. The state-of-the-art instrumentation platforms for JavaScript rely on different weaving approaches for instrumentation, offering different levels of analysis expressiveness. The main issue is that they are unable to observe and reason about abstract operations, i.e. operations that are not exposed as language constructs but are used within the runtime. However, abstract operations are pivotal to understanding JavaScript’s program behaviour. This paper demonstrates the importance of exposing the ToPrimitive abstract operation, which lies at the core of JavaScript’s type coercion. We introduce BoaSpect, an interpreter-based instrumentation platform for JavaScript, which provides increased expressiveness by exposing the ToPrimitive trap through the instrumentation interface. We demonstrate its potential by implementing a novel analysis in BoaSpect to identify a potential security exploit, and a taint analysis which can track information flows precisely in the presence of implicit type coercions.
@InProceedings{‹Programming›24p47,
author = {Aäron Munsters and Angel Luis Scull Pupo and Elisa Gonzalez Boix},
title = {BoaSpect: An Expressive Instrumentation Platform for JavaScript},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {47-51},
doi = {10.1145/3660829.3660839},
year = {2024},
}
Publisher's Version
Article: prog24morevms-id3-p doi:10.1145/3660829.3660839
‹Programming› Companion '24: "Tinyrossa: A Compiler Framework ..."
Tinyrossa: A Compiler Framework for Vertical, Verified Construction of Smalltalk VMs
Jan Vraný and Boris Shingarov
(LabWare, United Kingdom; LabWare, Canada)
We present Tinyrossa, an experimental compilation framework which is part of our larger “Smalltalk-25” program of research towards constructing dynamic-language VMs using formal methods. It performs JIT- and AoT-compilation based around OMR’s Testarossa Intermediate Language. As far as compilation per se, Tinyrossa does not make novel contributions; it is a traditional compiler that performs IL-to-IL and IL-to-Native code transformations. The main point of our work is to treat existing compilation algorithms within a mathematically-rigorous framework of executable logical specifications. Each IL-to-IL and IL-to-Native transformation is a derivation rule. Every transformation rule’s soundness is automatically justified as a theorem in “MachineArithmetic” which is our implementation of refinement calculus. The core of MachineArithmetic is a Horn solver implementing Rondon–Kawaguchi–Jhala’s “Logically-Qualified Data Types” over the Z3 SMT checker using standard algorithms. On top of this core, we mount a calculus of program refinements. This calculus endows Smalltalk objects with a defined game-theoretic semantics. We start from formalizing the Testarossa IL in a Plotkin-style small-step structural semantics. Next, Charguéraud’s logical reflection in the refinement calculus infers the Testarossa IL program’s axiomatic (Floyd–Hoare-style) verification conditions. The latter are then checked by reducing them to an SMT tautology, thus justifying the IL-to-IL transformation rule. Justifying IL-to-Native code instruction selection rules is more complex: IL semantics aside, we also need the semantics of the target processor comprising (1) the ISA semantics and (2) the relaxed memory semantics. We obtain ISA semantics by reading the ISA’s “Sail” specification. We ignore memory semantics for now. Bisimilarity between the Testarossa IL and the native code is then established using standard methods. Tinyrossa is an ongoing research effort. The complete Smalltalk source code for Tinyrossa, MachineArithmetic and all other parts of our system are available on GitHub under the MIT license. In this workshop talk, we present our current status using an example walking through the compilation of a simple method down to optimized native RISC-V code.
@InProceedings{‹Programming›24p43,
author = {Jan Vraný and Boris Shingarov},
title = {Tinyrossa: A Compiler Framework for Vertical, Verified Construction of Smalltalk VMs},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {43-46},
doi = {10.1145/3660829.3660838},
year = {2024},
}
Publisher's Version
Article: prog24morevms-id1-p doi:10.1145/3660829.3660838
‹Programming› Companion '24: "Ironies of Programming Automation: ..."
Ironies of Programming Automation: Exploring the Experience of Code Synthesis via Large Language Models
Alan T. McCabe, Moa Björkman, Joel Engström, Peng Kuang, Emma Söderberg, and Luke Church
(Lund University, Sweden; University of Cambridge, United Kingdom)
The widespread availability of large language models (LLMs) has presented the opportunity for novice programmers to make use of them for the purpose of understanding and synthesising code. In this paper, we discuss a small pilot study intended to explore the user experience of doing so in a limited way, and the attitudes of a group of novice programmers towards this style of programming. We also draw parallels to the seminal work of Lisanne Bainbridge, and discuss the way in which her "ironies of automation" are also present when attempting to automate the activity of programming.
@InProceedings{‹Programming›24p12,
author = {Alan T. McCabe and Moa Björkman and Joel Engström and Peng Kuang and Emma Söderberg and Luke Church},
title = {Ironies of Programming Automation: Exploring the Experience of Code Synthesis via Large Language Models},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {12-21},
doi = {10.1145/3660829.3660835},
year = {2024},
}
Publisher's Version
Article: prog24progai-p01-p doi:10.1145/3660829.3660835
‹Programming› Companion '24: "Developers’ Perspective ..."
Developers’ Perspective on Today’s and Tomorrow’s Programming Tool Assistance: A Survey
Peng Kuang, Emma Söderberg, and Martin Höst
(Lund University, Sweden; Malmö University, Sweden)
Software development is a complex activity that needs a lot of tool assistance. Over the years there has been a lot of effort put into development of automated assistance to help with activities such as detection of issues via program analysis, or refactoring of code. Recently, the landscape of developer tool assistance is being disrupted with the entry of AI tools, such as Copilot and ChatGPT, powered via Large Language Models. Other kinds of tool assistance, for instance, gaze-driven assistance, is around the corner. What are programmers’ perceptions on tool assistance today? What do they see as good directions for the future? In this paper, we present the results of a survey where we asked developers about their programming practices, experience with program analysis, and attitudes and views on enabling technologies, like AI and eye-tracking. We received 68 replies from a diverse group of developers from 12 countries. We found that 50% of the participants use program analysis and that many participants (N=28) already use AI-enabled tools for programming. We found that our participants were positive toward AI-powered tools, neutral toward eye-tracking, and negative toward gamification. We discuss these and other findings and point out directions for future work.
@InProceedings{‹Programming›24p108,
author = {Peng Kuang and Emma Söderberg and Martin Höst},
title = {Developers’ Perspective on Today’s and Tomorrow’s Programming Tool Assistance: A Survey},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {108-116},
doi = {10.1145/3660829.3660848},
year = {2024},
}
Publisher's Version
Info
Article: prog24px-id13-p doi:10.1145/3660829.3660848
‹Programming› Companion '24: "Design of Flexible Code Block ..."
Design of Flexible Code Block Comparisons to Improve Code Review of Refactored Code
Lo Heander, Emma Söderberg, and Christofer Rydenfält
(Lund University, Sweden)
Code review occupies a significant amount of developers' work time and is an established practice in modern software development. Despite misaligments between users' goals and the code review tools and processes pointed out by recent research, the code review tooling has largely stayed the same since the early 90s. Improving these tools, even slightly, has the potential for a large impact spread out over time and the large developer community. In this paper, we use the Double Diamond design process to work together with a team of industry practitioners to find, refine, prototype, and evaluate ways to make it easier to compare refactored code blocks and find previously hard-to-see changes in them. The results show that a flexible comparison modal integrated into Gerrit could reduce the mental load of code review on refactored code. Potentially, it could also have effects on how code is written by no longer discouraging refactoring due to it complicating the review. The user interface created in this collaborative manner was also intuitive enough for all of the participants to be able to use it without any hints or instructions.
@InProceedings{‹Programming›24p57,
author = {Lo Heander and Emma Söderberg and Christofer Rydenfält},
title = {Design of Flexible Code Block Comparisons to Improve Code Review of Refactored Code},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {57-67},
doi = {10.1145/3660829.3660842},
year = {2024},
}
Publisher's Version
Article: prog24px-id6-p doi:10.1145/3660829.3660842
‹Programming› Companion '24: "Containers for GUI Models ..."
Containers for GUI Models
Knut Anders Stokke, Mikhail Barash, Jaakko Järvi, Elisabeth Stenholm, and Håkon Robbestad Gylterud
(University of Bergen, Norway; University of Turku, Finland)
We present an ongoing work towards a programming approach for Graphical User Interfaces (GUIs), where structural operations on GUI data structures (such as inserting, removing, or reorganizing) can be declaratively specified and their implementations automatically generated. Concretely, we investigate how the type-theoretical notion of containers, an abstract formalism for specifying data structures, can be used for defining manipulatable GUI structures that have (multi-way) dependencies between their elements.
@InProceedings{‹Programming›24p3,
author = {Knut Anders Stokke and Mikhail Barash and Jaakko Järvi and Elisabeth Stenholm and Håkon Robbestad Gylterud},
title = {Containers for GUI Models},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {3-5},
doi = {10.1145/3660829.3660830},
year = {2024},
}
Publisher's Version
Article: prog24posters-id4-p doi:10.1145/3660829.3660830
‹Programming› Companion '24: "Containers for GUI Models ..."
Containers for GUI Models
Knut Anders Stokke, Mikhail Barash, Jaakko Järvi, Elisabeth Stenholm, and Håkon Robbestad Gylterud
(University of Bergen, Norway; University of Turku, Finland)
We present an ongoing work towards a programming approach for Graphical User Interfaces (GUIs), where structural operations on GUI data structures (such as inserting, removing, or reorganizing) can be declaratively specified and their implementations automatically generated. Concretely, we investigate how the type-theoretical notion of containers, an abstract formalism for specifying data structures, can be used for defining manipulatable GUI structures that have (multi-way) dependencies between their elements.
@InProceedings{‹Programming›24p3,
author = {Knut Anders Stokke and Mikhail Barash and Jaakko Järvi and Elisabeth Stenholm and Håkon Robbestad Gylterud},
title = {Containers for GUI Models},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {3-5},
doi = {10.1145/3660829.3660830},
year = {2024},
}
Publisher's Version
Article: prog24posters-id4-p doi:10.1145/3660829.3660830
‹Programming› Companion '24: "Unanticipated Progress Indication: ..."
Unanticipated Progress Indication: Continuous Responsiveness for Courageous Exploration
Marcel Taeumel, Jens Lincke, and Robert Hirschfeld
(Hasso Plattner Institute, Germany; University of Potsdam, Germany)
Scripting environments support exploration from smaller programs to larger systems. From original Smalltalk workspaces to modern Python notebooks, such tool support is known to foster understanding. However, programmers struggle with unforeseen effects from script execution, disrupting their thoughts. Unexpectedly long response times, in particular, cause frustration due to progress info not being provided automatically for ad-hoc scripting tasks. In Smalltalk systems, experienced programmers can interrupt an unresponsive environment to look for such info manually. We propose an automatic approach for progress indication, using a watchdog that periodically scans the stack of script workers for known heuristics to then derive task identity, label, and progress metrics. Using Squeak/Smalltalk as an object-oriented, single-threaded, cooperative scripting environment, we argue that simple heuristics for list enumeration or other patterns can (1) keep users informed while (2) leaving scripts untouched and (3) mostly retaining execution performance. We believe that Unanticipated Progress Indication will encourage programmers to experiment with library interfaces and domain artifacts more often, which will reduce their cognitive load for an expedient programming experience.
@InProceedings{‹Programming›24p80,
author = {Marcel Taeumel and Jens Lincke and Robert Hirschfeld},
title = {Unanticipated Progress Indication: Continuous Responsiveness for Courageous Exploration},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {80-86},
doi = {10.1145/3660829.3660843},
year = {2024},
}
Publisher's Version
Article: prog24px-id7-p doi:10.1145/3660829.3660843
‹Programming› Companion '24: "Multi-threaded OpenSmalltalk ..."
Multi-threaded OpenSmalltalk VM: Choosing a Strategy for Parallelization
Leon Matthes, Marcel Taeumel, Eliot Miranda, and Robert Hirschfeld
(Hasso Plattner Institute, Germany; University of Potsdam, Germany)
Dynamic, object-oriented programming languages are widely regarded as enjoyable and easy to use. These languages lend themselves well to exploration and very short iteration cycles and feedback loops. However, many of them have no or limited support for multithreading. Squeak, a modern Smalltalk programming environment that focuses on interactivity and programming experience, doesn't support multithreading. We discuss multiple high-level strategies employed by similar languages and runtime environments to support parallel execution. Existing research and implementations using the presented strategies are analyzed to find a good fit for the Squeak/Smalltalk ecosystem. Due to Squeak's strong focus on interactivity and programming experience, we decided for an approach with limited support for parallelization. Our focus on a straight-forward implementation is based on our observation that reduction of pause times is more important for the programming experience than a model for fully parallel execution.
@InProceedings{‹Programming›24p87,
author = {Leon Matthes and Marcel Taeumel and Eliot Miranda and Robert Hirschfeld},
title = {Multi-threaded OpenSmalltalk VM: Choosing a Strategy for Parallelization},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {87-93},
doi = {10.1145/3660829.3660846},
year = {2024},
}
Publisher's Version
Article: prog24px-id10-p doi:10.1145/3660829.3660846
‹Programming› Companion '24: "Magic Markup: Maintaining ..."
Magic Markup: Maintaining Document-External Markup with an LLM
Edward Misback, Zachary Tatlock, and Steven L. Tanimoto
(University of Washington, USA)
Text documents, including programs, typically have human-readable semantic structure. Historically, programmatic access to these semantics has required explicit in-document tagging. Especially in systems where the text has an execution semantics, this means it is an opt-in feature that is hard to support properly. Today, language models offer a new method: metadata can be bound to entities in changing text using a model's human-like understanding of semantics, with no requirements on the document structure. This method expands the applications of document annotation, a fundamental operation in program writing, debugging, maintenance, and presentation. We contribute a system that employs an intelligent agent to re-tag modified programs, enabling rich annotations to automatically follow code as it evolves. We also contribute a formal problem definition, an empirical synthetic benchmark suite, and our benchmark generator. Our system achieves an accuracy of 90% on our benchmarks and can replace a document's tags in parallel at a rate of 5 seconds per tag. While there remains significant room for improvement, we find performance reliable enough to justify further exploration of applications.
@InProceedings{‹Programming›24p22,
author = {Edward Misback and Zachary Tatlock and Steven L. Tanimoto},
title = {Magic Markup: Maintaining Document-External Markup with an LLM},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {22-31},
doi = {10.1145/3660829.3660836},
year = {2024},
}
Publisher's Version
Article: prog24progai-p02-p doi:10.1145/3660829.3660836
‹Programming› Companion '24: "Magic Markup: Maintaining ..."
Magic Markup: Maintaining Document-External Markup with an LLM
Edward Misback, Zachary Tatlock, and Steven L. Tanimoto
(University of Washington, USA)
Text documents, including programs, typically have human-readable semantic structure. Historically, programmatic access to these semantics has required explicit in-document tagging. Especially in systems where the text has an execution semantics, this means it is an opt-in feature that is hard to support properly. Today, language models offer a new method: metadata can be bound to entities in changing text using a model's human-like understanding of semantics, with no requirements on the document structure. This method expands the applications of document annotation, a fundamental operation in program writing, debugging, maintenance, and presentation. We contribute a system that employs an intelligent agent to re-tag modified programs, enabling rich annotations to automatically follow code as it evolves. We also contribute a formal problem definition, an empirical synthetic benchmark suite, and our benchmark generator. Our system achieves an accuracy of 90% on our benchmarks and can replace a document's tags in parallel at a rate of 5 seconds per tag. While there remains significant room for improvement, we find performance reliable enough to justify further exploration of applications.
@InProceedings{‹Programming›24p22,
author = {Edward Misback and Zachary Tatlock and Steven L. Tanimoto},
title = {Magic Markup: Maintaining Document-External Markup with an LLM},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {22-31},
doi = {10.1145/3660829.3660836},
year = {2024},
}
Publisher's Version
Article: prog24progai-p02-p doi:10.1145/3660829.3660836
‹Programming› Companion '24: "Tinyrossa: A Compiler Framework ..."
Tinyrossa: A Compiler Framework for Vertical, Verified Construction of Smalltalk VMs
Jan Vraný and Boris Shingarov
(LabWare, United Kingdom; LabWare, Canada)
We present Tinyrossa, an experimental compilation framework which is part of our larger “Smalltalk-25” program of research towards constructing dynamic-language VMs using formal methods. It performs JIT- and AoT-compilation based around OMR’s Testarossa Intermediate Language. As far as compilation per se, Tinyrossa does not make novel contributions; it is a traditional compiler that performs IL-to-IL and IL-to-Native code transformations. The main point of our work is to treat existing compilation algorithms within a mathematically-rigorous framework of executable logical specifications. Each IL-to-IL and IL-to-Native transformation is a derivation rule. Every transformation rule’s soundness is automatically justified as a theorem in “MachineArithmetic” which is our implementation of refinement calculus. The core of MachineArithmetic is a Horn solver implementing Rondon–Kawaguchi–Jhala’s “Logically-Qualified Data Types” over the Z3 SMT checker using standard algorithms. On top of this core, we mount a calculus of program refinements. This calculus endows Smalltalk objects with a defined game-theoretic semantics. We start from formalizing the Testarossa IL in a Plotkin-style small-step structural semantics. Next, Charguéraud’s logical reflection in the refinement calculus infers the Testarossa IL program’s axiomatic (Floyd–Hoare-style) verification conditions. The latter are then checked by reducing them to an SMT tautology, thus justifying the IL-to-IL transformation rule. Justifying IL-to-Native code instruction selection rules is more complex: IL semantics aside, we also need the semantics of the target processor comprising (1) the ISA semantics and (2) the relaxed memory semantics. We obtain ISA semantics by reading the ISA’s “Sail” specification. We ignore memory semantics for now. Bisimilarity between the Testarossa IL and the native code is then established using standard methods. Tinyrossa is an ongoing research effort. The complete Smalltalk source code for Tinyrossa, MachineArithmetic and all other parts of our system are available on GitHub under the MIT license. In this workshop talk, we present our current status using an example walking through the compilation of a simple method down to optimized native RISC-V code.
@InProceedings{‹Programming›24p43,
author = {Jan Vraný and Boris Shingarov},
title = {Tinyrossa: A Compiler Framework for Vertical, Verified Construction of Smalltalk VMs},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {43-46},
doi = {10.1145/3660829.3660838},
year = {2024},
}
Publisher's Version
Article: prog24morevms-id1-p doi:10.1145/3660829.3660838
‹Programming› Companion '24: "Towards a DevOps Modeling ..."
Towards a DevOps Modeling Based on Context-Oriented Programming
Harumi Watanabe, Nobuhiko Ogura, and Kenji Hisazumi
(Tokai University, Japan; Tokyo City University, Japan; Sibaura Institute of Technology, Japan)
This article contributes to the initial step of applying Context-Oriented Programming to DevOps. In DevOps, we must maintain continuously. One of the critical problems in maintenance is caused by cross-cutting concerns. In recent programs, the cross-cutting concerns occur at runtime. To solve this problem, we focus on Context-Oriented Programming (COP). COP consists of layers, and it solves the runtime cross-cutting concern problem. However, the existing modeling methods are limited. In DevOps, we need a more strategic method. In the maintenance process, we must improve the software based on user data, in addition to bug fixing. This article introduces a method of DevOps modeling based on COP.
@InProceedings{‹Programming›24p6,
author = {Harumi Watanabe and Nobuhiko Ogura and Kenji Hisazumi},
title = {Towards a DevOps Modeling Based on Context-Oriented Programming},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {6-7},
doi = {10.1145/3660829.3660832},
year = {2024},
}
Publisher's Version
Article: prog24posters-id5-p doi:10.1145/3660829.3660832
‹Programming› Companion '24: "A Formal Foundation of Reach ..."
A Formal Foundation of Reach Capabilities
Yichen Xu and Martin Odersky
(EPFL, Switzerland)
Though being seemingly orthogonal, the scoping restrictions enforced by capture checking and mutable variables give rise to surprising challenges when they interact. To obtain a system that is both sound and expressive, the Scala capture checker introduced reach capabilities. Although the empirical evaluation shows that the system is expressive enough to capture check the Scala standard library, its soundness remains unresolved: in fact, it has known soundness issues. Unfortunately, the core calculus models neither reach capabilities nor mutable variables, so a formal foundation for them is lacking. To bridge the gap between the implementation and the theory and to gain a better understanding of the reach capabilities approach, we present System CC∘, a mild extension to System CC<:□ that formalises reach capabilities. This abstract describes the system and prospects the formal properties that should be established for it.
@InProceedings{‹Programming›24p134,
author = {Yichen Xu and Martin Odersky},
title = {A Formal Foundation of Reach Capabilities},
booktitle = {Proc.\ ‹Programming›},
publisher = {ACM},
pages = {134-138},
doi = {10.1145/3660829.3660851},
year = {2024},
}
Publisher's Version
Article: prog24vimpl-p0-p doi:10.1145/3660829.3660851