Projects
Amaru
I work on Amaru, a Cardano consensus node in Rust.
A second implementation is only as good as the tests one can run against it, so I spend
most of my time on deterministic simulation of consensus and networking, including the
pure-stage runtime.
Swarm protocols
With Alceste Scalas, Emilio Tuosto, Hernán Melgratti, Florian Furbach, Lucas Clorius and others I study compositional design and verification of swarm and local-first protocols (ECOOP, PLF, PLAID). The aim is a protocol one can implement, compose, and test without a coordinating cloud.
Local-First Cooperation
Working on factory automation at Actyx I concluded that robust systems have to start where the users are. In a factory that is a matter of availability; the same reasoning applies more generally. We should use what we have locally and treat the cloud as a loosely coupled extra. Actyx as a company is finished; the research continues above. The older writeup is in the archived repository.
Reactive Streams
I am honored to be part of the effort of standardizing mechanisms for implementing asynchronous and non-blocking stream handling on the JVM: Reactive Streams. The focus of this project is to define interfaces for transferring data items across an asynchronous boundary—be that a network connection or between CPU cores—in a fashion that includes flow control, does not require unbounded buffering and can be efficiently implemented in different languages or based on different execution engines.
This means that implementations are interoperable and users can pick and choose the most appropriate technology for each part of their application while still enjoying asynchrony and flow control across all components.
Books
Probably of least interest to the general public — but dear to my heart — is my doctoral thesis.
Reactive Design Patterns
More relevant is that I published Reactive Design Patterns at Manning, with contributions from Jamie Allen and Brian Hanafee. This book focuses on the design philosophy behind reactive systems — demonstrated with examples using the Akka toolkit and others — and illustrates common design patterns around message passing, supervision and fault tolerance, scalability and testing. The book has also been translated to Polish and Chinese (反应式设计模式).
Teaching
Principles of Reactive Programming
This Coursera course (meanwhile deactivated, see this screenshot) had more than 120,000 enrollments in its first two iterations, starting in Nov 2013 and Apr 2015, and it is being rerun as part of the Scala Center, see below. I was co-teaching this course with Martin Odersky (creator of the Scala programming language) and Erik Meijer (creator of the Rx.NET reactive streams framework). Martin covered monads, mutability and FRP, Erik taught futures and Rx, and I covered actors, supervision and distribution using Akka.
Programming Reactive Systems
This edX course (also available on Coursera) first ran in spring 2019 with 4'300 enrollments. Besides four weeks on reactive system design and actors it comprises one week on asynchronous computation using Futures (taught by Julien Richard-Foy) and two weeks on bounded processing of unbounded data streams (taught by Konrad Malawski). The course uses Scala & Akka as an example implementation of a reactive systems toolkit, in particular one week on the new Akka Typed module for statically verified actor interactions, and Akka Streams as a Reactive Streams implementation.
