Tootfinder

Thread and Memory-Safe Programming with CLASS
Lu\'is Caires (Instituto Superior T\'ecnico)
https://arxiv.org/abs/2505.20848 https://

Thread and Memory-Safe Programming with CLASS
CLASS is a proof-of-concept general purpose linear programming language, flexibly supporting realistic concurrent programming idioms, and featuring an expressive linear type system ensuring that programs (1) never misuse or leak stateful resources or memory, (2) never deadlock, and (3) always terminate. The design of CLASS and the strong static guarantees of its type system originates in its Linear Logic and proposition-as-types foundations. However, instead of focusing on its theoretical found…

Choreographies as Macros
Alexander Bohosian (Department of Computer Science,Engineering University at Buffalo), Andrew K. Hirsch (Department of Computer Science,Engineering University at Buffalo)
https://arxiv.org/abs/2505.20845

Choreographies as Macros
Concurrent programming often entails meticulous pairing of sends and receives between participants to avoid deadlock. Choreographic programming alleviates this burden by specifying the system as a single program. However, there are more applications than implementations of choreographies, and developing new implementations takes a lot of time and effort. Our work uses Racket to expedite building a new choreographic language called Choret. Racket has a powerful macro system which allows Choret t…

An Efficient Implementation of Guard-Based Synchronization for an Object-Oriented Programming Language
Shucai Yao (Huawai Technologies Canada), Emil Sekerinski (McMaster University)
https://arxiv.org/abs/2505.20850

An Efficient Implementation of Guard-Based Synchronization for an Object-Oriented Programming Language
In the shared variable model of concurrency, guarded atomic actions restrict the possible interference between processes by regions of atomic execution. The guard specifies the condition for entering an atomic region. That is a convenient model for the specification and verification of concurrent programs, but has eschewed efficient execution so far. This article shows how guarded atomic actions, when attached to objects, can be implemented highly efficiently using a combination of coroutines, …

A Study of Synchronization Methods for Concurrent Size
Hen Kas-Sharir, Gal Sela, Erez Petrank
https://arxiv.org/abs/2506.16350 https://

A Study of Synchronization Methods for Concurrent Size
The size of collections, maps, and data structures in general, constitutes a fundamental property. An implementation of the size method is required in most programming environments. Nevertheless, in a concurrent environment, integrating a linearizable concurrent size introduces a noticeable overhead on all operations of the data structure, even when the size method is not invoked during the execution. In this work we present a study of synchronization methods in an attempt to improve the perfor…

GenAI-free WorldCon alternative!
Mia Tsai: on Bluesky: "ConCurrent Seattle, a one-day SFFH con intended to be an alternative program to WorldCon"
Thursday, August 14, 2025
ACT Theatre, downtown #Seattle
> My vision for ConCurrent was simple
> one day of excellent programming; have it be free to attend; run it efficiently; and never use genAI/L…

Mia Tsai (@itsamia.bsky.social)
There’s no way to ease into this news, so here it is. Today, I am announcing ConCurrent Seattle, a one-day SFFH con intended to be an alternative program to WorldCon, scheduled for Thursday, August 14, 2025, at the ACT Theatre in downtown Seattle at 700 Union Street, across from the Sheraton. 1/7

from my link log —
Idris 2: quantitative type theory in practice.
https://arxiv.org/abs/2104.00480
saved 2025-06-11 https://dotat…

Idris 2: Quantitative Type Theory in Practice
Dependent types allow us to express precisely what a function is intended to do. Recent work on Quantitative Type Theory (QTT) extends dependent type systems with linearity, also allowing precision in expressing when a function can run. This is promising, because it suggests the ability to design and reason about resource usage protocols, such as we might find in distributed and concurrent programming, where the state of a communication channel changes throughout program execution. As yet, howe…

This https://arxiv.org/abs/2505.15053 has been replaced.
initial toot: https://mastoxiv.page/@arXiv_csLO_…

Owicki--Gries Logic for Timestamp Semantics
Whereas an extension with non-interference of Hoare logic for sequential programs Owicki--Gries logic ensures the correctness of concurrent programs on strict consistency, it is unsound to weak memory models adopted by modern computer architectures and specifications of programming languages. This paper proposes a novel non-interference notion and provides concurrent program logic sound to timestamp semantics corresponding to a weak memory model that allows delays in the effects of store instru…

Choreographic Quick Changes: First-Class Location (Set) Polymorphism
Ashley Samuelson, Andrew K. Hirsch, Ethan Cecchetti
https://arxiv.org/abs/2506.10913 h…

Choreographic Quick Changes: First-Class Location (Set) Polymorphism
Choreographic programming is a promising new paradigm for programming concurrent systems where a developer writes a single centralized program that compiles to individual programs for each node. Existing choreographic languages, however, lack critical features integral to modern systems, like the ability of one node to dynamically compute who should perform a computation and send that decision to others. This work addresses this gap with $λ_{QC}$, the first typed choreographic language with \e…

Verification of the Release-Acquire Semantics
Parosh Abdulla, Elli Anastasiadi, Mohamed Faouzi Atig, Samuel Grahn
https://arxiv.org/abs/2506.08238 https://…

Verification of the Release-Acquire Semantics
The Release-Acquire (RA) semantics and its variants are some of the most fundamental models of concurrent semantics for architectures, programming languages, and distributed systems. Several steps have been taken in the direction of testing such semantics, where one is interested in whether a single program execution is consistent with a memory model. The more general verification problem, i.e., checking whether all allowed program runs are consistent with a memory model, has still not been stu…