Sylvan Clebsch

Sylvan Clebsch

Auto-generated profile, based on publicly available information

Sylvan Clebsch

Microsoft Azure Research, Austin, USA

Research Focus & Metrics

Academic Career Length

4Years (2023-Present)

(Calculated once Scilit publication data is synced: current year − year of first publication + 1)

Representative Publications

View All Publications
16 October 2023 in Proceedings of the ACM on Programming Languages
Verified
Journal Article
Open access
EAEllen Arvidsson
Ellen Arvidsson
ECElias Castegren
Elias Castegren
SCSylvan Clebsch
Sylvan Clebsch
SDSophia Drossopoulou
Sophia Drossopoulou
JNJames Noble
James Noble
TWTobias Wrigstad
Tobias Wrigstad
Verona is a concurrent object-oriented programming language that organises all the objects in a program into a forest of isolated regions. Memory is managed locally for each region, so programmers can control a program's memory use by adjusting objects' partition into regions, and by setting each region's memory management strategy. A thread can only mutate (allocate, deallocate) objects within one active region---its "window of mutability". Memory management costs are localised to the active region, ensuring overheads can be predicted and controlled. Moving the mutability window between regions is explicit, so code can be executed wherever it is required, yet programs remain in control of memory use. An ownership type system based on reference capabilities enforces region isolation, controlling aliasing within and between regions, yet supporting objects moving between regions and threads. Data accesses never need expensive atomic operations, and are always thread-safe.

16 October 2023 in Proceedings of the ACM on Programming Languages
Verified
Journal Article
Open access
LCLuke Cheeseman
Luke Cheeseman
MPMatthew J. Parkinson
Matthew J. Parkinson
SCSylvan Clebsch
Sylvan Clebsch
MKMarios Kogias
Marios Kogias
SDSophia Drossopoulou
Sophia Drossopoulou
PLPaul Liétar
Paul Liétar
Expressing parallelism and coordination is central for modern concurrent programming. Many mechanisms exist for expressing both parallelism and coordination. However, the design decisions for these two mechanisms are tightly intertwined. We believe that the interdependence of these two mechanisms should be recognised and achieved through a single, powerful primitive. We are not the first to realise this: the prime example is actor model programming, where parallelism arises through fine-grained decomposition of a program’s state into actors that are able to execute independently in parallel. However, actor model programming has a serious pain point: updating multiple actors as a single atomic operation is a challenging task. We address this pain point by introducing a new concurrency paradigm: Behaviour-Oriented Concurrency (BoC). In BoC, we are revisiting the fundamental concept of a behaviour to provide a more transactional concurrency model. BoC enables asynchronously creating atomic and ordered units of work with exclusive access to a collection of independent resources. In this paper, we describe BoC informally in terms of examples, which demonstrate the advantages of exclusive access to several independent resources, as well as the need for ordering. We define it through a formal model. We demonstrate its practicality by implementing a C++ runtime. We argue its applicability through the Savina benchmark suite: benchmarks in this suite can be more compactly represented using BoC in place of Actors, and we observe comparable, if not better, performance.

10 June 2025 in Proceedings of the ACM on Programming Languages
Verified
Journal Article
Open access
FSFridtjof Peer Stoldt
Fridtjof Peer Stoldt
BBBrandt Bucher
Brandt Bucher
SCSylvan Clebsch
Sylvan Clebsch
MJMatthew A. Johnson
Matthew A. Johnson
MPMatthew J. Parkinson
Matthew J. Parkinson
TWTobias Wrigstad
Tobias Wrigstad
The ways in which the components of a program interact with each other in a concurrent setting can be considerably more complex than in a sequential setting. The core problem is unrestricted shared mutable state. An alternative to unrestricted shared mutable state is to restrict the sharing using Ownership. Ownership can turn what would have been a race into a deterministic failure that can be explained to the programmer. However, Ownership has predominantly taken place in statically typed languages. In this paper, we explore retrofitting an existing dynamically typed programming language with an ownership model based on regions. Our core aim is to provide safe concurrency, that is, the ownership model should provide deterministic dynamic failures of ownership that can be explained to the programmer. We present a dynamic model of ownership that provides ownership of groups objects called regions. We provide dynamic enforcement of our region discipline, which we have implemented in a simple interpreter that provides a Python-like syntax and semantics, and report on our first steps into integrating it into an existing language, Python.


17 October 2024
Verified
Conference Paper
Open access
SCSylvan Clebsch
Sylvan Clebsch
MBMatilda Blomqvist
Matilda Blomqvist
ECElias Castegren
Elias Castegren
MJMatthew A. Johnson
Matthew A. Johnson
MPMatthew J. Parkinson
Matthew J. Parkinson
Compilation is all about tree rewriting. In functional languages where all data is tree-shaped, tree rewriting is facilitated by pattern matching, but data immutability leads to copying for each update. In object-oriented languages like Java or C++, a standard approach is to use the visitor pattern, which increases modularization but also adds indirection and introduces boilerplate code. In this paper, we introduce Trieste -- a novel tree-rewriting DSL, combining the power of C++ with the expressivity of pattern matching. In Trieste, sequences of rewrite passes can be used to read a file to produce an abstract syntax tree (AST), convert from one AST to another, or write an AST to disk. Each pass rewrites an AST in place using subtree pattern matching, where the result is dynamically checked for well-formedness. Checking the well-formedness of trees dynamically enables flexibly changing the tree structure without having to define new data types for each intermediate representation. The well-formedness specification can also be used for scoped name binding and generating random well-formed trees for fuzz testing in addition to checking the shape of trees. Trieste has been used to build fully compliant parsers for YAML and JSON, a transpiler from YAML to JSON, and a compiler and interpreter for the policy language Rego.

8 June 2026 in Proceedings of the ACM on Programming Languages
Verified
Journal Article
Open access
FSFridtjof Stoldt
Fridtjof Stoldt
SCSylvan Clebsch
Sylvan Clebsch
MJMatthew A. Johnson
Matthew A. Johnson
MPMatthew J. Parkinson
Matthew J. Parkinson
TWTobias Wrigstad
Tobias Wrigstad
Immutability is common in the programming mainstream: deep immutability is the default in functional languages while imperative languages typically provide opt-in support for shallow immutability, usually enforced through static checking. Python is a dynamic imperative language where mutability is inherent: not only are most objects mutable, but programs themselves---modules, classes, functions---are represented by mutable objects at run-time, and libraries routinely rely on this mutability. This makes adding immutability to Python a significant challenge. This paper presents the design and implementation of deep immutability for Python. Our primary motivation is to permit multiple sub-interpreters to directly share object references, which currently requires costly serialisation. Sharing via immutability introduces a soundness challenge, as a violation could corrupt the interpreter's state. We identify numerous challenges that stem from decades of design decisions that did not anticipate immutability, and show how they can be overcome through two complementary techniques: detachment, which severs run-time links that would cause immutability to propagate too widely, and freezability, which gives objects run-time control over whether and how they may become immutable. Together, these principles form a general design pattern for deep immutability in dynamic languages. We validate our design with an implementation on CPython 3.15 that is backwards-compatible with existing programs and enables direct, zero-copy sharing of immutable objects across sub-interpreters.