IT on 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.

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:

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

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).

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.

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.

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.

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.

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.

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.

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:

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.

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.

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.

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.

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.

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.

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.

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)

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:

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.