‹Programming› 2024
8th International Conference on the Art, Science, and Engineering of Programming (‹Programming› 2024)
Powered by
Conference Publishing Consulting

8th International Conference on the Art, Science, and Engineering of Programming (‹Programming› 2024), March 11–15, 2024, Lund, Sweden

‹Programming› 2024 – Companion Proceedings

Contents - Abstracts - Authors


Title Page

Welcome from the Chairs
Welcome to the Companion Proceedings for the 8th International Conference on the Art, Science, and Engineering of Programming, named <Programming> 2024. The International Conference on the Art, Science, and Engineering of Programming is a conference focused on programming topics including the experience of programming. We have named it <Programming> for short. <Programming> seeks papers that advance our knowledge of programming on any relevant topic, including programming practice and experience. This eight edition followed a hybrid format, and was held in Lund, Sweden, during March 11-15, 2024. To build a community and to foster an environment where participants can exchange ideas and experiences related to practical software development, <Programming> hosts several co-located events. In the 2024 edition, there were four workshops, one tutorial, and one special track. The workshops included the 8th edition of the International Workshop on Modern Language Runtimes, Ecosystems, and VMs (MoreVMs’24), the 10th edition of the Programming Experience Workshop (PX/24), the 2nd edition of the International Workshop on the Art, Science, and Engineering of Quantum Programming (QP’24), and the 2nd edition of the Value Independence in Modern Programming Languages Workshop (VIMPL'24). The tutorial was focused on learning participants to use Nodysseus (NODY), and the special track was focused on Programming with AI (PAI'24). This companion gathers all the papers for the workshop and special track events. For the first time at <Programming> there was also a track dedicated to digital arts, however the content was focused on in person events and isn't represented in this companion. We are grateful to AOSA for sponsoring <Programming> 2024, to ACM SIGPLAN and ACM SIGSOFT for conferring the “in-cooperation-with” status, and to all from the <Programming> 2024 Organizing and Steering Committee members for the preparation of the event. We would like to express our gratitude to the authors and reviewers of all co-hosted events for their contribution. Last but not least, we thank everyone who physically or virtually participated in the conference.

‹Programming› 2024 Organization
Committee Listings

8th International Workshop on Modern Language Runtimes, Ecosystems, and VMs (MoreVMs 2024)

10th International Workshop on Programming Experience (PX/24)

2nd International Workshop on the Art, Science, and Engineering of Quantum Programming (QP 2024)
Welcome to the 2nd International Workshop on the Art, Science, and Engineering of Quantum Programming (QP 2024). The workshop, co-located with the Programming 2024 conference, took place at the University of Lund, Lund, Sweden, on March 11, 2024. Classical computing is reaching its limit. Thus, it is necessary to revolutionize the current computing form with novel computing paradigms. Towards this end, quantum computing is one of the promising computing paradigms. However, programming quantum computers differs significantly from classical computing due to novel features of quantum computing, such as superposition and entanglement. QP 2024 provided a platform for researchers and practitioners interested in the Art, Science, and Engineering of Quantum Programming and its relation with classical programming to discuss research challenges, possible solutions, and future research directions. The workshop received five submissions, three in the research papers category, and two proposals for lightning talks. All the submissions were reviewed by three program committee members. After the intensive review process, we accepted two research papers and two lighting talks. As a result, the QP 2024 program had four talks. In addition, we invited one keynote speaker, Professor Mohammad Reza Mousavi from King's College London, UK, who gave a talk on Property-Based Testing and Debugging of Quantum Programs. We would like to thank the following program committee members for their timely reviews and fruitful discussions during the review period.

2nd International Workshop on the Value Independence in Modern Programming Languages (VIMPL 2024)
Welcome to the 2024 edition of International Workshop on Value Independence in Modern Programming Languages (VIMPL 2024), held on March 12th at the University of Lund, Sweden, co-located with <Programming> 2024.


Programming Algorithmic Art (Keynote)
Benoit Baudry ORCID logo
(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.

Publisher's Version
Recent Evolution of Dart: A Pragmatic Story (Keynote)
Erik Ernst ORCID logo
(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.

Publisher's Version

Posters and Demos

Containers for GUI Models
Knut Anders Stokke ORCID logo, Mikhail BarashORCID logo, Jaakko JärviORCID logo, Elisabeth Stenholm ORCID logo, and Håkon Robbestad Gylterud ORCID logo
(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.

Publisher's Version
Towards a DevOps Modeling Based on Context-Oriented Programming
Harumi Watanabe ORCID logo, Nobuhiko Ogura ORCID logo, and Kenji Hisazumi ORCID logo
(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.

Publisher's Version
The Next-Gen Interactive Runtime Simulator for Neural Network Programming
Sanaullah Sanaullah ORCID logo, Hasina Attaullah ORCID logo, and Thorsten Jungeblut ORCID logo
(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.

Publisher's Version

Programming with AI 2024

Dear Developers, What Do You Mean by Photography? (Keynote)
Nicolas Malevé ORCID logo
(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.

Publisher's Version
Ironies of Programming Automation: Exploring the Experience of Code Synthesis via Large Language Models
Alan T. McCabe ORCID logo, Moa Björkman ORCID logo, Joel Engström ORCID logo, Peng Kuang ORCID logo, Emma Söderberg ORCID logo, and Luke Church ORCID logo
(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.

Publisher's Version
Magic Markup: Maintaining Document-External Markup with an LLM
Edward Misback ORCID logo, Zachary Tatlock ORCID logo, and Steven L. Tanimoto ORCID logo
(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.

Publisher's Version
Faster Feedback with AI? A Test Prioritization Study
Toni Mattis ORCID logo, Lukas Böhme ORCID logo, Eva Krebs ORCID logo, Martin C. RinardORCID logo, and Robert Hirschfeld ORCID logo
(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.

Publisher's Version

MoreVMs 2024

Virtual Machines: Should We Keep Doing Them? (Invited Talk)
Javier Primás ORCID logo
(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.

Publisher's Version
Retro-fitting Garbage Collection into Rust (Invited Talk)
Jacob Hughes ORCID logo
(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.

Publisher's Version
Tinyrossa: A Compiler Framework for Vertical, Verified Construction of Smalltalk VMs
Jan Vraný ORCID logo and Boris Shingarov ORCID logo
(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.

Publisher's Version
BoaSpect: An Expressive Instrumentation Platform for JavaScript
Aäron Munsters ORCID logo, Angel Luis Scull Pupo ORCID logo, and Elisa Gonzalez Boix ORCID logo
(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.

Publisher's Version
A Virtual Machine for Higher-Order Reactors
Bjarno Oeyen ORCID logo, Jens Nicolay ORCID logo, and Wolfgang De Meuter ORCID logo
(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.

Publisher's Version

PX 2024

Design of Flexible Code Block Comparisons to Improve Code Review of Refactored Code
Lo HeanderORCID logo, Emma Söderberg ORCID logo, and Christofer Rydenfält ORCID logo
(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.

Publisher's Version
Implementing Babylonian/G by Putting Examples into Game Contexts
Eva Krebs ORCID logo, Toni Mattis ORCID logo, Marius Dörbandt ORCID logo, Oliver Schulz ORCID logo, Martin C. RinardORCID logo, and Robert Hirschfeld ORCID logo
(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.

Publisher's Version
In-Line Compositional Visual Programming
Michael Homer ORCID logo
(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.

Publisher's Version
Unanticipated Progress Indication: Continuous Responsiveness for Courageous Exploration
Marcel TaeumelORCID logo, Jens Lincke ORCID logo, and Robert Hirschfeld ORCID logo
(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.

Publisher's Version
Multi-threaded OpenSmalltalk VM: Choosing a Strategy for Parallelization
Leon Matthes ORCID logo, Marcel TaeumelORCID logo, Eliot Miranda ORCID logo, and Robert Hirschfeld ORCID logo
(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.

Publisher's Version
Autocorrection in Projectional Editors
André L. Santos ORCID logo and Ângelo Mendonça ORCID logo
(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.

Publisher's Version
Examples out of Thin Air: AI-Generated Dynamic Context to Assist Program Comprehension by Example
Toni Mattis ORCID logo, Eva Krebs ORCID logo, Martin C. RinardORCID logo, and Robert Hirschfeld ORCID logo
(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.

Publisher's Version
Developers’ Perspective on Today’s and Tomorrow’s Programming Tool Assistance: A Survey
Peng Kuang ORCID logo, Emma Söderberg ORCID logo, and Martin Höst ORCID logo
(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.

Publisher's Version Info

QP 2024

Property-Based Testing and Debugging of Quantum Programs (Keynote)
Mohammad Reza Mousavi ORCID logo
(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)

Publisher's Version
Model-Based Framework for Continuous Adaptation and Evolution of Quantum-Classical Hybrid Systems
Fuyuki IshikawaORCID logo and Shinobu Saito ORCID logo
(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.

Publisher's Version
A Constraint Programming Approach for QUBO Solving and Quantum Annealing
Philippe Codognet ORCID logo
(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.

Publisher's Version

VIMPL 2024

Lightweight Affine Types for Safe Concurrency in Scala (Keynote)
Philipp Haller ORCID logo
(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.

Publisher's Version
A Formal Foundation of Reach Capabilities
Yichen Xu ORCID logo and Martin Odersky ORCID logo
(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.

Publisher's Version

proc time: 10.74