Dr. Roland Kuhn

I am CTO and co-founder of Actyx, author of Reactive Design Patterns, a co-author of the Reactive Manifesto, and teacher of the edX course Programming Reactive Systems. Previously I led the Akka project at Lightbend. I also hold a Dr. rer. nat. in particle physics from TU München and have worked in the space industry. I spend most of my life in the central European timezone.

Talks and Presentations

If you are interested in having me speak at your conference, shoot me a mail.


For my blog please head over to github.

Actyx blog, Oct 2, 2020

Why I contributed to the Reactive Principles

Actyx blog, Sep 3, 2020

A statement on why decentralisation starts at the wrong end: Edge Native means Local — not Decentralised!

Akka blog, Feb 5, 2019

An article on Typed Supervision: why the changes?

blog, May 13, 2017

Writeup following Dagstuhl on Composing Actor Behavior

Dagstuhl, Jan 29–Feb 3, 2017

Seminar on Theory and Application of Behavioral Types, with a contribution on Composable Actor Behavior

JAXenter, Dec 8, 2016

What’s new in Akka?

blog, Nov 20, 2016

My journey towards understanding distribution

JAXenter, Nov 2, 2015

Reactive Anwendungen bauen: “Das stumpfe Kopieren von Mustern führt nicht zum Erfolg”

InfoQ, Jan 6, 2013

Creating Resilient Software with Akka (also in Japanese)

let-it-crash, Jan–Mar 2013

Blog series on Typed Channels (part one and part two)

let-it-crash, Mar 10, 2012

An often-useful post on TypedActors

Over time I contributed to the former Akka team blog “Let It Crash” (which has been converted into a newsfeed for everything around Akka in Oct 2013). You can take a look at all my posts.


Get a 39% discount using code 39kuhn.

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 (反应式设计模式).


Local-First Cooperation

Working on IT systems for factory automation at Actyx I realised that we can only achieve robust usage of our mechanical computing abilities by thinking from the other end: instead of bringing cloud services to the end users we need to start providing services directly where the end users are, without depending on the cloud. This is obvious in the factory context where availability is key, but it is also true in the larger social context. We should use what we have locally for maximal resilience and employ cloud services in a loosely coupled fashion for maximal scalability where required. See Local-First Cooperation for more details.

Reactive Foundation

Since Oct 2020 I’m a member of the Reactive Foundation’s advisory council. The Reactive Principles are well aligned with local-first cooperation and I think these two movements are well suited to go hand in hand.

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.


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) is open for enrollment; the first iteration in spring 2019 saw 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.

Social Networks

You can find me on twitter / LinkedIn / StackOverflow / github / slideshare / keybase / Skype (roland.kuhn).

Many of my recorded conference presentations are collected in this youtube playlist.


You may reach me at info@rolandkuhn.com.