Manuel Bernhardt

Macbook Pro Insomnia

Thu, 24 Jul 2025 20:38:38 +0000

Update (01.08.2025): fixed broken link, typo, clarified problematic behaviour

For a number of years now I have a MacBook Pro Silicon M1 Max. It worked beautifully.

Then, seemingly out of nowhere, I started noticing that the battery drained over night when I left the notebook somewhere, not connected to power. This got worse and worse, up until the point that I’ve had enough of it and I started doing some research.

200 dives and counting

Thu, 03 Apr 2025 21:32:09 +0200

200th dive

I started diving when I was 6 years old. Although I now live for a very long time in land-locked Austria, I still enjoy diving when I get the chance. The above picture was taken on Curaçao last October, where I went diving with my father.

When the world goes entirely crazy my plan is to relocate somewhere warm and work as a scuba dive instructor.

Cloud Run Job with arguments

Sat, 22 Feb 2025 16:10:22 +0200

Cloud Run Jobs allows to run containers as jobs, i.e. as short-lived tasks that spin up a container every time that they’re invoked. As with every container you can use environment variables to pass context. But what if we want to pass arguments to the container?

In this case, the GCP API specifies containerOverrides. When using terraform, we can pass those with the google_cloud_scheduler_jobresource by customizing the http_target body like so:

On Azure

Thu, 16 May 2024 10:49:22 +0100

I’m working with a client ~~condemned to~~ graced with the privilege of using the Azure Cloud platform. Whilst I have years of experience working with AWS and GCP, my last exposure to Azure goes back to 2017. Memories from that time before Corona are faint, the world was a different place back then. But some things do not change.

On Managed Identities

…without having to manage any credentials? The sound of it is pleasant to the ears, and off we go taking this approach to setup an Azure Database for PosgreSQL - Flexible Server. The name is long, the process a bit involved, but in the end the identity is there, managed.

Migrating from Kubernetes to Google Cloud Run with terraform

Thu, 07 Mar 2024 11:14:12 +0100

Kubernetes has its advantages when you’re big enough and require the flexibility it offers. But when all you’re after is running services and you don’t need stateful sets, Google Cloud Run can be a good alternative (provided you’re using Google Cloud Platform). This article provides a few pointers to migrate Kubernetes deployments to Google Cloud Run.

Migrating YAML deployment descriptors

There’s a guide for migrating deployment descriptors which outlines the major syntax differences between a Kubernetes deployment and a Cloud Run service.

Fearless concurrency with Rust, cats, and a few Raspberry PIs

Fri, 26 Jan 2024 10:58:12 +0100

Somehow I’m never satisfied when a program only runs on one computer. The reassuring feeling of connectedness, the thrill of discovering who else is there on the network, the fear of network instability and the insanity of trying to establish a coherent view of the world on multiple machines are both a source of joy and despair that keep me hooked. But I digress…

In the previous article, we looked at building a blinking Raspberry PI with Rust to help cat owners think about cleaning the cat litter box (and avoid death stares from their feline companions). In this article, we’ll take things a step further and expand the Reminder PIs to a network, allowing to spread them all over the house so that forgetting about this daily cat owner duty will become an almost impossible thing to do. In order to achieve this, we will embrace the principles of Fearless Concurrency made possible by Rust’s memory management paradigm. More specifically, we will:

Building a cat litter box reminder with Rust

Fri, 12 Jan 2024 15:34:48 +0100

I continued working on a side-project I built a year ago with Rust, and it is now at a point at which I can write something about it.

When you own cats, you also own a litter box for said cats which needs to be emptied regularly (at least once a day for two adult cats). Failing this, the cats will give you a look which, in human language, means as much as “I will murder you in your sleep” which is not a very pleasant feeling.

On pinning and isolating CPU cores

Thu, 16 Nov 2023 17:27:11 +0100

This year I have been involved in running performance benchmarks of Aeron over at Adaptive on two major cloud providers. I learned quite a few things about the ~~arcane arts~~ ~~science~~ craft of running performance benchmarks.

When benchmarking a piece of software, you really want to get the best performance out of it, which is to say that you also want to run it under the best conditions in order to see what is possible. One aspect I’d like to cover in this article is related to giving the program exclusive access to the CPU core(s) it needs to run, without having other threads interfering with the execution. This involves:

Photography

Sun, 12 Mar 2023 00:00:00 +0000

I'm using a Fuji X-S10 camera, mostly with the Fujinon XF 10-24mmF4 and the Fujinon XF 35mmF1.4 lenses.

Rust Development for the Raspberry Pi on Apple Silicon

Fri, 04 Nov 2022 17:36:39 +0100

Update (18.02.2023): Updated the article to reflect the usage of VSCode remote development instead of JetBrains Gateway

A few weeks ago I started building a Rust project for the Raspberry PI using my brand new MacBook Pro with an M1 chip (the old MacBook Pro from late 2013 still works but it simply is too slow for the work I’m doing these days).

Shiny new MacBook Pro complete with scuba-diving sticker from my wife

Resume

Fri, 14 Oct 2022 14:06:31 +0100

Training course delivery

I’m a certified Lightbend Academy trainer and have delivered a number of courses on Akka and Scala.

2020: Company (financial products and services): Lightbend Akka for Java - Professional
2020: Deutsche Bahn Systel (mobility): Lightbend Akka for Java - Expert
2020: Company (digital media measurement and analytics): Lightbend Scala Language - Professional
2020: Company (digital media measurement and analytics): Lightbend Akka for Scala - Professional
2019: Company (financial products and services): Lightbend Akka for Java - Professional
2019: Lunatech (consulting), Netherlands: Lightbend Akka for Scala - Expert
2018: WireCard (financial services), Germany: Lightbend Akka for Java - Professional (multiple times)
2017: WireCard (financial services), Germany: Lightbend Akka for Java - Expert
2017: WireCard (financial services), Germany: Lightbend Akka for Java - Professional
2017: In cooperation with OpenForce: Lightbend Akka for Scala - Expert (public training course held in Vienna)
2017: In cooperation with Trifork: Lightbend Akka for Scala - Expert (public training at Scala Days 2017 Copenhagen)
2016: Deveryware, France: Akka Lightbend for Java - Professional
2016: DIMOCO, Austria: Lightbend Akka for Java - Professional

Tools & Technologies

The following is an (incomplete) list of tools and technologies that I have experience with.

Switching to Hugo after 17 years of WordPress

Thu, 11 Aug 2022 11:53:32 +0200

In the fall of 2005, I installed WordPress on the free hosting space provided by my ISP in France (fittingly called Free). I had very little experience with PHP but enough so to get the site up and running.

Initially called Lost in translation (after the eponymous movie starring Bill Murray and Scarlett Johansson) and I was writing about… well, I frankly don’t remember. However it must have been such poor writing that I decided to wipe all of it in the beginning of 2008 (even the wayback machine didn’t care to keep a trace of the content, to give you an idea of how bad it must have been). The subsequent writing wasn’t much better but I apparently wasn’t ashamed enough about it to wipe it out again.

Programming Languages

Tue, 12 Oct 2021 07:08:14 +0200

Programming languages I have dabbled with, in approximate order of first encounter:

Sinclair ZX81 basic
QuickBasic
logo
turbo basic
turbo pascal
assembly
html
c
java
sql
matlab
php
perl
javascript
python
action script
scala
groovy
typescript
go
swift
kotlin
rust

I always planned on looking closer at a LISP (such as Clojure) but so far haven’t found the time to play with one.

In general, I find it increasinly easy to pick up a new programming language. Concepts translate rather well. There definitely are design differences between the languages that require more time to get right and getting the feeling for the idiomatic way of writing in language X does take a bit of practice, but all in all I find the exercise to be rather repetitive (I expect that someone will point out that I have not yet experienced LISP).

Hey

Sat, 01 May 2021 14:38:24 +0200

I started using Hey last July as it seemed like a good way to get less noise via e-mail, for my personal e-mails. After about a year of using it, here’s what I can say about it.

What works for me

it is easy to just turn off noise by screening out incoming e-mail adresses
for some things, it is fast

What does not work for me

when I click on an e-mail to read it, it is marked as read. Then, it will be shown at the bottom of the Imbox. There, it tends to disappear. So, if I read an important e-mail that I do not want to forget about but have already left it, I need to scroll back down after reading it and do something with it. Unfortunately, neither the views “Reply later” or “Set aside” help me with the remembering because they tend to stack up. So what I do is to mark the e-mail as “new” so that it keeps on top of the Imbox and I don’t end up forgetting about it. Unfortunately this doesn’t always work and I end up forgetting about important e-mails sometimes.
finding back forgotten e-mail is hard and very time consuming. In Hey it is not possible to archive e-mails so everything ends up at the bottom of the Imbox. Scrolling down the Imbox is slow as it needs to load e-mails quite often and that takes time. So I cannot easily go back through the e-mails to see if I forgot something important, like communications with friends.
the search doesn’t work well (it does not find everything) and is slow. I find myself going to GMail (from where mail is redirected) to search

All in all, I think I will not renew my subscription and go back to using GMail. And perhaps be somewhat more agressive with filtering out e-mails I do not want to see.

Tour of Temporal: Performance

Sun, 25 Apr 2021 18:59:46 +0200

In the last part of this series, we looked into the fundamentals of the Temporal workflow engine and how it compares to actor toolkits such as Akka. As I wrote in the previous part, my personal experience with workflows has led me to associate anything with the word “worfklow” in it to “a slow process” (taking minutes to complete). In order to clear that idea from my mind (and also because I like exploring performance characteristics of technologies) I wanted to have a closer look at the performance of Temporal workflows.

Akka Raspberry PI demos

Thu, 15 Apr 2021 15:57:21 +0200

Here are a few demonstrations of how Akka Cluster works internally using a Raspberry PI cluster stack.

Tour of Temporal: Welcome to the Workflow

Mon, 12 Apr 2021 07:42:15 +0200

I’ve been exposed to workflows early on in my career, at first in enterprise environments where advanced GUIs were used to model highly complex business workflows whose execution would invariable lead to hours of debugging through mountains of log files via a remote desktop connection to the server running the proprietary workflow execution engine and later in research projects which would invariably feature some type of home-grown workflow engine (with a shiny GUI) to solve a part of the project. These interactions with workflows left me with a rather poor after-taste of the entire concept of workflows which can be summed up in two words: slow and complicated.

Smartphone Detox

Fri, 26 Mar 2021 20:04:41 +0100

“Insanity is doing the same thing over and over again and expecting different results.” – Someone (not Einstein)

Smartphones are addictive and highly distracting. Their mere presence reduces cognitive ability. I tried getting rid of mine - or at least of its intensive usage - many times over and have failed. Here’s my attempt at another shot, inspired by this article.

Day 1 (27.03.21)

Attempting to setup my old Ericsson T28s, which stores all contacts on the SIM card. iOS doesn’t allow to copy contacts to a SIM card anymore, so I found an old Android phone and connected it with my Google account to synchronize contacts. Tried 3 different SIM tooling apps but none of them manages to copy contacts over the SIM card. After a bit of research it turns out that most SIM cards issued by operators these days are read-only.

Disciplines for getting out of the stream

Mon, 08 Mar 2021 14:38:34 +0100

“Life is what happens to you while you’re busy making other plans” – John Lennon

But what if you’re not making plans. Or if all the plans you are making are more reactions to address short-term goals, needs or issues, rather than stepping back and looking at the general direction you’re headed?

I think this easily happens to most of us. When caught up in daily chores without the time to think - really think - it is very difficult to go meta and ask yourself about what it is that you really want. Add to this the plethora of interruptions and distractions we’re subjected to these days thanks to the attention economy and you get yourself a state of “constant drifting in a stream”. If you also have kids, replace “stream” with “torrent”.

When not to save money

Sat, 06 Mar 2021 18:04:50 +0100

Most people like to save money. But in some cases, saving money is counter-productive or will cost you more money, or so much time that you had wished spending a little more money.

Buying low quality items is one of these situations. The old saying too poor to buy cheap captures to essence of it: low quality ends up costing more on the long run than saving some money on the short term.

Three key findings from ten years of home-office

Fri, 23 Oct 2020 14:30:20 +0200

It’s been nearly ten years that I have worked mainly from home (or more accurately, homes, as we moved around a bit). As it turns out, many people now work from home, less so by choice than by ~~dystopian scenario C~~ circumstance. Whilst I’m sure that there are already hundreds of articles on the topic I thought I’d write a bit about my experience and especially about some aspects that may not be that obvious and that took me a while to prioritize.

10000 nodes and beyond with Akka Cluster and Rapid

Thu, 30 Apr 2020 09:39:47 +0200

Update: there’s a podcast episode about this

The year is 2021. As the world is still deeply affected by the COVID-19 pandemic, the United Nations have decided that in order to prevent the same scenario of ever happening again, there should be a worldwide, real-time contact-tracing system in place capable of tracking every human being on the planet. Everyone is now equipped with a small, pebble-like device. If a person you have been in contact with is confirmed to carry a new kind of virus for which there is no remedy, the device starts glowing in red. Each device reports the anonymized contact information to one global backend system capable of handling this type of massive scale.

Akka Consulting

Fri, 14 Feb 2020 13:55:41 +0100

If you are looking for a consultant to help you with the Akka Toolkit, you have come to the right place! Over the past decade I have consulted with dozens of clients on the topic distributed and reactive systems using technologies such as Akka, Akka Cluster, Akka Streams as well as related technologies such as Kafka, Kubernetes and Cassandra to name but a few.

A physical Akka Cluster used in Akka Consulting projects to demonstrate specific issues hands-on

Akka Cluster on Raspberry PI

Mon, 10 Feb 2020 16:00:09 +0100

Akka is a toolkit for building massively scalable applications. At the same time, it is lightweight enough to be deployed on Raspberry PI computers. I’m fascinated with these machines since I first saw one in real life at Devoxx Antwerp in 2010, own quite a few of them (some of which are hooked up to various appliances in my home) and use them in order to demonstrate Akka Cluster to clients or at training courses.

Akka anti-patterns overview

Fri, 20 Dec 2019 09:52:44 +0100

This is an overview of Akka anti-pattern articles. You can think of these anti-patterns as the opposite of Akka best practices – that is, things you should not be doing when using Akka.

Here is also a talk about 8 very frequent anti-patterns out there:

Basics

Performance

Network / Cluster

Using remoting
Trusting the network
Always using the defaults (to be written)
Using cluster without / with the wrong split-brain resolver (to be written)

Architecture / Design

Not defining a protocol (to be written)
Naming your application components after akka concepts
Too many actor systems
Blindly ignoring dead letters (to be written)

Tour of Akka Typed: Cluster Singleton and Routers

Tue, 03 Dec 2019 14:59:48 +0100

In part 5 of this series, we started to scale the application from a local one to a clustered one by introducing Cluster Sharding. In this article, we will continue our effort to scale the payment processor out and make it resilient through the use of Cluster Singletons and Cluster-Aware Routers.

Before we get started, here’s a quick reminder of what we’ve seen so far: in the first part we had a look at the the raison d’être of Akka Typed and what advantages it has over the classic, untyped API. In the second part we introduced the concepts of message adapters, the ask pattern and actor discovery. In the third part, we covered one of the core concepts of Actor systems: supervision and failure recovery. In the fourth part, we covered one of the most popular use-cases for Akka: event sourcing. Finally, as mentioned before, in the fifth part we started scaling out by making use of cluster sharding.

Tour of Akka Typed: Cluster Sharding

Sat, 09 Nov 2019 20:14:10 +0100

Update 21/11/2019: Fixed comment about shardId extraction in relation to ShardingEnvelope

Welcome to the fifth part of the Akka Typed series! In this part, we’ll leave the safe harbor of a single JVM and sail into the seas of distributed systems by exploring a key features of Akka Cluster with the typed API: Cluster Sharding. If you want to get a more in-depth introduction to Akka Cluster, I invite you to check out the article series on this topic.

One step closer: exploiting locality in Akka Cluster based systems

Mon, 28 Oct 2019 12:36:24 +0100

When it comes to the latency of processing a request in a distributed system, everyone knows (or should know) that doing things over the network is the most expensive thing you can do (alongside with disk reads):

The round trip time in a datacenter is about 5000 times longer than a main memory reference

Modern architectures have recognized this and will favor keeping data in memory, avoiding the need to go to disk or to the database, when consistency requirements allow for it. With Akka Cluster Sharding combined with Akka Persistence, it is possible to keep millions of durable entities in memory, reducing latency to a large degree.

Articles

Fri, 18 Oct 2019 15:40:23 +0200

This is an overview of some of what I’ve written over the years.

Featured

SRE / DevOps

On Azure

Rust

Tour of Temporal

Tour of Akka Typed

Tour of Akka Cluster

Akka anti-patterns

Basics

Performance

Network / Cluster

Using remoting
Trusting the network
Always using the defaults (to be written)
Using cluster without / with the wrong split-brain resolver (to be written)

Architecture / Design

Not defining a protocol (to be written)
Naming your application components after akka concepts
Too many actor systems
Blindly ignoring dead letters (to be written)

Akka

Scala

Play Framework

Reactive Database Access

Misc

Tour of Akka Typed: Event Sourcing

Mon, 07 Oct 2019 13:42:32 +0200

Welcome to the fourth part of the Akka Typed series. In the first part we had a look at the the raison d’être of Akka Typed and what advantages it has over the classic, untyped API. In the second part we introduced the concepts of message adapters, the ask pattern and actor discovery. In the third part, we covered one of the core concepts of Actor systems: supervision and failure recovery. In this part of the series we’ll explore one of the most popular use-cases for Akka: event sourcing. We’ll assume that you are already familiar with the concept of event sourcing - if not, first read about it to get some context.

Tour of Akka Typed: supervision and signals

Thu, 05 Sep 2019 10:10:10 +0200

Update 18.10.2019: fixed wrong syntax for handling multiple exceptions, clarifying a few points

Welcome to the third part of the Akka Typed series. In the first part we had a look at the the raison d’être of Akka Typed and what advantages it has over the classic, untyped API. In the second part we introduced the concepts of message adapters, the ask pattern and actor discovery. In this part of the series, we’ll have a look at one of the core concepts of actor systems: supervision and failure recovery.

Tour of Akka Typed: Message Adapters, Ask Pattern and Actor Discovery

Wed, 07 Aug 2019 08:13:01 +0200

In the previous article of this series we’ve explored the basics of the Akka Typed API: why it was created and what are its benefits in comparison to the classic Actor API, how to build typed actor systems via protocols and behaviors and how to create typed actors. In this series we’re going to go further down the route of building typed actor systems by looking at fundamental concepts necessary for the interaction between actors.

Tour of Akka Typed: Protocols and Behaviors

Thu, 11 Jul 2019 08:05:53 +0200

Update 18.08.2019: corrected actor hierarchy and default supervision strategy

Ukrainian translation / Chinese translation

In this series we are going to explore Akka Typed, the new Akka Actor API that brings significant advantage over the classic one. Akka Typed is ready for production since April and although the API is still marked as may change I think it is a good time to look into it and to learn what’s new.

Optimizing CI build times for Scala projects

Mon, 17 Jun 2019 10:12:38 +0200

CI / CD pipelines that run for each new and merged pull-request (or even for each commit on a branch) are today’s de-facto standard when it comes to developing software. Running the complete test suite automatically ensures that regressions are rapidly identified and do not make it into production.

As applications grow and their test suites grow (well, ideally, of course), build times tend to grow as well. Without care, these increasing build times can become a productivity bottleneck as the feedback loop provided by the automated CI/CD pipeline grows longer and longer. And yet I’ve also observed that teams tend to get used to those long build times (over 20 minutes or longer) without realizing just how much time is spent waiting for the tests to pass. It’s a bit of a “boiling frog” situation as the build times increase gradually and people just get used to them. The trouble is that this has a potentially large impact on team productivity - waiting for the CI pipeline to finish before submitting a pull-request for review (because you wouldn’t want to submit it if the tests fail), waiting for the pipeline to finish after merging it to the master branch before deployment, etc. is just wasted time - without mentioning the context switch that inevitably occurs when you have to wait for a 20 minutes for a build to finish.

Why I’m still using a MacBook Pro Late 2013 in 2019

Fri, 07 Jun 2019 09:18:05 +0200

Update: it is now June 2021 and I’m still using the MacBook Pro Late 2013
Update: it is now February 2022 and I’m still using the MacBook Pro Late 2013 after having changed the thermal paste for the CPU and GPU

I’ve started using Apple computers in 2008. Of all the Apple computers - and other computers - I’ve owned, the MacBook Pro Late 2013 is the one I’ve been able to keep the longest so far. The main reason that’s possible is because there are still a few ways to upgrade this Apple computer.

Raspberry PI Akka Cluster LED strips

Thu, 02 May 2019 12:00:59 +0200

Ever since Eric Loots from Lightbend first showed me the Raspberry-PI based Akka Cluster with special LED stripes, I’ve wanted (at least) one of them.

The Akka PI Cluster at Scala Days 2018

This is a 5 node cluster with special LED stripes setup in such a way that the LED colour and status (on, off, blinking, etc.) show in which state each node is. It is an excellent way to teach Akka Cluster, and since I do this regularly I was very interested from the beginning to get one of these myself.

2018: year in review

Mon, 31 Dec 2018 17:52:53 +0100

I had intended to write a yearly review for a few years now but have not managed so far - 2018 is going to be the year that I finally get down to it. Looking back at the year is an interesting exercise and if I manage to keep this up for a few years (fingers crossed) it might provide a few interesting insights — and if not, it will have been fun anyway.

Akka anti-patterns: too many actors

Mon, 06 Aug 2018 06:01:22 +0200

Update (07.08.2018): clarified optimal vs. suboptimal use cases of having many actors at runtime (it could have been misunderstood that Akka isn’t meant to build systems with many actors - it entirely is - but it is questionable whether that’s always the best approach)

It occurred to me that I haven’t written yet about this very frequent anti-pattern. It is to be found in codebases written by developers who have just discovered the actor model.

Tour of Akka Cluster

Fri, 03 Aug 2018 09:25:34 +0200

Here’s an overview of the Tour of Akka Cluster article series:

Akka anti-patterns: Java serialization

Fri, 20 Jul 2018 11:29:45 +0200

Akka makes use of serialization when messages leave the JVM boundaries. This can happen in mainly two scenarios: sending messages over the network when using Akka Cluster (do not use Akka Remote directly) or using Akka Persistence.

Now here’s the catch: the default serialization technology configured in Akka is nothing but the infamous Java serialization, which Mark Reinhold called a “horrible mistake” and which Oracle plans to dump in the near future anyway.

Akka anti-patterns: stateless actors

Wed, 30 May 2018 07:31:24 +0200

Actors are object-orientation done right (as opposed to say, objects in Java): their state is not visible from the outside and they communicate via messages. There’s no way to break encapsulation because you can’t peek into an actor’s state while it is running. That’s the entire point of actors: they provide you with the illusion of a safe space in which things are executed sequentially, one message after the other, allowing you to use mutable state inside of your actor without having to worry about race conditions (well, almost: don’t leak the state).

A quick tour of build tools in Scala

Thu, 19 Apr 2018 13:07:55 +0200

Update 20.04.2018: added Polyglot Maven

Scala has a rich ecosystem and active community producing a lot of useful libraries. So much so that, sometimes it is not easy as a newcomer to decide which library to pick for a given task (this is the case for example when it comes to database access and JSON handling). In this article we are going to cover another domain in which there is an increasing number of alternatives: build tools. At the time of writing this article in April 2018 we have at our disposal:

60-Minute Strategy Call

Fri, 30 Mar 2018 15:34:01 +0200

Do you want to make sure you’re headed the right direction before investing a considerable amount of time and money? Do you need a quick look at your planned architecture? Are you unsure as to the next steps to take? I can help you with a focused strategy call during which we’ll work out solutions for your problems.

[testimonials category="strategy-testimonials" class="owl-one"]

What’s included?

60-minute video conversation via Skype (with screen sharing if necessary)
Video recording of the call
One week follow-up via email

Ready for the call?

The 60-minute strategy call currently costs 399€. Please book a time slot using the button below, and I’ll get back with a payment link and further details.

Services

Fri, 30 Mar 2018 15:33:06 +0200

Expert services to guide you towards a reactive system architecture

My services are available as low-risk, fixed-price packages. If you didn’t find a package to meet your needs, don’t hesitate to get in touch with me to discuss a custom engagement. I offer all of these services in english, german and french.

60-Minute Strategy Call

Do you want to make sure you're headed the right direction before investing a considerable amount of time and money? Do you need a quick look at your planned architecture? Are you unsure as to the next steps to take? I can help you with a focused strategy call during which we'll work out solutions for your problems.

Tour of Akka Cluster – Testing with the multi-node-testkit and a handful Raspberry PIs

Fri, 23 Mar 2018 08:19:47 +0100

In the previous parts of this article series, we have looked at various functionality of Akka Cluster: distributed data, persistence, message delivery semantics and cluster sharding. We are far from done with exploring Akka Cluster features, but today it is time to look at one feature that is extremely useful when it comes to building production-quality systems based on Akka Cluster: the test support. As testing itself isn’t the most exciting activity there is, let’s space this article a bit up by throwing a few Raspberry PIs in the mix:

Akka anti-patterns: overusing ActorSelection

Tue, 20 Mar 2018 09:27:15 +0100

Akka’s ActorSelection makes it possible to look up actors by logical path in the hierarchy:

1

val selection: ActorSelection = context.actorSelection("../processor/storage")

This selection can then be used like ActorRef in order to send messages to it using the tell or ask patterns:

1
2
3


selection ! Storage.Store("important words")

val allWords: Future[Seq[String]] = selection ? Storage.RetrieveAll

ActorSelection is therefore quite useful and allows more flexibility when designing an actor system given that trees can be built dynamically and queried dynamically at runtime. That being said, there are a few things that you should be aware of when using this mechanism.

Lightbend Akka Streams for Scala – Professional

Fri, 16 Mar 2018 16:31:52 +0100

Want to help your team to get up to speed with Akka Streams, enabling them to build powerful streaming data applictions? I have been working intensively with Akka since 2011 and am offering remote and in-house training for teams.

Summary

This one day course introduces experienced Akka developers to the Akka Streams API. Akka Streams enables the consumption of streaming data, in a fully non-blocking, asynchronous manner. It also allows us to consume that data while providing non-blocking backpressure to prevent mailbox overflows. Our goal is to learn the components that make up the Akka Streams API and how they interact. We will see a broad range of different Akka Streams components and have a chance to use many of them.

Tour of Akka Cluster – Cluster Sharding

Mon, 26 Feb 2018 16:33:04 +0100

In Tour of Akka Cluster - Eventual consistency, persistent actors and message delivery semantics we started to look into making the reactive payment processor resilient to node crashes by exploring Akka Persistence, a mechansim that provides durability guarantees for actor state. We also briefly mentioned Akka Cluster Sharding which offers a way to automatically distribute actors of the same type over several nodes. In this article we are going to take a closer look at cluster sharding and then make use of it for our reactive payment processor.

Tour of Akka Cluster – Eventual consistency, persistent actors, message delivery semantics

Wed, 31 Jan 2018 14:19:43 +0100

In Tour of Akka Cluster - Akka Distributed Data we looked into building a reactive payment processing system using Akka Distributed Data as a means to provide master-master replication to the order storage component. We did not, however, ensure in any way of form that the system as a whole could withstand individual node crashes. In this article, we will explore options for making the Reactive Payment Processor fault-tolerant.

Evaluating the existing design in the light of redundancy

Let’s make a thought experiment and see if our current design is fit to be “upgraded” in the light of redundancy. Let’s suppose we have made the validation process redundant, so that it would take place on any node (not just the node on which the order was first registered). This way, should the order receiving the node fail, we would still be able to continue validation and processing (so long as it wasn’t the node also handling the particular acquring bank).

Tour of Akka Cluster – Akka Distributed Data

Wed, 03 Jan 2018 15:23:04 +0100

Building distributed systems is hard. Pesky things like the laws of physics get in the way of maintaining state accross geographically (and chronologically) disparate systems, and, if that weren’t already outrageous enough in itself, those systems may be subject to network failures, forcing us to think about annoying tradeoffs regarding consistency, availability and the meaning of life.

One of the more interesting (well, at least from my perspective) tools in the Akka toolbox is Akka Cluster and the modules built on top of it. Through its design it acknowledges the hard reality of life, promoting a “no magic here” approach to building distributed applications and yet at the same time, takes care about many of the harder aspects of doing so.

Subsequent thoughts on fatherhood

Thu, 16 Nov 2017 09:04:29 +0100

A bit over two years ago, I wrote about my initial thoughts on fatherhood a bit after our daughter was born. Our son ThÃ o is now 4 months old and I find it fitting to write a follow-up.

Life with one kid

Life with one kid is easy (in a couple). You’re two adults (well, more-or-less) against one child. Yes, the nights can be rough - in our case, ValÃ rie still hasn’t learned to sleep through the nights. There’s about a gazillion books, blog posts, video courses, self-proclaimed sleep gurus out there, and while some of the advice may apply to some kids, the reality of the matter is that each kid is wildly different (or should I say unique) and will have wildly different sleep patterns. And all that money spent on books and whatnot won’t change this. Judging from what we’ve heard from friends and acquaintances with children, the sleep pattern seems to be in large part hereditary - there seems to be a rather strong relationship between how the parents slept as kids (or still sleep as adults) and how the children sleep. In our case, we hit the double jackpot since neither I nor my wife is particularly sound sleepers. Perhaps, now is a good time to consider reliable options such as buying the best adjustable bed in Australia. Hopefully, that way, no matter what time we sleep, we can get a good night’s sleep.

Akka anti-patterns: naming your application components after Akka concepts

Sat, 26 Aug 2017 06:00:47 +0200

So you’ve just learned Akka and are tremendously excited. It’s got dispatchers, routers, supervisors - so many shiny things to play with, and in style (I mean, come on, a dispatcher sounds a lot nicer than, say, an AbstractSingletonProxyFactoryBean).

And so it happens that, perhaps even unknowingly to you (you’re busy configuring a pool router), your actors start getting names such as:

Dispatcher
IncomingRouter
FailureSupervisor

I’ve observed this on three projects now, for two of which I delivered an introductory Akka training to the team beforehand. I’d say that this anti-pattern is especially to be found in projects where people are just getting started with Akka.

A new adaptive accrual failure detector for Akka

Wed, 26 Jul 2017 15:28:38 +0200

Akka uses the The Φ Accrual Failure Detector for failure detection, which is to say for answering the question of whether a node is alive or not. That’s one of the harder problems of distributed systems since it is virtually impossible (from the point of view of one node) to tell the difference of a remote system being completely unavailable (process crashed, computer died, etc.) or slow (network congestion, other kind of congestion such as CPU during a garbage collection for JVM processes, etc.).

Akka anti-patterns: trusting the network

Tue, 20 Jun 2017 05:06:33 +0200

One anti-pattern I’ve observed in networked Akka applications is a tendency to forget that it is, well, networked and to treat the network as a friendly place.

Trusting the network to be reliable

How does that look like? Well, consider the following piece of code:

1

actorOnDifferentNode.tell(veryImportantMessage, sender());

Akka’s default message sending mechanism is the fire-and-forget tell method. And that works great - until it doesn’t. See, tell has at-most-once message delivery semantics. This means that in theory (and in practice!) messages may not make it to their destination.

Lightbend Akka for Java – Expert

Sun, 18 Jun 2017 13:00:43 +0200

Want to help your team in getting started with building distributed reactive applications using Akka? I have been working intensively with Akka since 2011 and am offering remote and in-house training for teams.

Summary

This is a three-day advanced course on building distributed reactive applications using Akka and Java. It is intended for developers who already have a strong understanding of the fundamentals of building applications using Akka and Java on a single JVM and are looking to learn how to scale out to multiple nodes and 3rd party systems. This course has extensive hands-on work and successive exercises build upon prior lessons learned to produce a fully functional application that is both event-driven and resilient by the conclusion of the course.

Akka anti-patterns: using remoting

Thu, 08 Jun 2017 07:14:03 +0200

Senior developer using Akka remoting directly to build a special type of cluster

Whilst I have always successfully discouraged my clients from using Akka Remoting in their application, I often get questions regarding remoting while talking about anti-patterns at conferences and user groups.

Don’t get me wrong. I love Akka remoting. Especially the new Aeron-based Artery remoting version that is based on UDP rather than TCP. Whilst it maintains the same delivery guarantees, it is quite a bit faster than the TCP counterpart.

Tour de Lagom Part 1: Lagom and microservices

Mon, 05 Jun 2017 16:17:52 +0200

Lagom is a framework for building reactive microservices in Scala or Java with an emphasis on developer productivity. I’ve had a chance to work with it for some time and would like to share my impressions about it. This is going to take a bit longer than just one post, so you’re reading part one of a 3-part series:

Part 1: Lagom and microservices
Part 2: Lagom and reactive
Part 3: Lagom and developer productivity

The idea is to cover most of what Lagom has to offer by looking at it at various angles. Let’s go!

Akka Streams – What is NotUsed all about

Mon, 22 May 2017 08:55:14 +0200

Akka Streams is a powerful implementation on top of the Reactive Streams SPI for non-blocking asynchronous communication with back-pressure on the JVM. This post is not about explaining what this means, nor what Akka Streams does. The purpose of this post is to explain what on earth the NotUsed type in type signatures of Akka Streams is all about which — incidentally — also means explaining a fundamental design aspect of Akka Streams.

Akka anti-patterns: blocking

Mon, 15 May 2017 07:59:20 +0200

This is probably one of the most frequent (and dangerous) anti-patterns when it comes to working with Akka. Let’s look at an adequate description of the mindset you must be in in order to use it:

So maybe you didn’t actually want to see the world burn. Maybe you thought that this one time it was okay to call blocking code inside of an actor. Little did you know that, seven months later, this decision would bring down the entire system minutes after its official launch and announcement in the media.

You got to hold the frame – Avoiding burnout or Lessons learned from six years as an independent consultant

Mon, 08 May 2017 09:15:06 +0200

There’s a scene in the 1987 classic movie Dirty Dancing in which Johnny (Patrick Swayze) explains the concept of dancing space to Baby (Jennifer Grey).

“Lock your frame. Lock it, lock it, lock it.
Look. Spaghetti arms.
This is my dance space, this is your dance space.
I don’t go into yours, you don’t go into mine.
You got to hold the frame”

— Johnny, Dirty Dancing

Baby, who is a quick learner, later makes fun of this:

IntelliJ IDEA OS X Shortcuts on Ubuntu Gnome

Mon, 10 Apr 2017 19:43:20 +0200

I recently got myself a new desktop computer with nice and fast hardware (more about this in another post) and am setting up Ubuntu Gnome on it. Since I’ll still be using my MacBook Pro for some time I don’t want to learn another set of keyboard shortcuts, so I set out to use IDEA’s OS X 10.5+ keyboard bindings on Ubuntu. It turns out that it possible, although not straightforward. Here’s how to go about it.

What I'm doing now

Tue, 21 Mar 2017 20:20:31 +0100

This is a now page that tells you what I am focusing on at this point in my life.

These days, I am:

Putting in place SRE and DevSecOps practices at a client in Vienna
experimenting with AI agents

This page was last updated on 18th of March 2025

About

Sun, 19 Mar 2017 21:12:15 +0100

I’m a polyglot software engineer and trainer working as an independent consultant.

My consulting work consists in helping my clients:

engineer, deploy and operate highly available and fault-tolerant systems
get existing systems to meet predictable performance requirements in the face of increasing load

I have significant experience in engineering and operating distributed systems at all levels of the stack, from high-level architecture down to debugging issues at the kernel or network level. Next to working on client projects I have also explored the topics of cluster membership and distributed consensus, trying to keep up to date with the latest research in this field and sometimes pushing the limit myself.

Lightbend Akka for Scala – Expert

Mon, 02 Jan 2017 15:14:23 +0100

Summary

This is a two-day advanced course on building distributed reactive applications using Akka and Scala. It is intended for developers who already have a strong understanding of the fundamentals of building applications using Akka and Scala on a single JVM and are looking to learn how to scale out to multiple nodes and 3rd party systems. This course has extensive hands-on work and successive exercises build upon prior lessons learned to produce a fully functional application that is both event-driven and resilient by the conclusion of the course.

Akka anti-patterns: being out of touch with the hardware

Mon, 21 Nov 2016 17:02:31 +0100

Choosing Akka as a tool is often - if not always - driven by the need for good performance. Surely, the actor model itself is appealing as a means for organizing and reasoning about code, but this isn’t in itself a good reason enough to use the Akka toolkit. If all you are concerned about is a nice way to organize code and build modular applications you might as well pick the Spring Framework which has a very rich and clear component model and provides very good support for building software where performance isn’t one of the driving factors.

Lightbend Akka for Scala – Professional

Mon, 24 Oct 2016 20:49:54 +0200

Want to help your team to get up to speed with the core concepts of Akka and the Actor model, enabling them to build production-ready Akka applications? I have been working intensively with Akka since 2011 and am offering remote and in-house training for teams.

The course is updated to include the new Akka Typed API that brings significant advantages over the classic API.

Summary

This two-day course introduces experienced application developers to the reactive Akka toolkit and runtime and the methodologies that enable the creation of real-world actor-based systems in Java on a single JVM. This course has extensive hands-on work and successive exercises build upon prior lessons learned to produce a fully functional application that is both message-driven and resilient by the conclusion of the course.

Lightbend Scala Language – Professional

Thu, 06 Oct 2016 09:50:09 +0200

Want to help your team to get started with Scala faster and to share the same basic knowledge about the language and the functional programming concepts? I have been working intensively with Scala since 2010 and am offering remote and in-house training for teams.

Summary

This two-day course is designed to give experienced developers the know-how to confidently start programming in Scala. The course ensures you will have a solid understanding of the fundamentals of the language, the tooling and the development process as well as a good appreciation of the more advanced features. If you already have Scala programming experience, then this course could be a useful refresher, yet no previous knowledge of Scala is assumed.

Lightbend Akka for Java – Professional

Wed, 28 Sep 2016 06:29:44 +0200

Do you want to help your team start using Akka and the actor model quickly to create operational applications? I have worked intensively with Akka since 2011 and offer the official training of Lightbend Akka for Java – Professional, remotely or in your office.

The course is updated to include the new Akka Typed API that brings significant advantages over the classic API.

Presentation

This three-day training was designed for the purpose enable experienced Java developers to create reactive applications based on Akka on the FMV. The training devotes a large part to the acquisition of knowledge by carrying out several practical exercises using adapted tools, which at the end of the training result in a operational application that is both resilient and message-oriented.

Akka anti-patterns: logging (the wrong way)

Wed, 31 Aug 2016 05:59:33 +0200

Update: removed rogue toString call in the second code example, since it was unnecessary (and harmful).

Proper logging

Debugging actor systems is no small feat, even when there is IDE support for it. In fact, debugging any asynchronous system for that matter is a rather complicated task. Which is why, especially during development, it is not entirely uncommon to rely on DEBUG level logging to get a sense of how messages flow between actors. Whilst doing so is fine, there are a few precautions that need to be taken when logging at DEBUG level (or any other level). Remember, logging ranks very high on the list of top 10 performance mistakes.

Akka anti-patterns: too many actor systems

Tue, 23 Aug 2016 07:25:10 +0200

Admittedly I’ve seen this one in use only one time, but it was one time too many. For some reason I keep seeing clients come up with this during design discussions and reviews though, therefore it makes it into the list of Akka anti-patterns.

What I am talking about is this:

Many ActorSystems on a single JVM, competing for resources

Reasons I hear for this design:

isolation of concerns: each ActorSystem is separated, hence failure of one system does not affect the other
custom classloading in the ActorSystem, dynamically loading libraries and isolating them between systems
using multiple Akka versions without having to restart

And I am not talking about designs where there are 2 or 3 ActorSystems on the same JVM here, but possible hundreds if not thousands. Now, Akka itself does not share any global state so you can theoretically pull this off. But should you?

Akka anti-patterns: race conditions

Tue, 16 Aug 2016 05:00:39 +0200

The actor model makes it possible to build highly-concurrent applications through the notion that actors obey the actor send rule and the actor subsequent processing rule, hence creating a single-threaded environment inside of an actor.

That being said, it’s all an illusion: as we have briefly talked about previously, Akka’s dispatchers make sure that messages are being processed by actors and so the thread by which one message is processed may not be the same as the one by which the next message is going to be processed.

Akka anti-patterns: flat actor hierarchies or mixing business logic and failure handling

Tue, 09 Aug 2016 04:00:31 +0200

Flat actor hierarchy. Sad actors being all flat.

One of the fundamental ideas built into Akka is the one of failure handling through parental supervision.

In other words this means agencing actors in such a way that parent actors that depend upon the correct execution of a child to perform their work are also responsible for deciding what to do when one of the child actor crashes.

An exception thrown inside of an actor results in that actor crashing, prompting its parent to decide what to do, which it does using a SupervisorStrategy. You should not be writing defensive try...catch blocks inside of an actor - except perhaps for a few rare cases, this too is an anti-pattern! Instead the idea is to let it crash and handle failures through another channel entirely.

Akka anti-patterns: shared mutable state

Tue, 02 Aug 2016 15:00:40 +0200

When I work with clients on designing actor systems there are a few anti-patterns that seem to make it into initial, non-reviewed designs no matter what. In this series of short articles I would like to cover a few of those.

Even though the Akka documentation points this out in various places, one of the favourite anti-patterns I’ve seen is use is sharing mutable state accross actor boundaries.

The reality of writing a technical book

Fri, 15 Jul 2016 16:18:15 +0200

Two days ago I received my copies of Reactive Web Applications.

Stairways to Reactive

Needless to say, I had been waiting for this moment for some time. Even though the final PDF version had been out for a few weeks prior to this, nothing compares to holding in your hands an actual, physical, printed book (sites like Printivity could help out in this regard) and seeing the pages you’ve been working on in context with the possibility of turning them back and forth. Call me old-fashioned, but when it comes to reading a book with the purpose of learning new material I have the feeling that printed books have a better quality to it, with some form of tactile memory helping to remember the contents better.

The microservices marathon

Tue, 14 Jun 2016 09:19:58 +0200

Everyone is talking about microservices. And many people are betting on it. At this year’s Voxxed Days Vienna over 60% of the submissions contained the word microservices. At JAX 2016 in Mainz, the word microservices was spoken out aloud on average 40 times per minute accross the entire venue. It’s hard to go one day on Twitter without seeing microservices in the stream.

In this post I’ll first try to answer the question of why there is a need for microservices (in some settings) and then I’d like to talk a bit about what I think is a neglected issue in all the hype surrounding the topic these days: the feasability of organizational adoption of microservices. It is one thing to have the tools to microservice and another one entirely to be able to get an organization to think and act in terms compatible with the vision promised by the microservice architecture.

Akka Cluster, Java and the Raspberry PI 3 Model B

Tue, 19 Apr 2016 07:39:52 +0200

I recently built an architecture prototype for DIMOCO aiming at answering roughly the following questions:

what does it entail to run an Akka cluster, how fast can new nodes join, how manageable is such a cluster?
are traditional publish-subscribe message distribution semantics supported (one-to-one, one-to-N, one-to-any-of-N)?
how can message loss be averted / minimized?
how fast is the message sending, is it fast enough?
does it feel “Java-like” enough (since Akka has strong ties to Scala and the aim is to use Java for this project)?
how well does it run on the data centers on premise, how easy is it to operate?

Since I’ve been itching to find an excuse for trying out the new Raspberry PI 3 Model B this was the perfect opportunity to order 3 of them and use them for testing the prototype.

Reactive Web Applications

Mon, 21 Mar 2016 15:38:10 +0000

Reactive Web Applications

I decided to put the know-how I’ve collected over the years to good use by writing a book that will help others get started with reactive web applications. “Reactive Web Applications” will introduce you to a few concepts that will provide a basis for working with reactive architecture and making the most out of it.

The book is the result of several years of experience designing, building and working with teams to build high-performant, fault-resilient web applications using the Play Framework, Akka and Scala. In a way, this is the book I wish I had had when I first started working with this stack.

The one Play Framework productivity tip you should know about

Mon, 07 Mar 2016 15:08:38 +0100

If there is one thing you need to know when it comes to enhancing your productivity when working with the Play Framework it’s the following tip because it will save you a lot of time during development. I’ve watched many developers repeat the same steps countless times in a day and every time I show this albeit simple tooling tip it’s like developing is a whole new experience again.

So what’s this “magic” tip I am talking about? Since Play leverages type-safety and warns you early on that things go bad through compilation errors, your screen will often look like this:

Upgrading from React 0.11.2 to 0.14.7 in 374 easy steps

Thu, 25 Feb 2016 17:42:17 +0100

Today I set out to the task of upgrading a set of views crafted with the React library. The upgrade was necessary because one part of a view using React stopped working in Chrome Version 48.0.2564.116 (64-bit). I don’t know why this happened, I didn’t find anything related to it and as it stands this was probably the only project on the Internet still running on this old version of React anyway. If not, you may or may not find this post useful. Or not. But at least it might be entertaining.

5 years of Scala and counting – debunking some myths about the language and its environment

Fri, 13 Nov 2015 12:39:21 +0100

I started using Scala 5 years ago instead of Java after starting (but never quite finishing) to read the first edition of Programming in Scala. First only present in tests, my first attempts at Scala code would quite soon invade small utility classes and before I knew it take over all of my projects.

There are many rants about Scala out there. This isn’t one of them. I’m not here to complain, but rather to applaud.

A quick tour of JSON libraries in Scala

Fri, 06 Nov 2015 00:22:48 +0100

Update (18.11.2015): added spray-json-shapeless library
Update (06.11.15): added circe library

Some time ago I wrote a post on relational database access in Scala since I was looking for a library and there were many of them available, making it hard to make a choice. It turns out that the situation is similar if not worse when it comes to JSON libraries in Scala.

There are just plenty of them. You have no idea. (me neither until I wrote this post)

Initial thoughts on fatherhood

Fri, 16 Oct 2015 12:30:34 +0200

Our daughter Valérie was born ~~two~~ three weeks ago. Our friends have all suggested we use someone similar to this newborn photographer El Dorado Hills to capture these special memories before they’re gone, but I’ve decided to write them down instead. We’ll definitely get photos soon though. This post is a collection of thoughts and first impressions that my tired brain will probably forget if I don’t write them down.

The Art of Meaningful Programming

Wed, 27 May 2015 23:16:38 +0200

As a child (I think I was around 6 at that time), I wanted to become an inventor, much like Gyro Gearloose. My father wisely pointed out that this wasn’t a job that existed on the job market, but that the closest thing was likely to become an engineer of some kind. And so I ended up becoming a telecommunications engineer with a specialization in the development of distributed systems.

Software is an excellent medium for expressing one’s creativity. It is cheap and malleable, and nowadays it is possible to see the result of what code does almost instantly. I haven’t yet figured out how to build a walking light-bulb with software yet but give it 15 years and we’ll have APIs for this, too. But programming is not easy, which also means that next to actually building things, we software people spend a lot of time learning how to build things and arguing about how things should be built.

Reactive Play

Tue, 27 Jan 2015 08:17:00 +0100

TL;DR: Play applications are not automagically performant. I’m writing a book that shows how to use Play correctly, especially when used to working with threaded web-servers such as Tomcat or Jetty. Save 50% with the code mlbernhardt.

Generation Javascript

Tue, 30 Dec 2014 09:24:36 +0100

I’ll start by saying that this is not a rant, but rather a cry of despair that I’m repeating and that slowly - but steadily - seems to come to consciousness in our industry, like this one. The phenomenon I’m about to describe is not only limited to the Javascript community either, that community seems a lot more affected than others.

Up until this morning, I had been mumbling about those concerns mostly to myself, and to some colleagues and friends. Then I read this article and I felt like I had to do something. This really is a good read, if you haven’t seen it yet, I recommend adding it to your reading list or Instapaper or whatsonot right away. The article, A generation lost in the Bazaar, talks about Unix and how the lack of overall design or “bazaar” mentality (depicted in The Cathedral and the Bazaar) have made it extremely hard to get anything done without digging through a jungle of libraries that kind of repeat functionality, contain copy-pasted code, or depend on libraries that they perhaps don’t need at all.

A handful Akka techniques

Wed, 23 Apr 2014 19:50:28 +0200

I’ve been using Akka for 3 years in a variety of projects and by now, I have a hard time imagining to deal with some of the parts of my work without it. Sure, Scala provides other powerful paradigms for dealing with concurrency, but I find Actors to be one of the most elegant concept when it comes to reasoning about it.

There are a few techniques that I’ve used repeatedly in projects and that I would like to share. Make no mistake though

A quick tour of relational database access with Scala

Tue, 04 Feb 2014 18:43:39 +0100

Update: Added Squeryl, thanks to @JoeZulli for the heads-up
Update 2: Added link to latest Squeryl release for Scala 2.10 and 2.9.2

I recently started working with relational databases again from within Scala, after a while in JSON-land (mostly MongoDB and elasticsearch). During that time, I’d been happily working with lightweight libraries / DSLs that take care of case class serialization, such as the impeccable Salat and elastic4s.

So I started looking for a tool that would let me achieve the following:

Java2Days Sofia 2013

Sat, 21 Dec 2013 16:50:40 +0100

Two weeks ago, I went to speak about Scala at the Java2Days conference in Sofia, Bulgaria. This was the 5th edition of the conference, and my first time there. A small group of speakers (to the extent of my knowledge, Josh Long, John Willis and Andrew Lombardi) has been flying overseas every year to attend the conference since it’s first edition. Why, you ask? After having been there, I too know why: it’s a really nice conference!

Tips & tricks for setting up a Play 2 project

Sat, 16 Nov 2013 16:47:32 +0100

Here are the slides from my talk at Devoxx 2013 in Antwerp: https://speakerdeck.com/manuelbernhardt/tips-and-tricks-for-setting-up-a-play-2-project

Devoxx was great, as always! A huge thank to Stephane and his crew for making it happen, year after year!

Devoxx wristbands 2012 and 2013

Reactive Golf or Iteratees and all that stuff in practice, part 3

Sat, 26 Oct 2013 17:44:07 +0200

In part 1 and 2 we’ve seen how to build a completely reactive chain to fetch a large stream of data from a REST API, transform it on the fly and send it over to indexing to ElasticSearch.

Now one question remains: does it actually work, and does it help solve a real problem?

In order to answer to this question, let’s build a naive, blocking version of the pipe-line above. We’ll consume the stream, then transform it, and then send it over to ElasticSearch, in chunks:

Java Klassentreffen 2013: Scala Introduction slides

Thu, 24 Oct 2013 15:25:09 +0200

A bit late, but nonetheless: my slides from the Java Klassentreffen 2013 in Vienna and Linz.

Introduction to Scala from Manuel Bernhardt

Reactive Golf or Iteratees and all that stuff in practice, part 2

Mon, 21 Oct 2013 18:29:43 +0200

Last week, we saw how to get data from a REST API and modify it to our liking in order to send it off for indexing to ElasticSearch. Now, let’s see how to get the data into ElasticSearch in a resource-friendly manner.

Indexing with ElasticSearch and elastic4s

ElasticSearch has a RESTful index API through which to send data for indexing, like for example so (from the ElasticSearch documentation):

1
2
3
4
5


$ curl -XPUT 'http://localhost:9200/twitter/tweet/1' -d '{
 "user" : "kimchy",
 "post_date" : "2009-11-15T14:12:12",
 "message" : "trying out Elastic Search"
}'

It also supports bulk requests, which is what we’ll need, since it makes little sense to issue one HTTP request for each document.

Reactive Golf or Iteratees and all that stuff in practice, part 1

Thu, 17 Oct 2013 20:24:13 +0200

I’m currently working on a project that involves synchronizing large amounts of data from backend systems for the purpose of making it searchable. Amongst other things, one domain the system deals with is Golf and the booking of tee times (i.e. a time at which to start playing). If I got things correctly, tee times are there in order to avoid getting hit by a player that starts later on (I haven’t played golf yet).

Scala with SublimeText

Fri, 20 Sep 2013 13:07:13 +0200

Three weeks ago, one of our cats set its mind to beat its long-distance jumping record on my desk, accross my laptop. Unfortunately for my laptop, there was a cup of tea standing next to it, and our cat didn’t care too much about adjusting the height of the jump.

Laptop-destroying cat

As a result, I am now working for the past 3 weeks with my old MacBook Pro Early 2008 (which I kept in a shelf for this purpose exactly). As a side effect though, I can’t work anymore with IntelliJ IDEA, because coding with Scala on this old machine (with little RAM) needs quite a bit of resources, and the IDE is too slow.

How to read the Play session from AngularJS

Thu, 01 Aug 2013 19:24:12 +0200

If you happen to work, like me, on a project that makes use of both the Play framework and AngularJS, you may at some point need to read some data from the Play session in your AngularJS application. Play uses a client-side session, which makes sharing the data with client-side applications easy.

In order to access the session data on the client-side, you’ll need the following:

1. Allow the Play session to be read by javascript

In application.conf, set the session.httpOnly flag to false:

The case for document-oriented databases

Sun, 28 Jul 2013 14:21:41 +0200

Last week, I started working with AngularJS for a real-world project - I had played with Angular before, mainly to see how it differs from KnockoutJS which I had been using intensively before. This post is not about AngularJS itself (I may write one later on when I have a better perspective about the framework), I’ll just say that my first impressions about it are:

it lacks good documentation - the existing documentation doesn’t exactly have the right “feel”, and is incomplete
when coming from Knockout, Angular feels rather invasive, given that it is a “full-blown” framework rather than “just” a MVVM mapping tool
my current impression is that the learning curve looks like a roller-coaster - there’s moments of intense productivity interrupted with high amounts of “not getting anywhere, why on earth am I using this sh*t”

That being said, there’s one thing that AngularJS seems to get really right: it makes it possible to map documents to the UI without imposing its own design philosophy on the said document. With KnockoutJS for example, you’d have to make sure certain fields were provided as arrays, and generally had to know really well how the different bindings worked before knowing into what shape to bring your data so that the UI would do what you wanted.

CRUD trait for Slick models in the Play! framework

Mon, 08 Jul 2013 20:09:41 +0200

Slick is a powerful library for functional database access, leveraging Scala language features such as implicit conversions and macro’s to allow type-safe interaction with databases.

The play-slick module allows easy integration with the Play! framework by providing e.g. support for database evolutions and other convenience methods.

As I got to work with Slick more extensively, one thing that started to annoy me pretty soon is that I had to repeat boilerplate code for generic CRUD methods such as insert, update, delete, etc. At the same time, it didn’t look really easy to provide a CRUD trait for models, given that Slick’s design is heavily centered around the idea of drivers encapsulating the implementation details for all generic concerns (querying, insertion, etc.) and is therefore already making use of large portions of abstractions.

Quickly open errors in your IDE when developing Play applications

Fri, 14 Jun 2013 11:08:23 +0200

A few weeks ago, James Ward announced a new Google Chrome extension (and SBT plugin) to automatically refresh Play framework applications during development in the browser. So I jumped on there being a Google Chrome extension and revived a feature of Play 1 that allows you to directly click on the error message in the browser to open the correct file and line in the IDE.

Getting this to run is pretty simple, below the instructions for IntelliJ IDEA - if anyone has the equivalents for Eclipse, VIM, Emacs, etc. just send them to me and I’ll add them here!

How to disable the Shift + F10 “slow motion” animation on OS X and reclaim the keyboard shortcut

Tue, 04 Jun 2013 10:21:24 +0200

On OS X, when you press the Exposé keys (F9, F10, F11) with Shift as a modifier, you get the animation shown much, much slower. That’s nice and all, but this keyboard shortcut clashes with IntelliJ IDEA’s run shortcut, and there’s no option to turn this off via the default settings.

So here’s how to do it by hand:

Start by opening a terminal, and go to ~/Library/Preferences. There, open the com.apple.symbolichotkeys.plist preference list by typing:

Java impressions after 2 years of abstinence

Mon, 03 Jun 2013 21:20:13 +0200

Today I wrote my first useful Android app, which shows the bus connections from the bus stop next to our flat to the subway line (I didn’t say it was going to be useful for you).

Since I didn’t want to start right away making things more complicated by adding Scala to the mix, I decided to write the application in plain old Java. I haven’t been writing much more than a line of Java in two years, I think - so here are my impressions after this evening’s experiment:

One week on Tenerife

Thu, 25 Apr 2013 10:10:08 +0200

We spent last week on vacations in Tenerife, enjoying the nice climate and all the hiking possibilities.

The highlight of this short stay was to climb on the Teide volcano, in two steps - first to the Altavista hut at 3200m, then to the top, the next morning at 5:45 AM, to catch the sunrise at 3700m.

At the top of the Teide at sunrise, with the shadow of the crater

Dynamic multi-modular SBT project

Tue, 09 Apr 2013 12:18:46 +0200

As the Delving Culture-Hub project grows, I found myself adding module definitions by hand to the SBT more often than what I’d wish for, and for each adjustment of a common value, having to go through all modules and adjust them.

So after a while, I wondered whether it wouldn’t be possible to discover modules dynamically, rather than maintaining them by hand. It turns out that this is a bit tricky, but still possible.

Multi-modular development with Play 2.1

Tue, 26 Mar 2013 15:53:30 +0100

Play 2.1 makes it possible to write completely modular applications, and on top of this, to develop each module separately. I’ve been waiting for this for some time now, and even implemented a custom router based on plugins while waiting for the framework to support modular routing. Now that the wait is over, let’s see how to take advantage of this feature.

The Play documentation describes how to set-up a multi-modular project via SBT sub-projects. What is important to understand here is that:

Activating logging in test mode in Play 2.0.x

Fri, 26 Oct 2012 09:38:47 +0200

Because of a permgen leak related to third-party libraries, the logging in test mode is disabled in Play 2.0.x (there’s a fix coming up in Play 2.1). In some cases, seeing what happens while running a test can be useful - e.g. when debugging calls to various Akka actors that don’t quite behave as expected.

Luckily there’s a workaround, which is to specify a logger for logback by hand when starting play or SBT:

MongoDB-based Cache for Play 1.2.x and Play-Scala

Fri, 18 Nov 2011 22:33:57 +0100

In case anyone needs this: https://gist.github.com/1377952

You’ve got to bootstrap it in some bootstrap job like so:

1

ScalaCacheAccessor.set(new MongoCacheImpl)

It’s only tested with the Press module so far (shared state is evil anyway 😉 )

Writing custom de/serializers for Jerkson

Tue, 01 Nov 2011 19:54:45 +0100

Since I wrote my previous post on how to use Play! Scala with Jerkson, I was asked a number of times how to make use of custom de/serialization for classes. This happens when e.g. the case class you want to de/serialize has a POJO or another complex type that you’d like to have more control over, such as e.g. the BSON ObjectId or Play’s Anorm PK.

Here’s a wrap-up on how you can easily create custom de/serializers and use them within your Play! Scala application. Let’s take the example of the BSON ObjectId, which you will most likely run into if you use MongoDB in the backend.

Play! Scala and JSON

Fri, 16 Sep 2011 22:59:50 +0200

Update: If you need to have custom de/serialization of some types, check out this new post

I’ve been working with Play! Scala for a couple of months now, and the experience is really good - the combination of the Scala language and the sound design principles of Play! make web-development a real pleasure.

One of the aspects I have been fighting with for a while (and which had initially put me off writing my first bigger Play! application with Play! Scala) is the lack of simple support for JSON de/serialization. With simple, I mean the possibility to turn a case class into a JSON string and back, and to additionally have access to a couple of more advanced features that are often required (e.g. implementing custom serialization of specific types).

Selenium IDE plugin for the Play! framework

Wed, 23 Mar 2011 15:34:34 +0100

Two months ago we started using the Play! framework for our work at Oxiras (as I am writing these lines, the Oxiras website is still totally empty, this should change soon however).

As we started making UI tests using the excellent integration with the Selenium test runner, we quickly noticed that also having an integration with the Selenium IDE plugin would make our lives much easier. So I looked a bit around, found that creating a Selenium IDE formatter was not all too hard and here we go with what I can call my first Firefox plugin.

Information Retrieval

Fri, 11 Feb 2011 11:58:17 +0100

This morning I spent some time looking for information on how to deploy a legacy webservice on Apache Karaf.

This post isn’t about Karaf and OSGi and webservices though, but a reflection on how to efficiently find information that can lead towards a specific technical problem on the Internet. For quite some time now I feel that this task has become much more complicated in the past 2-3 years than it used to.

Deploying a GWT application as OSGi module with Apache Karaf and Maven

Wed, 15 Dec 2010 15:20:14 +0100

In a project I’m currently working on we use the OSGi platform in order to achieve higher modularity (the project is about building a framework for massive data ingestion and processing for a high-availability service, and the processing is dealt with via workflows that are composed of a number of plugins that we don’t develop, hence the need for modularity).

We use the Apache Karaf framework, which offers neat extension points and means to customize it. One of the nice features is the WebConsole that can also be extended, which would provide the means to add a GUI for the users. However, this happens through providing a Servlet implementation, which isn’t really handy these days when wanting to develop a bit more complicated GUIs.

Debugging ANT tasks in IntelliJ IDEA

Wed, 08 Sep 2010 20:14:20 +0200

I recently started using IntelliJ IDEA in addition to Eclipse after seeing it being used by some dutch colleagues of mine. And I must say that I do like it more and more every day — it just has all these many little things that fill so well to Java.

One thing I do miss though is the ability to debug ANT tasks. In Eclipse, you can make an external launcher, select one or more targets, and run them in debug mode. With IDEA, that just doesn’t seem to work. I did install the ANT debugger plugin which makes it possible to debug through the build file, but that’s not still what I wanted.

Early rising

Thu, 01 Apr 2010 07:43:01 +0200

The headache is bad, the coffee tastes bitter, but I still keep on fighting.

This is what a diary of mine would sound like, if I were keeping track of my journey of becoming an early riser.

I got inspired by this post and decided to try out if I could get up earlier. Doing the switch from getting up at around 8 AM to 6 AM when the summer time started (effectively getting up 3 hours earlier each day) doesn’t make it any easier. Let’s see how it goes!

New CV

Tue, 01 Sep 2009 11:00:59 +0200

Have you ever written a CV as part of a lecture at university (yes, in France, there are such lectures), a seminar for young graduates, or have you ever gotten feedback from the professionals in the branch?

I did. It always ended up with some frustration - all the small pieces of creativity would get marked in red as “too unusual”, and in the end my CV (the one through which I got into my current job last year) looked very standard (or as some may say, professional).

How I stopped reading the news and feel much better now

Thu, 09 Apr 2009 21:12:30 +0200

Over the past years, we have been given the access of increasingly more and more information. Not only are we given the opportunity to get nearly real-time information about all the terrorist attacks, accidents, revolutions and other events happening around the world, but with the evolution of mobile services, we get access to this information just everwhere.

Like Tim Berners-Lee points out in his last TED talk, there is an even greater potential to the world wide web - the interlinking of raw data, and not just documents, making it possible to get a new kind of understanding of the world.

Following through with dreams in rough times

Mon, 09 Mar 2009 19:57:45 +0100

For a while now I am following the Illuminated Mind blog and even purchased Reclaim your dreams (and also started reading it, though I still have something to do about the “finish reading it” part). The blog deals with how to get out of the trap of a job and life you don’t want, and raises challenging questions.

Today in the tramway back home I listened to Plan B, a recent episode of This American Life (which is great for a european listener like me since it communicates some of the culture of american life - or at least that’s the impression I got). This episode illustrates how many people live Plan B (or C, D, E…) of their life, because Plan A didn’t work out or didn’t turn out to be that good.

The cost of simplicty in technology

Sun, 14 Sep 2008 13:30:50 +0200

Recently I decided to try out a new kind of computer and bought a MacBook Pro. After many years on PC, which never really satisfied me in matters of simplicity of use, I wanted to give a shot to this kind of computer.

So what to say?

the design is nice, the computer becomes an eye-candy and I don’t spend my time removing dust from the screen or the keyboard (it looks as if the aluminium casing was dust-repelling)
the visual effects and graphics of Mac OS X feel good - and it matters. After all, the computer being my main working tool, it is important for me to have a nice, ergonomic working space (it is not just a tool, but a space full of virtual tools)
there is a lot of free software out there which works for the Mac, and for the moment I did only buy Microsoft Office (at a student price that is)
Mac OS X Leopard comes with Java 6, so it isn’t a problem for development, unless you need something very specific that is OS-dependent (but even then, VirtualBox makes it possible to run Linux or else)

However, I think that one important point with the Mac (or the whole “switching to Mac” thing) is to commit fully, in ways I am going to elaborate about now. Indeed, besides the (obvious) cost of money, there are other costs that come with using a Mac. For example, after you purchase a Mac, you’ll need to keep up with continuous upgrades, and if you’re not too tech-savvy about the whole process, you could continue reading at this website to see how experts can assist you.

The pain of configuration and ideas for making it a bit more bearable

Thu, 14 Feb 2008 21:15:32 +0100

Three weeks ago, I decided to give up on my Windows operating system and try again using Linux (the Ubuntu release). Windows had been running fine for a while, but it ended up becoming very, very slow, and just too unreliable. I had been using Linux before in order to work on my previous laptop, and I thought I could give it a try again.

Now what happened of course is that I spent a lot of time configuring the OS. I eventually succeeded (though I am not completely sure yet, surprises keep arising as I go). During the process, I also had to send back my laptop to Lenovo (I own a Thinkpad T43) because the computer was overheating (but nevermind, this was another issue that I may be writing about later).

Twitter, geolocalisation and pervasive games – mixing virtual and real life

Wed, 30 Jan 2008 22:08:52 +0100

Today I created an account on twitter after reading an article at academhack. Apparently there seem to be some interesting usages of this micro-blogging tool, like increasing communication amongst members of a same community. Whilst the article on academhack emphasizes the educational usages of the tool, I wonder if the same thing wouldn’t work in other settings. Then again it may be that belonging to several communities would clash - how to do “directed twittering”, what to prioritise when writing and how to keep up with the additional information flow?

Reset

Sat, 19 Jan 2008 01:09:03 +0100

Welcome!

If you have been here before, you will notice, past posts have disappeared. Probably, they were too short to sustain a Reset.

1
2


re<br />
set

Maybe this time I will manage to write something sustainable?