hello! 👋

I'm june, a PhD student working with Marco Gaboardi at Boston University.
interested in programming languages, software verification, data privacy, concurrency, and web development.

want to get in contact? my email is: june@junewunder.com


Pipelines and Beyond: Graph Types for ADTs with Futures
Francis Rinaldi, june wunder, Arthur Azevedo de Amorim, Stefan K Muller
Principles of Programming Languages (POPL), 2024
[acm library]   [arXiv]   [artifact]


Parallel programs are frequently modeled as dependency or cost graphs; such graphs can be used to detect various bugs, or simply to visualize the parallel structure of the code. However, such graphs reflect just one particular execution and are typically constructed in a post-hoc manner. Graph types, which were introduced recently to mitigate this problem, can be assigned statically to a program by a type system and compactly represent the family of all graphs that could result from the program.

Unfortunately, prior work is restricted in its treatment of futures, an increasingly common and especially dynamic form of parallelism. In short, each instance of a future must be statically paired with a vertex name. Previously, this led to the restriction that futures could not be placed in collections or be used to construct data structures. Doing so is not a niche exercise: such structures form the basis of numerous algorithms that use forms of pipelining to achieve performance not attainable without futures. All but the most limited of these examples are out of reach of prior graph type systems.

In this paper, we propose a graph type system that allows for almost arbitrary combinations of futures and recursive data types. We do so by indexing datatypes with a type-level vertex structure, a codata structure that supplies unique vertex names to the futures in a data structure. We prove the soundness of the system in a parallel core calculus annotated with vertex structures and associated operations. Although the calculus is annotated, this is merely for convenience in defining the type system. We prove that it is possible to annotate arbitrary recursive types with vertex structures, and show using a prototype inference engine that these annotations can be inferred from OCaml-like source code for several complex parallel algorithms.

Bunched Fuzz: Sensitivity for Vector Metrics
june wunder, Arthur Azevedo de Amorim, Patrick Baillot, Marco Gaboardi
European Symposium on Programming (ESOP), 2023
[Springer]   [arXiv]   [pdf]   [pdf (rendered w/ OpenDyslexic)]


Program sensitivity measures the distance between the outputs of a program when run on two related inputs. This notion, which plays a key role in areas such as data privacy and optimization, has been the focus of several program analysis techniques introduced in recent years. Among the most successful ones, we can highlight type systems inspired by linear logic, as pioneered by Reed and Pierce in the Fuzz programming language. In Fuzz, each type is equipped with its own distance, and sensitivity analysis boils down to type checking. In particular, Fuzz features two product types, corresponding to two different notions of distance: the tensor product combines the distances of each component by adding them, while the with product takes their maximum.

In this work, we show that these products can be generalized to arbitrary Lp distances, metrics that are often used in privacy and optimization. The original Fuzz products, tensor and with, correspond to the special cases L1 and L∞. To ease the handling of such products, we extend the Fuzz type system with bunches---as in the logic of bunched implications---where the distances of different groups of variables can be combined using different Lp distances. We show that our extension can be used to reason about quantitative properties of probabilistic programs.


I spell my name "june wunder" in all lowercase. people referring to me in any context should use this stylization.