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

7th International Conference on the Art, Science, and Engineering of Programming (‹Programming› 2023), March 13–17, 2023, Tokyo, Japan

‹Programming› 2023 – Companion Proceedings

Contents - Abstracts - Authors


Title Page

Welcome from the Chairs

Committees of ‹Programming› 2023


7th International Workshop on Modern Language Runtimes, Ecosystems, and VMs (MoreVMs 2023)

9th International Workshop on Programming Experience (PX/23)
Some programming feels fun, other programming feels annoying. Why?

1st International Workshop on the Art, Science, and Engineering of Quantum Programming (QP 2023)
Classical computing is reaching its limit. Thus, there is a need to revolutionize the current form of computing. Towards this end, quantum computing is one of the promising computing paradigms. However, programming quantum computers differ significantly from classical computing due to novel features of quantum computing, such as superposition and entanglement. Thus, the art, science, and engineering of quantum programming differ from classical programming. Therefore, there is a need to initiate the discussion towards this direction and clarify and establish relations with classical programming. QP 2023, thus, provided a platform for researchers and practitioners interested in various aspects of quantum programming and its relations with classical programming to brainstorm research challenges, possible solutions, and future research directions.



SML#: Toward the Ideal Interoperability between Languages and Systems (Keynote)
Katsuhiro Ueno ORCID logo
(Niigata University, Japan)
This talk introduces the development of the SML# language and its native code compiler from the perspective of its interoperability with operating systems and foreign libraries. SML# is a statically-typed functional programming language derived from Standard ML. One of its core features is interoperability with the C language, which enables SML# programs to be used and statically-linked with C libraries. For example, SML# does not provide any builtin primitives for multithreading but allows the users to import C functions that may create threads. Even in a statically-typed language equipped with native code generation, achieving such an interoperability is not straightforward because of polymorphism and garbage collection, which are also closely related to VM-based dynamic languages. The major policy of the SML# development is to make everything “natural” without elaborating its own run-time environment; in other words, SML# regards the native platform as the target VM shared with other languages. This talk will give the design choices and internal details of the SML# compiler and run-time system, including type-directed compilation and independence of garbage collector from thread scheduler.

Publisher's Version
Programming for Deep Learning on Top of Virtual Machines (Keynote)
Zoran Vlatko Sevarac ORCID logo
(Deep Netts, Serbia)
Development of deep learning applications over a variety of new hardware opens many challenges for developers. These challenges include requirements for massive parallelization, runtime optimization and debugging of computation over a large amount of data. Virtual machines can provide solutions to these challenges, by hiding some of the underlying complexity and providing friendly programming models. This talk discusses aspects of the VMs that can be utilized and favoured for the development of deep learning applications.

Publisher's Version

Extended Abstracts

A Compact and Extensible Portable Scheme VM
Léonard Oest O'Leary and Marc Feeley ORCID logo
(Université de Montréal, Canada)
Virtual Machines (VM) tend to evolve over their life cycle with features being added regularly and a growing footprint. In a VM designed for resource constrained environments this trend deteriorates the VM's primary quality. We present how extensibility is implemented in the Ribbit Scheme VM that is both compact and portable to multiple languages. Our approach adds annotations to the VM's source code allowing the compiler to generate the source code of a specialized VM extended with user-defined primitives and with needless ones removed. This gives the best of both worlds: an extensible VM packed with all and only the features needed by the source code, while maintaining a small code footprint.

Publisher's Version
Threaded Execution as a Dual to Native Code
Dave Mason ORCID logo
(Toronto Metropolitan University, Canada)
Threaded execution has been used as a higher performance alternative to a byte-code interpreter, by utilizing hardware dispatch to replace software interpreter dispatch.
Traditional JIT code is compiled from byte-code to native code for the current machine, with an even higher performance result. Unfortunately, when debugging is required for a method, most JIT-based interpreters discard the JIT code and revert to the byte-code interpreter. Additionally, switching between interpreted code and native code requires clever trampolines to bring the models into alignment.
We describe a technique that maintains the threaded code and native code as parallel implementations of the program. This provides seamless transitions between the implementations and supports full debugging, while providing near full native execution performance.

Publisher's Version
Implementation and Evaluation of an Interpreter for Functional Reactive Programming on Small Embedded Devices
Go Suzuki ORCID logo, Takuo Watanabe ORCID logo, and Sosuke Moriguchi ORCID logo
(Tokyo Institute of Technology, Japan)
This paper reports the implementation of Emfrp-REPL, an interactive interpreter (REPL) of a functional reactive programming language for resource-constrained embedded systems. Its goal is to accelerate the prototyping and development of microcontroller-based embedded systems. The interpreter runs on small-scale embedded devices based on 32-bit microcontrollers, such as ESP32 with 520KiB size data RAM. The evaluation shows that the memory usage of Emfrp-REPL is comparable to MicroPython, and the range of its latency is narrower than MicroPython, according to microbenchmarks.

Publisher's Version
Cross-Language Interoperability of Heterogeneous Code
Athanasios Stratikopoulos ORCID logo, Florin Blanaru ORCID logo, Juan Fumero ORCID logo, Maria Xekalaki ORCID logo, Orion Papadakis ORCID logo, and Christos Kotselidis ORCID logo
(University of Manchester, UK; OctoML, USA)
In recent years, the Java Virtual Machine has evolved from a cross-ISA virtualization layer to a system that can also offer multilingual support. GraalVM paved the way to enable the interoperability of Java with other programming languages, such as Java, Python, R and even C++, that can run on top of the Truffle framework in a unified manner. Additionally, there have been numerous academic and industrial endeavors to bridge the gap between the JVM and modern heterogeneous hardware resources. All these efforts beacon the opportunity to use the JVM as a unified system that enables interoperability between multiple programming languages and multiple heterogeneous hardware resources.
In this paper, we focus on the interoperability of code that accelerates applications on heterogeneous hardware with multiple programming languages. To realize that concept, we employ TornadoVM, a state-of-the-art software for enabling various JDK distributions to exploit hardware acceleration. Although TornadoVM can transparently generate heterogeneous code at runtime, there are several challenges that hinder the portability of the generated code to other programming languages and systems. Therefore, we analyze all challenges and propose a set of modifications at the compiler and runtime levels to constitute Java as a prototyping language for the generation of heterogeneous code that can be used by other programming languages and systems.

Publisher's Version


Clerk: Moldable Live Programming for Clojure
Martin Kavalar ORCID logo, Philippa Markovics ORCID logo, and Jack Rusher ORCID logo
(Nextjournal, Germany; Nextjournal, Austria)
Clerk is an open source Clojure programmer’s assistant that builds upon the traditions of interactive and literate programming to provide a holistic moldable development environment. Clerk layers static analysis, incremental computation, and rich browser-based graphical presentations on top of a Clojure programmers familiar toolkit to enhance their workflow.

Publisher's Version Info
Five Futures with AI Coding Agents
Steven L. Tanimoto ORCID logo
(University of Washington, USA)
Many computer programmers are beginning to use computational agents to help them develop software. This article raises questions about the nature of programmer-to-agent relationships. The author's intent is to foster thought that will help human programmers best prepare for such relationships and perhaps design the relationships, ultimately keeping their jobs and improving their programming experience.

Publisher's Version
Multiple-Representation Visual Compositional Dataflow Programming
Michael Homer ORCID logo
(Victoria University of Wellington, New Zealand)
Many tasks that end users want to accomplish with a computer program are fundamentally data-flow transformations, and both visual and textual programming systems have been created to fill this need, but these are often inflexible, unapproachable, or cumbersome, satisfying a niche at one stage of the process but limited at others. An approach that suits one part of the program, or one time in its development, may be confounding at another, but the user is stuck with both the constructive and obstructive aspects of a tool's chosen paradigm throughout. Much of this difficulty can be removed by enabling the cohabitation of multiple editing paradigms in a single program for the user to choose how to tackle the current point in the process - and change their mind. We present a new data-flow programming environment where the same program, or parts of the same program, can be viewed and edited as linear text, a node-and-wire graph representation, or a two-dimensional grid layout, and the correspondence between these representations is made clear through a continuous visual identity for each part of the program.

Publisher's Version
My Space, Our Space, Their Space: A First Glance at Developers’ Experience of Spaces
Luke Church ORCID logo, Emma Söderberg ORCID logo, and Martin Höst ORCID logo
(Lund University, Sweden)
We report on an investigation into the nature of the experience that developers have with the spaces in which they work and live based on the reflections of the authors. We describe a few aspects of the structure of developers' experience around the malleability, ownership and control of the spaces and the emotions they induce, and consider what this may mean for future research.

Publisher's Version
Object-Centric Time-Travel Debugging: Exploring Traces of Objects
Christoph Thiede ORCID logo, Marcel TaeumelORCID logo, and Robert Hirschfeld ORCID logo
(University of Potsdam, Germany; Hasso Plattner Institute, Germany)
Traditional behavior-centric debuggers are organized around an extensive call stack, making it hard for programmers to navigate and explore large programs. We present object traces, a novel, object-centric approach to time-travel debugging that enables programmers to directly interact with recorded states of objects and explore their evolution in a simplified call tree. Our approach allows programmers to send messages to the object trace to ask questions of different granularity, from single variable values to custom representations of object graphs. We demonstrate practicability by applying it to the TraceDebugger, a time-travel debugger for Squeak/Smalltalk. We examine the practical opportunities and limitations of object traces and suggest directions for future work.

Publisher's Version
Probe Log: Visualizing the Control Flow of Babylonian Programming
Eva Krebs ORCID logo, Patrick Rein ORCID logo, Joana Bergsiek ORCID logo, Lina Urban ORCID logo, and Robert HirschfeldORCID logo
(Hasso Plattner Institute, Germany; University of Potsdam, Germany)
Code itself is abstract, which makes it often difficult to understand -- sometimes even by the programmers that wrote it. When working with or thinking about code, programmers thus often resort to concrete values and execution traces to make the abstract more tangible. Such approaches like exploration scripts in a workspace or unit tests of a test suite are already very helpful, but still lack a convenient conceptual and technical integration into core development tools, leaving such examples and the code they refer to too far apart. Example-based programming like Babylonian Programming aims at offering the benefits of concrete, live examples directly in program editors, interleaved with the code it supports, to shorten feedback loops and reduce the need for context switches coming with changing tools. However, Babylonian Programming and its tools currently focus on a local perspective on code exploration, but do not yet extend to messages sent outside a particular unit of code and with that do not yet directly support feedback on more dynamic properties of a running program / system. We developed Probe Log, a Babylonian Programming tool that extends the benefits of example-based programming to scenarios that span across multiple procedures. It provides a linear view on the dynamics of evolving examples beyond a local perspective.

Publisher's Version
Programmer Stories, Stories for Programmers: Exploring Storytelling in Software Development
Paul Wuilmart ORCID logo, Emma Söderberg ORCID logo, and Martin Höst ORCID logo
(KnowIt Dataunit, Sweden; Lund University, Sweden)
Developers need to comprehend new code on a regular basis; a demanding task that gets complicated as projects grow in complexity and size. To help developers, documentation is typically added in the form of code comments, design documents, system documents, to name a few examples. Despite all these different kinds of documentation code base comprehension is still challenging and there is room for further exploration of assistance in this space.
In this paper, we explore storytelling as a strategy to assist developers in comprehending a code base, by exploring attachment of stories to developer tasks. We carry out an exploratory study using a design science based research structure with three iterations with feedback from four practitioners working at a consultancy company. We find that our participants typically miss information about rationale and alternatives explored in the documentation, and resort to getting this information from other developers. When asked to write their own stories for tasks our participants sought to add this missing information, but overall found story-writing challenging. We further saw that stories on task-level presents challenges connected to exposure of personal information and integration. We make recommendations for future designs in this space based on our results and list a couple of interesting directions for future work.

Publisher's Version
ReactCOP Supporting Layer Parameter Management for Front-End Web Applications
Hiroki Hashimoto ORCID logo, Ikuta Tanigawa ORCID logo, Nobuhiko Ogura ORCID logo, and Harumi Watanabe ORCID logo
(Tokai University, Japan; Change Vision, Japan; Tokyo City University, Japan)
In modern software, including web applications, context-dependent behavior is one of the most important features. Context-oriented programming (COP) is a suitable programming technique for developing such software. However, we often need to work on handling parameter values in layers. This problem which we experience during the development of web application means inconvenience in setting parameters by each layer. We call it "layer parameter problem." Especially front-end web applications use a component-based approach with a DOM tree, making the layer parameter problem more complicated because they cannot handle COPs in class-in-layer and layer-in-class models. We propose ReactCOP, an implementation of an idea that applies COP to React, one of the front-end web application libraries. ReactCOP solves the parameter problem on a layer-in-component model. As the solution to this problem, we present Layer Parameter Management that dynamically switches values in a variable within a layer. In this paper, we propose ReactCOP with Layer Parameter Management. Finally, we investigate our proposed approach through two case studies.

Publisher's Version
Resurrecting Score11 in Siren: What Ever Happened to the 1980s Score Languages?
Stephen Travis Pope ORCID logo
(FASTLab, USA; HeavenEverywhereMedia, USA)
This paper describes a “software archaeology” project in which a new interpreter was created for the Score11 music representation, a popular 1980s music input language that was frequently used with the Music11 non-real-time software sound synthesis package. The new version runs within the Smalltalk-based Siren system, a library of software classes for music representation, algorithmic composition and live interactive performance. The project background is given, and the port of Score11 to the Siren environment is described and evaluated.

Publisher's Version Video Info



Static Analysis for Quantum Software Correctness and Reliability (Keynote)
Jianjun Zhao ORCID logo
(Kyushu University, Japan)
Software correctness and reliability have been central issues in classical computing for decades. Researchers have developed a wide range of approaches to these problems, but few have been to date for quantum computing. In this talk, I consider two different static analysis approaches to solving quantum software correctness and reliability problems: pattern-based bug detection and entanglement analysis. I will overview how these approaches work and conclude by discussing the challenges they face moving forward.

Publisher's Version

Full Papers

Scaling W State Circuits in the qudit Clifford Hierarchy
Lia Yeh ORCID logo
(University of Oxford, UK; Quantinuum, UK)
We identify a novel qudit gate which we refer to as the (Z)1/d gate. This is an alternate generalization of the qutrit T gate to any odd prime dimension d, in the dth level of the Clifford hierarchy. Using this gate which is efficiently realizable fault-tolerantly should a certain conjecture hold, we deterministically construct in the Clifford+(Z)1/d gate set, d-qubit W states in the qudit { | 0 ⟩ , | 1 ⟩ } subspace. For qutrits, we show deterministic and fault-tolerant constructions for the three-qubit W state with T count three, for the six-qubit W state, and for any power-of-three-qubit W state.
Furthermore, we adapt these constructions to recursively scale the W state size to arbitrary size N, in O(N) gate count and O(log N) depth. This is moreover deterministic for any size qubit W state, and for any prime d-dimensional qudit W state, size a power of d.
For these purposes, we devise constructions of the | 0 ⟩ -controlled Pauli X gate and the controlled Hadamard gate in any prime qudit dimension. These decompositions, for which exact synthesis is unknown in Clifford+T for d > 3, may be of independent interest.

Publisher's Version
Symbolic Quantum Programming for Supporting Applications of Quantum Computing Technologies
Jarosław Adam Miszczak ORCID logo
(Institute of Theoretical and Applied Informatics at Polish Academy of Sciences, Poland)
The goal of this paper is to deliver the overview of the current state of the art, provide experience report on developing quantum software tools, and outline the perspective for developing quantum programming tools supporting symbolic programming for the needs of quantum computing technologies. The main focus of this paper is on quantum computing technologies, as they can in the most direct way benefit from developing tools enabling the symbolic manipulation of quantum circuits and providing software tools for creating, optimizing, and testing quantum programs. We deliver a short survey of the most popular approaches in the field of quantum software development, pointing their strengths and weaknesses. This helps to formulate a list of desirable characteristics which should be included in quantum computing frameworks. Next, we describe a software architecture and its preliminary implementation supporting the development of quantum programs using symbolic approach, encouraging the functional programming paradigm, and, at the same, time enabling the integration with high-performance and cloud computing. The described software consists of several packages developed to address different needs, but nevertheless sharing common design concepts. We also outline how the presented approach could be used in tasks in quantum software engineering: quantum software testing and quantum circuit construction.

Publisher's Version

Position Papers

Capturing Qubit Decoherence through Paraconsistent Transition Systems
Luís Soares BarbosaORCID logo and Alexandre MadeiraORCID logo
(University of Minho, Portugal; University of Aveiro, Portugal)
This position paper builds on the authors' previous work on paraconsistent transition systems to propose a modelling framework for quantum circuits with explicit representation of decoherence.

Publisher's Version
Model-Driven Quantum Federated Learning (QFL)
Armin Moin ORCID logo, Atta Badii ORCID logo, and Moharram Challenger ORCID logo
(TU Munich, Germany; University of Antwerp, Belgium; University of Reading, UK; Flanders Make, Belgium)
Recently, several studies have proposed frameworks for Quantum Federated Learning (QFL). For instance, the Google TensorFlow Quantum (TFQ) and TensorFlow Federated (TFF) libraries have been deployed for realizing QFL. However, developers, in the main, are not as yet familiar with Quantum Computing (QC) libraries and frameworks. A Domain-Specific Modeling Language (DSML) that provides an abstraction layer over the underlying QC and Federated Learning (FL) libraries would be beneficial. This could enable practitioners to carry out software development and data science tasks efficiently while deploying the state of the art in Quantum Machine Learning (QML). In this position paper, we propose extending existing domain-specific Model-Driven Engineering (MDE) tools for Machine Learning (ML) enabled systems, such as MontiAnna, ML-Quadrat, and GreyCat, to support QFL.

Publisher's Version
Towards Reliable Distributed Quantum Computing on Quantum Interconnects
Ryo Wakizaka ORCID logo
(Kyoto University, Japan)
Quantum interconnects (QuICs), which connect multiple quantum devices to build distributed quantum systems, are essential for large-scale quantum information processing. While various software tools have been developed to analyze quantum programs running on QuICs, there are very few frameworks for formal reasoning about them on actual quantum devices. The lack of such tools may make distributed systems unreliable because of the complicated behavior of concurrent quantum processes and the physical constraints of quantum devices. This paper discusses the need for an infrastructure, including a distributed quantum programming language, to realize reliable distributed quantum computing.

Publisher's Version

proc time: 6.16