Java on Maarten on IT

Coding, Thinking and Adapting: My Take-Aways from Devoxx Poland 2025

Mon, 16 Jun 2025 21:53:00 +0200

Six years after my first Devoxx Poland visit, I was invited there again to present. This time, I had the opportunity to give two talks instead of just one. Apart from speaking, visiting a conference is a great way to also join other speaker’s sessions. In this blog, I will share some of the most inspiring talks I attended. Topics include mutation testing, monads, tips for smooth-running applications in production, effectively working with AI and hexagonal architecture. Continue reading for my recommendations from this year’s edition!

Authenticate Jakarta EE apps with Google using OpenID Connect

Tue, 20 Aug 2024 10:02:00 +0200

In one of my pet projects, I’m writing a Jakarta EE web application where I want users to authenticate using Google. Easy, you would say, as Jakarta EE 10 includes Jakarta Security 3.0, which has support for OpenID Connect authentication. Took me a bit more time to figure out how to get it working, and to save you from having to do that, here’s what I found.

Reduce Maven Plugin logging

Tue, 16 Jul 2024 08:16:00 +0200

Sometimes, a Maven plugin logs more then you want it to. I recently had this situation with a plugin that generated source code from specifications. This plugin alone wrote over 22000 lines of output just to inform the user that it did what it had to do. No errors or such, only confirming that it did its job. Such superfluous output makes it hard for developers to focus on actual problems in their build. It’s too easy to think “too long, didn’t read” (TL;DR) and hence miss the important bits. So, it’s time to tame the plugin logging!

Devnexus 2024

Wed, 10 Apr 2024 18:50:00 -0400

This year, I again have the pleasure to join Devnexus and speak there. In this blog, I’ll highlight some of the sessions that I’ve joined.

Measure Your Maven Build

Fri, 15 Mar 2024 09:46:00 +0200

Slow builds are annoying!

There, I’ve said it. And you know it’s true, don’t you? They take valuable time, they are a source of frustration, they extend the feedback cycle, and often they provide the perfect excuse for slacking off.

But it doesn’t have to be this way! Rather than getting another cup of coffee or playing that medieval game of gladiator, what if we would investigate why the build is so slow? If we know the bottlenecks, we can address them. That would shorten the feedback loop, increasing our productivity and our job happiness in one go.

Why Write Boring Apps?

Fri, 01 Mar 2024 15:00:00 +0200

If you’ve built any kind of web-based application in the last decade, chances are you were building a single-page application (SPA). This means you’ve been writing JavaScript or Typescript, had to work with the Node Package Manager or Yarn, needed to understand a framework like Angular, React or Vue and had to learn a new testing framework (or two). And that would have been only the basics. You would probably use other libraries, frameworks and toolkits: for styling the user interface, for doing API calls using REST and/or GraphQL, and for writing reusable components. But we usually take the pain, because the alternative is just… “boring”.

But it is time to reflect on this approach. It drags in a lot of complexity, but what does it give us? More complexity! At the end of the day, everyone will probably agree that simplicity is important. And what we want to achieve is a simple thing: displaying some information to a user. So why all that complexity?

Devoxx 2023: First Impressions

Mon, 09 Oct 2023 12:04:15 +0200

This week, I’ve been attending Devoxx Belgium. It wasn’t my first time around, so I more or less knew what to expect in terms of atmosphere, content and people. In this post, I will share my first impressions. It includes some interesting talks that I joined. Of course, there were more - but those require a larger post, so those may end up in a seperate post later.

Devnexus 2023 live blog

Wed, 05 Apr 2023 17:49:15 +0200

This week, I’m attending the 19th edition of the Devnexus conference in Atlanta! In those 19 years, Devnexus has truly grown to being one of the biggest Java and JVM-related conference in Nothern America, and it’s always been a pleasure to be there. This year marks my fourth attendance as a speaker, and I’ll be doing two talks myself.

In this post, I’ll be live blogging about some of the sessions that I’ve joined. Enjoy!

Notes from JavaZone

Mon, 12 Sep 2022 21:56:13 +0200

Last week, I attended JavaZone, the annual conference ran by javaBin, the Norwegian Java User Group. I have attended JavaZone in the past (2018) so I knew what to expect - and the bar was high! Because of that, I was looking forward a lot to join JavaZone again. Also, this would be my first conference as a Java Champion, which made it even more special.

Using HSQL in OpenLiberty

Tue, 23 Aug 2022 08:46:13 +0200

A quick note, this time. Recently, I wanted to do some hacking around on Jakarta EE and MicroProfile. I chose to work with the OpenLiberty runtime, as I previously had good experiences with it. My pet project also needs a database, so for starters, I chose HyperSQL Database (HSQL DB). Here’s how I set it up.

Mutation Testing badge with PIT and Stryker Dashboard

Sat, 30 Jul 2022 10:41:13 +0200

Earlier, I wrote about integrating PIT with the Stryker Mutator Dashboard. The setup for that was pretty complicated, with some shell scripting that extracted the JSON payload for the report from a JavaScript file. Today, I’m introducing a much simpler approach to that: the Stryker Mutator Dashboard reporter for PIT.

Playing with Loom

Fri, 04 Mar 2022 08:39:13 +0200

If there’s one topic that has kept the Java community excited over the last years, it’s Project Loom. We all know it’s coming someday, but when? What will it look like? And how will it change the way we write concurrent code? In this blog, I’ll try to play a bit with what Loom currently looks like.

The Dapr SDK for Java: Pub/Sub & Distributed Tracing

Tue, 11 Jan 2022 09:36:13 +0200

It’s been a while since the first two posts about Dapr! In those first installments, we looked at the basics of Dapr, from a very conceptual point of view. We also looked at the bare minimum HTTP API that Dapr exposes to the applications that use it. But writing enterprise applications that way would be slow, and it would inevitably lead to mistakes. In this article, I will introduce you to a higher abstraction level of working with Dapr.

Jakarta EE meets Dapr

Tue, 28 Sep 2021 09:46:13 +0200

Earlier this month, I introduced you to Dapr, the Distributed Application Runtime. That was a mostly conceptual introduction, showing you how Dapr works and what it can do for you. But how do you integrate it into an existing application? That’s the topic for today.

Getting to know Dapr

Fri, 10 Sep 2021 10:46:13 +0200

Building distributed applications or microservice applications brings a whole new range of problems. All those application components, or microservices, need to communicate with each other. How will we do that: using messaging, or would direct HTTP calls be a better choice? Often, we must make such decisions early in a project. Since it’s hard to change it later, we call it an “architectural decision”. But this is often an excuse so we can blame the architect if the choice turned out to be wrong.

Build your own OpenJDK on macOS

Mon, 31 May 2021 08:31:13 +0200

Following the recent kerfuffle around the security manager deprecation, I was curious to see if a codebase I’m working on would also suffer. But how could I find out? There are no early access builds of Java 17 yet with the latest changes for this JEP. Maybe… I should set out and try to build it myself? But that’s sure going to be a lot of work… Or is it?

Introduction to Maven Toolchains

Tue, 16 Mar 2021 08:31:12 +0100

Java evolves at a much faster pace than it used to do. But not all of the projects we work on keep up with that pace. I have projects on Java 8, 11 and 15 - and sometimes I want to play with early access builds of newer versions as well. How to make sure I can build them without having to constantly switch Java runtimes?

What's New in Maven 4

Mon, 30 Nov 2020 08:02:09 +0100

Recently, the Maven community decided to push forward and start working towards a 4.0.0 release. The first question after this announcement is of course: what can we expect Maven 4 to bring us? A lot - and in this post, we want to highlight some of the features that we are particularly excited about.

Mutation Testing badge with Pitest and Stryker Dashboard

Tue, 30 Jun 2020 13:18:13 +0200

Over the years, badges have become a way for open source maintainers to show the state of their product. Badges can give a quick overview of the code quality, test coverage or build health of an open-source product. The problem with code coverage is, however, that a high coverage doesn’t mean the tests are any good. If only there was a way to show the quality of the test suite…

DevNexus Day 1: WebAssembly, Productivity

Fri, 21 Feb 2020 15:20:13 +0200

Together with four “AwesomeSauce” colleagues from Info Support, I’m attending DevNexus this year. For me, it’s the second time I’m here, as I spoke here in 2018, too. Next to delivering my own “React in 50 minutes” session I’m attending some sessions to update with new technology advancements.

Customise the Maven Release process

Fri, 10 Jan 2020 09:30:13 +0200

Shipping a new release of software usually involves quite a few steps. Depending on the type of software, this may be something you rarely do. Thus, it often involves manual steps. This is not necessary! Maven has had its “Release Plugin” since approximately April 2007; yes, that’s over 12 years! It has served both the Maven project and many other software projects.

Code One - Day Three

Wed, 18 Sep 2019 20:08:00 -0700

Third day on Code One already! Highlights for today: the Community Keynote, a trip to GitHub and a session called “Sarcasm as a Service”.

Code One - Day Two

Tue, 17 Sep 2019 16:11:00 -0700

On this second day at Code One I have again visited interesting sessions. One on security by Jim Manicode and one on cash (or the lack thereof) in Sweden.

Code One - Day One

Mon, 16 Sep 2019 18:42:32 -0700

This year I’m returning to Oracle Code One (formerly JavaOne) for the third time. I’m planning to write some notes on interesting sessions or other content.

How did I get that library?!

Wed, 11 Sep 2019 18:42:32 +0200

When you’re writing Java applications, chances are you’re using Maven for dependency management. It lets you declare the artifacts you need to build your application. Those artifacts also depend on other artifacts. This means you have transitive dependencies - dependencies you didn’t declare yourself but you need them anyway.

Reports from Devoxx PL

Tue, 25 Jun 2019 14:00:13 +0200

From yesterday until tomorrow I’m attending Devoxx Poland (or Devoxx PL for short). It’s the second largest conference in the Devoxx family with around 2700 people attending. The conference is held in the ICE Kraków Congress Centre, a large venue with an amazing primary room.

Entrance of the ICE

The main reason I’m here is to give a talk about GraalVM on Wednesday morning. Apart from that, it’s a nice opportunity to network, meet old friends and make new ones. And of course to attend other talks to learn something new.

A first look at MVC 1.0

Fri, 14 Sep 2018 21:20:19 +0200

Recently, Twitter brought the renaming of Ozark to Krazo to my attention. It pulled my attention: I had never heard of either projects, and I wondered what they would be about. Ozark (or Krazo) will be the Reference Implementation of the new Model-View-Controller Specification. This MVC specification, also known as JSR 371, was planned for inclusion in Java EE 8, but eventually dropped. Apparently, this didn’t kill the effort. I was curious to see where the specification (and it’s implementation) would be now.

Custom SOAP Faults using Spring WS

Tue, 24 Jul 2018 16:05:35 +0200

There are many situations when you need to write a SOAP-based webservice. Maybe you are writing a test dummy, or maybe you got the interface from some kind of architect. (Yes, there are other reasons, too.) And chances are you’ll be using Spring-WS to do this.

Recently I was doing that, and I found the following inside the interface definition (WSDL):

<element name="faultMessage" type="common:FaultMessage"/>

<message name="faultMessage">
 <part name="faultMessage" element="tns:faultMessage"/>
</message>

<portType name="someName">
 <operation name="searchOrder">
 <input message="tns:searchOrderRequest"/>
 <output message="tns:searchOrderResponse"/>
 <fault name="faultMessage" message="tns:faultMessage"/>
 </operation>
</portType>

That was a rather challenging thing! In case the operation would fail, it should give a SOAP Fault with a custom element in it:

Impressions of the first JVMCON

Thu, 01 Feb 2018 20:17:00 +0200

Last Tuesday was the first edition of JVMCON. This conference has a special programme committee: its audience. When the Call for Papers closed, everyone who had a ticket could see the submitted papers. Only, they could not see who submitted the paper - which let them focus on the papers themselves. Out of almost 180 papers, they had to select 13…

And guess what: one of them was mine! I presented my talk for the early birds, and there were quite a lot of them! The room was pretty much packed, and there was a lot of questions and remarks afterwards. That surprised me a bit, since I usually do not experience a lot of interaction with the audience.

I upgraded to Java 9 - Part II

Tue, 23 Jan 2018 16:14:35 +0200

A few weeks ago, I wrote about migrating an existing Spring-application to Java 9. When I finished, two things remained to be investigated:

Code coverage for unit tests.
A bunch of warnings when running the application in Tomcat.

Code coverage for unit tests

As Alan Bateman pointed out, upgrading JaCoCo to its latest version should resolve the issue about the $jacocoData field. In fact, I thought I had done that, but somehow I kept on getting the same error every single time. But when I tried (again) last week, it somehow disappeared. No error to be seen, all tests green, and a nice coverage report from JaCoCo. I’m a happy developer, again!

I upgraded to Java 9 - here's what happened

Fri, 12 Jan 2018 20:28:35 +0200

I recently participated in a Twitter conversation about upgrading to Java 9. Like most of the people, my current projects are all on Java 8. Of course the question came up, why don’t you upgrade? Good question! Since I hadn’t even tried, I decided to see how far I could come…

The component I took for my experiment is a pretty simple Spring application. It doesn’t use Spring Boot. It exposes a few REST endpoints, and calls couple of webservices over SOAP. For these webservices, it uses bindings generated by the JAXB plugin for Maven.

Devoxx 2017

Sun, 07 Jan 2018 14:15:35 +0200

Almost two months ago I visited Devoxx 2017. It’s about time to write some notes on the stuff I learnt there!

Event Storming & DDD workshop

The week started off with a full afternoon workshop led by Stijn Vanpoucke. The workshop consisted of small pieces of theory, alternated with exercises using post-it’s and markers.

A few of the theoretic pieces:

An event is something that has happened in the past. It is usually phrased in past tense. It should be understandable for business users.
A command is an user-initiated action. It explains the origin and sometimes the reason for the action.
An entity is an individual thing. It has a unique identity. Often, entities are mutable.
A value object is an non-unique value. It is often immutable. Its equality is based on it’s attributes. It should be able to validate itself. They can be combined.
An aggregate is a combination of entities and value objects. They are structured in a hierarchy. Its root is always an entity. Aggregates contain business rules. Note that a bigger aggregate is not always better! To circumvent this, aggregates can use soft links based on the unique identity of other entities.
The bounded context describes the context from which you look at it. Take a pen as example; what a pen is depends on the context from which you look at it. To stress the fact that it has boundaries, it is called a bounded context. Bounded contexts support the idea of having “one team, one (business) language”. The bigger the bounded context is, the bigger the language, whether artificial or natural. Finally, multiple domains can have different words for the same concept. A sales department might speak of products while inventory management might name the same concept article.

Kotlin for Java programmers

This year had a lot of talks about Kotlin scheduled. To visit them all would take too much time, so I decided to follow just one by Venkat Subramaniam. I figured it would give me about the same amount of content…

Getting Started with Zuul

Sat, 30 Dec 2017 14:15:35 +0200

It’s been a while since my last post! I recently have been reading a lot about the idea of “API management” or an “API gateway”. There’s a lot of commercial offerings in this field. Many of them promise you (to some extend) ultimate flexibility and endless possibilities. My preference is for “lean and mean” approaches where I can pick the building blocks that I need. In the long run, that offers more flexibility. After all, you could replace building blocks. Having small building blocks makes it less tempting to put any kind of business logic in such a gateway. Doing that must sooner or later lead to some kind of vendor lock-in.

JavaOne 2017

Fri, 06 Oct 2017 15:05:45 +0200

This year, I had the pleasure again to visit JavaOne. Not only did I attend the conference, I was also accepted to speak, which was quite a dream come true. The session catalog contains almost 500 sessions, and I obviously visited only a subset of them. I found two topics particularly interesting and decided to attend multiple sessions on each of them.

“Prepare for JDK 9” and “Migrating to Java 9 Modules”

Both sessions where more or less covering the same ground, although from a different perspective. Alan Bateman from Oracle took the more theoretical view and explained what you can expect to happen when you want to move to Java 9. He also busted some myths, like the one that “nothing will continue to work” or “everything first needs to be modularised”.

JBCNConf & Voxxed Days LU

Thu, 22 Jun 2017 15:05:32 +0200

Wow, that was a busy and inspiring week! In one week, I’ve visited two conferences in two different countries to give talks on two different subjects. But the most inspiring part came from attending other sessions. I’ll highlight one session from both conferences.

JBCNConf 2017

On JBCNConf, I’ve attented a session by Burr Sutter about Vert.x. This was a session full of energy, as Burr is really capable of making your enthusiastic of whatever he is talking on. As he walked us through the various options you have to build and deploy Vert.x-based applications, he also showed a lot of demos. One of the demos involved “simple” temperature sensors over MQTT on miniature computers (aside: the size of these computers was largely dominated by their batteries… impressive!) to his MacBook showing you can run Vert.x in multiple languages that still communicate with each other. It also illustrated how to handle events coming in at this pace, introducing the concepts of streaming events.

Verify logging with Logback

Thu, 02 Mar 2017 10:15:32 +0200

Sometimes you have a piece of logging that is very important, maybe even part of a business requirement. In that case, you might want to verify that in a unit test, so you can rest assured that this requirement is actually met. How to do that?

Mock it away

A first approach might be to just mock your logging framework in a unit test and verify it was called as you expected. It might sound tempting, and easy to do, but not everybody likes it. And in fact, you might run into some issues when walking this path, because some libraries tend to make classes and/or methods final so they can’t always be mocked away. Also, a lot of people tend to create a logger by doing private static final Logger LOG = ..., which makes it even harder to mock it away. Making your logger an instance variable just so you can test it? Nah…

Blah blah Microservices blah blah

Sat, 25 Feb 2017 20:15:40 +0200

As a closing keynote on the second day of Jfokus, Jonas Bonér took the stage under the very clarifying title “Blah blah Microservices blah blah”, which turned out to mean “From microliths to microsystems”.

As a first observation, he stated that no-one really likes microservices. They are kind of a necessary evil - because “doing” microservices comes at a cost. In fact, microservices are just a specialisation of an older concept called distributed systems. But what we often build are microliths - an application that might be called a microservice except for the fact that it lives alone. No failover, no resilience, nothing. But just like actors, microservices should come in systems. And just as important, microservices should come as systems, designed as a distributed system, which each microservice focussing on a single responsibility.

Jfokus, Day 2

Wed, 08 Feb 2017 16:30:40 +0200

The second day of Jfokus is just as action-packed as the first one. However, part of the action is me giving two talks. Both of them scheduled today, so a little less time for attending other sessions and blogging about them. I did attend some other sessions after lunch time, on which I’ll report below.

Introduction to Machine Learning

Directly after the lunch, James Ward gave an introduction to machine learning. He started with a very recognizable story about how humans (in casu his daughter) learn new facts about the world around them. Machine learning is in fact no different than human learning: building a model, trying something, seeing whether and how it changes reality and updating the model.

Quickly switch Java versions on macOS

Tue, 07 Feb 2017 18:06:40 +0200

Inspired by a Jfokus session I attended today I decided to download and install a preview of Java 9 on my MacBook. That went pretty quick and without much trouble. But when I issued java -version on my terminal, I was greeted with

Java(TM) SE Runtime Environment (build 9-ea+155)
Java HotSpot(TM) 64-Bit Server VM (build 9-ea+155, mixed mode)

Although that’s nice - you’d even expect it, maybe - I realised I often need Java 8 as well. How to quickly switch between the two?

Jfokus, Day 1

Tue, 07 Feb 2017 08:10:40 +0200

These days, I’m in Stockholm, attending and speaking at the Jfokus conference. Yesterday night was a great opportunity to get to know a few other speakers during dinner. We were even surprised by an act of the Lemon Squeezy barbershop quartet singing for us - very beautiful!

But today, the serious stuff started. In the following sections, I have written down my notes and observations of each of the sessions I attended.

Automatic scan for known vulnerabilities in dependencies

Tue, 30 Aug 2016 15:30:40 +0200

When using third-party components (be it open source or not), we all know it’s a good practice to keep your frameworks and libraries up to date. This is also one of the spearhead in the OWASP Top 10 (2013 edition): A9 - Using Components with Known Vulnerabilities. To help you assess your projects status with regard to this, OWASP.org developed the tool Dependency Check. This tool is primarily intended code bases in Java, .NET, Ruby, Node.js, and Python. Integration with various build tools is also provided for.

Easily upgrade Java dependencies

Wed, 20 Jan 2016 17:11:40 +0200

To start with a cliche: the Java ecosystem continues to develop at a high pace. Various open source frameworks releasing versions, sometimes even multiple versions at the same time. This may quickly turn into a risk But how to deal with it?

Basically, you have two options. We’ll take a typical Maven-project as an example, which uses Commons Lang 3. See the end of this post if you prefer Gradle over Maven.

Automatic upgrades

Maybe the simplest way is automatic upgrading. You can achieve this by not specifying an exact version of your dependency, but instead specify a version range. If you would normally have this snippet in your POM:

This method is likely to yield significantly better performance

Sat, 06 Apr 2013 14:57:21 +0000

This week, I came across an interesting difference between the Java API documentation and its current implementation. A difference? Or is it just a matter of thorough reading?

If you look at the Javadoc for Double.valueOf(), you’ll find that it is likely to outperform the use of new Double(). Sounds good! And don’t we all ove it when we get a free performance boost?

However, examining the source code to see what causes this “significantly better space and time performance”, we find….