Publish 10(1)

krono · krono · commit b541785c8a8e · 2025-03-03T16:04:38.000+01:00
diff --git a/2025/10/1/index.markdown b/2025/10/1/index.markdown
@@ -21,6 +21,8 @@ authors:
     affiliation: "University of Uppsala, Sweden"
     id: "0000-0002-4269-5408"
 
+arxiv: "2502.20522"
+file: "https://arxiv.org/pdf/2502.20522v1.pdf"
 excerpt: |
     In modern server computing, efficient CPU resource usage is often
     traded for latency. Garbage collection is a key aspect of memory
@@ -60,7 +62,7 @@ The Art, Science, and Engineering of Programming, 2025, Vol. 10, Issue 1, Articl
 Submission date: 2024-08-09  
 Publication date: 2025-02-15  
 DOI: <https://doi.org/10.22152/programming-journal.org/2026/10/1>  
-Full text: *t.b.a*  
+Full text: [PDF](https://arxiv.org/pdf/2502.20522v1.pdf)  
 
 
 ### Abstract
diff --git a/2025/10/10/index.markdown b/2025/10/10/index.markdown
@@ -21,6 +21,8 @@ authors:
     affiliation: "Lund University, Sweden"
     id: "0000-0001-7966-4560"
 
+arxiv: "2502.20540"
+file: "https://arxiv.org/pdf/2502.20540v1.pdf"
 excerpt: |
     #### Context
     Developing compilers and static analysis tools (“language tools”) is a difficult and time-consuming task.
@@ -62,7 +64,7 @@ The Art, Science, and Engineering of Programming, 2025, Vol. 10, Issue 1, Articl
 Submission date: 2024-09-30  
 Publication date: 2025-02-15  
 DOI: <https://doi.org/10.22152/programming-journal.org/2026/10/10>  
-Full text: *t.b.a*  
+Full text: [PDF](https://arxiv.org/pdf/2502.20540v1.pdf)  
 
 
 ### Abstract
diff --git a/2025/10/11/index.markdown b/2025/10/11/index.markdown
@@ -21,6 +21,8 @@ authors:
     affiliation: "Institute of Science Tokyo, Japan"
     id: "0000-0002-8837-5303"
 
+arxiv: "2502.20534"
+file: "https://arxiv.org/pdf/2502.20534v1.pdf"
 excerpt: |
     **Context:** Many systems require receiving data from multiple information sources, which act as distributed network devices that asynchronously send the latest data at their own pace to generalize various kinds of devices and connections, known as the Internet of Things (IoT). These systems often perform computations both **reactively** and **retroactively** on information received from the sources for monitoring and analytical purposes, respectively.
     
@@ -42,7 +44,7 @@ The Art, Science, and Engineering of Programming, 2025, Vol. 10, Issue 1, Articl
 Submission date: 2024-10-01  
 Publication date: 2025-02-15  
 DOI: <https://doi.org/10.22152/programming-journal.org/2026/10/11>  
-Full text: *t.b.a*  
+Full text: [PDF](https://arxiv.org/pdf/2502.20534v1.pdf)  
 
 
 ### Abstract
diff --git a/2025/10/12/index.markdown b/2025/10/12/index.markdown
@@ -21,6 +21,8 @@ authors:
     affiliation: "Institute of Science Tokyo, Japan"
     id: "0000-0002-8837-5303"
 
+arxiv: "2502.20530"
+file: "https://arxiv.org/pdf/2502.20530v1.pdf"
 excerpt: |
     **Context:** Multi-schema-version data management (MSVDM) is the database technology that simultaneously supports multiple schema versions of one database. With the technology, multiple versions of one software system can co-exist and exchange data even when the system's data structure evolves along with versions. 
     
@@ -48,7 +50,7 @@ The Art, Science, and Engineering of Programming, 2025, Vol. 10, Issue 1, Articl
 Submission date: 2024-10-01  
 Publication date: 2025-02-15  
 DOI: <https://doi.org/10.22152/programming-journal.org/2026/10/12>  
-Full text: *t.b.a*  
+Full text: [PDF](https://arxiv.org/pdf/2502.20530v1.pdf)  
 
 
 ### Abstract
diff --git a/2025/10/13/index.markdown b/2025/10/13/index.markdown
@@ -29,6 +29,8 @@ authors:
     affiliation: "CWI, Netherlands / University of Groningen, Netherlands"
     id: "0000-0001-8853-7934?"
 
+arxiv: "2502.20537"
+file: "https://arxiv.org/pdf/2502.20537v1.pdf"
 excerpt: |
     As software grows increasingly complex, the quantity and diversity of concerns to be addressed also rises. To answer this diversity of concerns, developers may end up using multiple programming languages in a single software project, a practice known as polyglot programming. This practice has gained momentum with the rise of execution platforms capable of supporting polyglot systems.
     
@@ -50,7 +52,7 @@ The Art, Science, and Engineering of Programming, 2025, Vol. 10, Issue 1, Articl
 Submission date: 2024-10-01  
 Publication date: 2025-02-15  
 DOI: <https://doi.org/10.22152/programming-journal.org/2026/10/13>  
-Full text: *t.b.a*  
+Full text: [PDF](https://arxiv.org/pdf/2502.20537v1.pdf)  
 
 
 ### Abstract
diff --git a/2025/10/14/index.markdown b/2025/10/14/index.markdown
@@ -29,6 +29,8 @@ authors:
     affiliation: "USI Lugano, Switzerland"
     id: "0000-0001-5527-5931"
 
+arxiv: "2502.20526"
+file: "https://arxiv.org/pdf/2502.20526v1.pdf"
 excerpt: |
     #### Context
     Graphics is a popular domain for teaching introductory programming in a motivating way, even in text-based programming languages.
@@ -76,7 +78,7 @@ The Art, Science, and Engineering of Programming, 2025, Vol. 10, Issue 1, Articl
 Submission date: 2024-10-01  
 Publication date: 2025-02-15  
 DOI: <https://doi.org/10.22152/programming-journal.org/2026/10/14>  
-Full text: *t.b.a*  
+Full text: [PDF](https://arxiv.org/pdf/2502.20526v1.pdf)  
 
 
 ### Abstract
diff --git a/2025/10/15/index.markdown b/2025/10/15/index.markdown
@@ -21,6 +21,8 @@ authors:
     affiliation: "EPFL, Switzerland"
     id: "0009-0005-2543-3309"
 
+arxiv: "2502.20546"
+file: "https://arxiv.org/pdf/2502.20546v1.pdf"
 excerpt: |
     Type classes are a popular tool for implementing generic algorithms and data structures without loss of efficiency, bridging the gap between parametric and ad-hoc polymorphism. Since their initial development in Haskell, they now feature prominently in numerous other industry-ready programming languages, notably including Swift, Rust, and Scala. The success of type classes hinges in large part on the compilers' ability to infer arguments to implicit parameters by means of a type-directed resolution. This technique, sometimes dubbed **implicit programming**, lets users elide information that the language implementation can deduce from the context, such as the implementation of a particular type class.
     
@@ -36,7 +38,7 @@ The Art, Science, and Engineering of Programming, 2025, Vol. 10, Issue 1, Articl
 Submission date: 2024-10-01  
 Publication date: 2025-02-15  
 DOI: <https://doi.org/10.22152/programming-journal.org/2026/10/15>  
-Full text: *t.b.a*  
+Full text: [PDF](https://arxiv.org/pdf/2502.20546v1.pdf)  
 
 
 ### Abstract
diff --git a/2025/10/2/index.markdown b/2025/10/2/index.markdown
@@ -21,6 +21,8 @@ authors:
     affiliation: "Northeastern University, USA"
     id: "0000-0001-6678-1004?"
 
+arxiv: "2502.20542"
+file: "https://arxiv.org/pdf/2502.20542v1.pdf"
 excerpt: |
     #### Context
     
@@ -86,7 +88,7 @@ The Art, Science, and Engineering of Programming, 2025, Vol. 10, Issue 1, Articl
 Submission date: 2024-08-19  
 Publication date: 2025-02-15  
 DOI: <https://doi.org/10.22152/programming-journal.org/2026/10/2>  
-Full text: *t.b.a*  
+Full text: [PDF](https://arxiv.org/pdf/2502.20542v1.pdf)  
 
 
 ### Abstract
diff --git a/2025/10/3/index.markdown b/2025/10/3/index.markdown
@@ -29,6 +29,8 @@ authors:
     affiliation: "JKU Linz, Austria"
     id: "0000-0001-7706-7308"
 
+arxiv: "2502.20536"
+file: "https://arxiv.org/pdf/2502.20536v1.pdf"
 excerpt: |
     Data structures are a cornerstone of most modern programming languages. Whether they are provided via separate libraries, built into the language specification, or as part of the language's standard library - data structures such as lists, maps, sets, or arrays provide programmers with a large repertoire of tools to deal with data. 
     Moreover, each kind of data structure typically comes with a variety of implementations that focus on scalability, memory efficiency, performance, thread-safety, or similar aspects. 
@@ -56,7 +58,7 @@ The Art, Science, and Engineering of Programming, 2025, Vol. 10, Issue 1, Articl
 Submission date: 2024-09-22  
 Publication date: 2025-02-15  
 DOI: <https://doi.org/10.22152/programming-journal.org/2026/10/3>  
-Full text: *t.b.a*  
+Full text: [PDF](https://arxiv.org/pdf/2502.20536v1.pdf)  
 
 
 ### Abstract
diff --git a/2025/10/4/index.markdown b/2025/10/4/index.markdown
@@ -21,6 +21,8 @@ authors:
     affiliation: "Vrije Universiteit Brussel, Belgium"
     id: "0000-0002-5229-5627"
 
+arxiv: "2502.20538"
+file: "https://arxiv.org/pdf/2502.20538v1.pdf"
 excerpt: |
     #### Context
     Distributed Stream Processing Frameworks (DSPFs) are popular tools for expressing real-time Big Data applications that have to handle enormous volumes of data in real time. These frameworks distribute their applications over a cluster in order to scale horizontally along with the amount of incoming data.
@@ -60,7 +62,7 @@ The Art, Science, and Engineering of Programming, 2025, Vol. 10, Issue 1, Articl
 Submission date: 2024-10-01  
 Publication date: 2025-02-15  
 DOI: <https://doi.org/10.22152/programming-journal.org/2026/10/4>  
-Full text: *t.b.a*  
+Full text: [PDF](https://arxiv.org/pdf/2502.20538v1.pdf)  
 
 
 ### Abstract
diff --git a/2025/10/5/index.markdown b/2025/10/5/index.markdown
@@ -36,6 +36,8 @@ authors:
     affiliation: "Hasso Plattner Institute, Germany / University of Potsdam, Germany"
     id: "0000-0002-4249-6003"
 
+arxiv: "2502.20535"
+file: "https://arxiv.org/pdf/2502.20535v1.pdf"
 excerpt: "Exploratory programming involves open-ended tasks. To evaluate their progress on these, programmers require frequent feedback and means to tell if the feedback they observe is bringing them in the right direction. Collecting, comparing, and sharing feedback is typically done through ad-hoc means: relying on memory to compare outputs, code comments, or manual screenshots. To approach this issue, we designed Exploriants: an extension to example-based live programming. Exploriants allows programmers to place variation points. It collects outputs captured in probes and presents them in a comparison view that programmers can customize to suit their program domain. We find that the addition of variation points and the comparisons view encourages a structured approach to exploring variations of a program. We demonstrate Exploriants' capabilities and applicability in three case studies on image processing, data processing, and game development. Given Exploriants, exploratory programmers are given a straightforward means to evaluate their progress and do not have to rely on ad-hoc methods that may introduce errors."
 ---
 Tom Beckmann[^1] [![OrcidLogo]](https://orcid.org/0000-0003-0015-1717), Joana Bergsiek[^2], Eva Krebs[^3] [![OrcidLogo]](https://orcid.org/0000-0002-9089-7784), Toni Mattis[^4] [![OrcidLogo]](https://orcid.org/0000-0001-7024-9838), Stefan Ramson[^5] [![OrcidLogo]](https://orcid.org/0000-0002-0913-1264?), Martin C. Rinard[^6] [![OrcidLogo]](https://orcid.org/0000-0001-8095-8523), and Robert Hirschfeld[^7] [![OrcidLogo]](https://orcid.org/0000-0002-4249-6003)
@@ -45,7 +47,7 @@ The Art, Science, and Engineering of Programming, 2025, Vol. 10, Issue 1, Articl
 Submission date: 2024-09-26  
 Publication date: 2025-02-15  
 DOI: <https://doi.org/10.22152/programming-journal.org/2026/10/5>  
-Full text: *t.b.a*  
+Full text: [PDF](https://arxiv.org/pdf/2502.20535v1.pdf)  
 
 
 ### Abstract
diff --git a/2025/10/6/index.markdown b/2025/10/6/index.markdown
@@ -21,6 +21,8 @@ authors:
     affiliation: "Inria - University of Côte d’Azur, France"
     id: "0000-0002-5240-1610"
 
+arxiv: "2502.20547"
+file: "https://arxiv.org/pdf/2502.20547v1.pdf"
 excerpt: |
     **Context:** Just-in-Time (JIT) compilers are able to specialize the code they generate according to a continuous profiling of the running programs. This gives them an advantage when compared to Ahead-of-Time (AoT) compilers that must choose the code to generate once for all.
     
@@ -42,7 +44,7 @@ The Art, Science, and Engineering of Programming, 2025, Vol. 10, Issue 1, Articl
 Submission date: 2024-10-01  
 Publication date: 2025-02-15  
 DOI: <https://doi.org/10.22152/programming-journal.org/2026/10/6>  
-Full text: *t.b.a*  
+Full text: [PDF](https://arxiv.org/pdf/2502.20547v1.pdf)  
 
 
 ### Abstract
diff --git a/2025/10/7/index.markdown b/2025/10/7/index.markdown
@@ -17,6 +17,8 @@ authors:
     affiliation: "Ave Maria University, USA"
     id: "0000-0002-1736-4009"
 
+arxiv: "2502.20529"
+file: "https://arxiv.org/pdf/2502.20529v1.pdf"
 excerpt: "Human-computer dialog plays a prominent role in interactions conducted at kiosks (e.g., withdrawing money from an ATM or filling your car with gas), on smartphones (e.g., installing and configuring apps), and on the web (e.g., booking a flight). Some human-computer dialogs involve an exchange of system-initiated and user-initiated actions. These dialogs are called *mixed-initiative dialogs* and sometimes also involve the pursuit of multiple interleaved sub-dialogs, which are woven together in a manner akin to coroutines. However, existing dialog-authoring languages have difficulty expressing these dialogs concisely. In this work, we improve the expressiveness of a dialog-authoring language we call *dialog specification language* (DSL), which is based on the programming concepts of functional application, partial function application, currying, and partial evaluation, by augmenting it with additional abstractions to support concise specification of task-based, mixed-initiative dialogs that resemble concurrently executing coroutines. We also formalize the semantics of DSL---the process of simplifying and staging such dialogs specified in the language. We demonstrate that dialog specifications are compressed by to a higher degree when written in DSL using the new abstractions. We also operationalize the formal semantics of DSL in a Haskell functional programming implementation. The Haskell implementation of the simplification/staging rules provides a proof of concept that the formal semantics are sufficient to implement a dialog system specified with the language. We evaluate DSL from practical (i.e., case study), conceptual (i.e., comparisons to similar systems such as VoiceXML and State Chart XML), and theoretical perspectives. The practical applicability of the new language abstractions introduced in this work is demonstrated in a case study by using it to model portions of an online food ordering system that can be concurrently staged. Our results indicate that DSL enables concise representation of dialogs composed of multiple concurrent sub-dialogs and improves the compression of dialog expressions reported in prior research. We anticipate that the extension of our language and the formalization of the semantics can facilitate concise specification and smooth implementation of task-based, mixed-initiative, human-computer dialog systems across various domains such as ATMs and interactive, voice-response systems."
 ---
 Zachary S. Rowland[^1] [![OrcidLogo]](https://orcid.org/0009-0009-3990-4617) and Saverio Perugini[^2] [![OrcidLogo]](https://orcid.org/0000-0002-1736-4009)
@@ -26,7 +28,7 @@ The Art, Science, and Engineering of Programming, 2025, Vol. 10, Issue 1, Articl
 Submission date: 2024-10-01  
 Publication date: 2025-02-15  
 DOI: <https://doi.org/10.22152/programming-journal.org/2026/10/7>  
-Full text: *t.b.a*  
+Full text: [PDF](https://arxiv.org/pdf/2502.20529v1.pdf)  
 
 
 ### Abstract
diff --git a/2025/10/8/index.markdown b/2025/10/8/index.markdown
@@ -25,8 +25,11 @@ authors:
     affiliation: "NYU Abu Dhabi, United Arab Emirates"
     id: "0000-0002-5516-1376"
 
+arxiv: "2502.20533"
+file: "https://arxiv.org/pdf/2502.20533v1.pdf"
 excerpt: |
     A gradual type system allows developers to declare certain types to be enforced by the compiler (i.e., statically typed), while leaving other types to be enforced via runtime checks (i.e., dynamically typed). When runtime checks fail, debugging gradually typed programs becomes cumbersome, because these failures may arise far from the original point where an inconsistent type assumption is made. To ease this burden on developers, some gradually typed languages produce a blame report for a given type inconsistency. However, these reports are sometimes misleading, because they might point to program points that do not need to be changed to stop the error.
+    
     To overcome the limitations of blame reports, we propose using dynamic program slicing as an alternative approach to help programmers debug run-time type errors. We describe a proof-of-concept for TypeSlicer, a tool that would present dynamic program slices to developers when a runtime check fails. We performed a Wizard-of-Oz user study to investigate how developers respond to dynamic program slices through a set of simulated interactions with TypeScript programs. This formative study shows that developers can understand and apply dynamic slice information to provide change recommendations when debugging runtime type errors.
 
 ---
@@ -37,12 +40,13 @@ The Art, Science, and Engineering of Programming, 2025, Vol. 10, Issue 1, Articl
 Submission date: 2024-09-30  
 Publication date: 2025-02-15  
 DOI: <https://doi.org/10.22152/programming-journal.org/2026/10/8>  
-Full text: *t.b.a*  
+Full text: [PDF](https://arxiv.org/pdf/2502.20533v1.pdf)  
 
 
 ### Abstract
 
 A gradual type system allows developers to declare certain types to be enforced by the compiler (i.e., statically typed), while leaving other types to be enforced via runtime checks (i.e., dynamically typed). When runtime checks fail, debugging gradually typed programs becomes cumbersome, because these failures may arise far from the original point where an inconsistent type assumption is made. To ease this burden on developers, some gradually typed languages produce a blame report for a given type inconsistency. However, these reports are sometimes misleading, because they might point to program points that do not need to be changed to stop the error.
+
 To overcome the limitations of blame reports, we propose using dynamic program slicing as an alternative approach to help programmers debug run-time type errors. We describe a proof-of-concept for TypeSlicer, a tool that would present dynamic program slices to developers when a runtime check fails. We performed a Wizard-of-Oz user study to investigate how developers respond to dynamic program slices through a set of simulated interactions with TypeScript programs. This formative study shows that developers can understand and apply dynamic slice information to provide change recommendations when debugging runtime type errors.
 
 
diff --git a/2025/10/9/index.markdown b/2025/10/9/index.markdown
@@ -25,6 +25,8 @@ authors:
     affiliation: "University of Lille - Inria - CNRS - Centrale Lille - UMR 9189 CRIStAL, France"
     id: "0000-0002-5615-6691?"
 
+arxiv: "2502.20543"
+file: "https://arxiv.org/pdf/2502.20543v1.pdf"
 excerpt: |
     Virtual Machines (VMs) combine interpreters and just-in-time (JIT) compiled code to achieve good performance.
     However, implementing different execution engines increases the cost of developing and maintaining such solutions.
@@ -47,7 +49,7 @@ The Art, Science, and Engineering of Programming, 2025, Vol. 10, Issue 1, Articl
 Submission date: 2024-09-30  
 Publication date: 2025-02-15  
 DOI: <https://doi.org/10.22152/programming-journal.org/2026/10/9>  
-Full text: *t.b.a*  
+Full text: [PDF](https://arxiv.org/pdf/2502.20543v1.pdf)  
 
 
 ### Abstract
diff --git a/2025/10/issue1/index.markdown b/2025/10/issue1/index.markdown
@@ -4,7 +4,7 @@ category: "Issues"
 order: -10001
 type: "issue"
 id: "urn:doi:10.22152%2Fprogramming-journal.org%2F2026%2F10%2Fissue1"
-date: "2025-02-27"
+date: "2025-02-28"
 ---
 DOI: <https://doi.org/10.22152/programming-journal.org/2026/10/issue1>
 
