Distributed systems

In the past few years I mainly worked on the global distribution of an international customer’s
in-house asset management platform. State replication across multiple datacenters, low-latency write access to replicated
state and write-availability during inter-datacenter network partitions were important requirements from the very beginning.
We decided to follow an event sourcing approach for persistence and developed an event replication mechanism that preserves
the causal ordering of events in event streams. For replicated state, we used a causal consistency model which is the strongest
form of consistency that is still compatible with AP of CAP. The implementation
was based on both generic and domain-specific operation-based CRDTs. I was
responsible for the complete distributed systems architecture and the development of the generic platform components.
These components evolved into the Eventuate open source project of which
I’m the founder and lead developer. Eventuate has several production deployments today.

We also used Eventuate to build distributed systems composed of microservices that collaborate via events. With Eventuate,
services can rely on consuming events from local event logs in correct causal order, without duplicates. They can also rely
on the write-availability of local event logs during network partitions and the reliable delivery of written events to
collaborators. Eventuate-based microservice systems are conceptually similar to those that can be built with
Apache Kafka and Kafka Streams but
Eventuate additionally implements a causal consistency model for systems that are distributed across multiple datacenters.

I already worked with globally distributed systems in 2004 where I developed a distributed computing solution for an
international pharmaceutical company. In their drug discovery pipeline they used several computing services, deployed at
different locations around the globe, for analyzing chemical structures regarding their biological activity. The developed
solution integrated these computing services so that researchers could run them with a single mouse click from a chemical
spreadsheet. The solution managed the reliable execution of compute jobs, persisted the results and delivered them back
to the user. It ran in production for many years and was an integral part of the drug discovery pipeline of that company.

Event sourcing

I use event sourcing since 2011 in my projects. I started to apply
that approach during the development of an electronic health record for an international customer. Event sourcing proved
to be the right choice in this project given the demanding read and write throughput requirements and the needed flexibility
to integrate with other healthcare IT systems. I later generalized that work in the Eventsourced
open source project that I developed in collaboration with Eligotech. Eventsourced adds
persistence to stateful Akka actors by writing inbound messages to a journal and replaying them on
actor restart. Eventsourced was used as persistence solution in Eligotech products.

In 2013, Eventsourced attracted the interest of Lightbend (formerly Typesafe) and we decided
to start a collaboration to build Akka Persistence which is now
the official successor of Eventsourced. I was responsible for the complete development of Akka Persistence, from initial
idea to production quality code. Akka Persistence has numerous production deployments today and is used as persistence
mechanism in the Lagom microservices framework. I also developed the
Cassandra storage plugin for Akka Persistence which is now the
officially recommended plugin for using Akka Persistence in production.

In 2014, I started to further develop the idea of Akka Persistence in the Eventuate
open source project. Among other features, Eventuate additionally supports the replication of persistent actors, up to
global scale. The replication mechanism supports a causal consistency model
which is the strongest form of consistency that is still compatible with AP of CAP. The concepts of Eventuate are closely
related to those of operation-based CRDTs which is further described in this blog post
(see also section Distributed Systems).

System integration

In 2007, I started to work on a project in which we integrated the hospital information systems of several customers
using IHE standards. Technical basis for the integration solutions was the Apache Camel
integration framework for which I developed integration components that implement actor interfaces of several
[IHE] profiles(https://www.ihe.net/) and a DSL for processing HL7 messages and
CDA documents (see also
this article for an introduction). In 2009, these extensions have
been open sourced as Open eHealth Integration Platform (IPF) of which I’m the founder and
initial lead developer. IPF has many production deployments in international customer projects today and is still actively
developed by ICW, the sponsor of the open source project. IPF is a central component of ICW’s
eHealth Suite and provides connectivity to a wide range of healthcare information
systems. Its standard compliance has been certified in several IHE Connectathons.
During my work on IPF I also became an Apache Camel committer.

To meet the increasing scalability requirements in some IPF projects I started to investigate alternatives to Apache Camel’s
routing engine. I decided to use Akka actors for message routing and processing which proved to be a
better basis for scaling IPF applications under load. The result of these efforts was the
akka-camel module that I contributed to Akka in 2011. It implements
a generic integration layer between Akka actors and Apache Camel components, including the IHE components of IPF. The
akka-camel module is still part of Akka today and has many production deployments.

I also developed other routing engine alternatives that follow a pure functional programming approach. A first attempt was
scalaz-camel which is now superseded by the camel-fs2 module of the
Streamz project which I’m still actively developing today. It allows application
developers to integrate Apache Camel components into FS2 applications
with a high-level integration DSL. Streamz also implements that DSL on top of
Akka Streams with the camel-akka module which is meanwhile the
official replacement for akka-camel and part of the Alpakka ecosystem.

Machine learning

My first contact with machine learning dates back to 1999 where I worked on
ab-initio protein structure prediction. I derived
statistical potentials i.e. potentials of mean force (PMFs)
from structures in the Protein Data Bank and used them as energy function to be
minimized during protein folding simulations. These simulations followed a simulated annealing approach combined with
further stochastic methods to escape local minima. My work extended previous work on protein backbone-atom PMFs to all-atom
PMFs with promising initial results in protein structure prediction accuracy.

I also applied machine learning in several other projects. For example, for an international pharmaceutical company I
implemented and optimized hierarchical clustering algorithms for detecting structural and behavioral patterns in chemical
compounds. These algorithms were used in the company’s drug discovery pipeline for several years in production. In a more
recent project, I trained models with data from an application’s event history to predict execution times of distributed
background jobs.

In September 2017, I decided to take a sabbatical year to go deeper into machine learning theory and practice. Besides
classical machine learning, I’m especially interested in deep learning, reinforcement learning and Bayesian statistics.
Having spent the first half of my sabbatical on fundamentals (see literature,
courses and some exercises) I’m now
investing more and more time to work on realistic use cases and datasets as well as advanced concepts for gaining
the experience needed to be a successful machine learning practitioner. I see the gained machine learning know-how as
an important complement to my software engineering experience, a combination that enables me to build more intelligent
systems with higher business value.