Magnus' blog

Posts

• 2026-02-18 - My Wedding Invitation Benchmark Has Been Broken

  Back in 2024 when we were getting married, my wife designed a beautiful paper wedding invitation:

  
  

• 2025-10-18 - Java Value Objects: record vs Lombok

  This post explores how to model Value Objects in Java using record and Lombok. In Domain-Driven Design (DDD), a Value Object is an immutable type defined entirely by its attributes, not by a unique identity. Two Value Objects are equal if all their values are equal. They enforce their own domain rules, ensuring that objects are always valid.

  
  

• 2025-10-07 - Measuring Java Code Coverage from a Running Jar

  In Java projects, JaCoCo provides an effective way of measuring test coverage. Most IDEs support using it out-of-the-box, any type of run can produce coverage data. In most projects, it is quite easy to set it up to run alongside standard JUnit or Spock tests. However, it is also possible to spin it up alongside a running application, where you can record coverage of end-to-end tests, UI tests, and manual tests. This post explores how we capture code coverage for running these tests.

  
  

• 2025-10-06 - Practical Java Test Data Builders with Lombok

  This post demonstrates a practical example of a Java Test Data Builder using the Lombok annotations @Setter and @Accessors(chain = true, fluent = true) to minimize boilerplate. The concept of using test data builders has been presented in previous blog posts:

  • Test Data Builder
  • Test Data Builders with Related Data
  • Complex Test Data Builders
  
  

• 2025-10-05 - Speeding Up Multi-module Gradle Integration Testing

  TL;DR: By using a centralized JUnit Test Suite and shared Hibernate EntityManagerFactory, we drastically reduced integration test times in a large Gradle multi-module build from ∼15 minutes to ∼3 minutes.

  
  

• 2025-10-04 - A Reusable Hibernate TestBase for Integration Testing

  This post shares a fully-featured TestBase for Hibernate that allows you to do Integration Testing with a Real Database. This TestBase approach has been successfully used in production and development projects, so it is very well tested. This specific code was written specifically for this post and is free to copy.

  
  

• 2025-09-28 - Why, how and when to use PostgreSQL enums in Java

  There are a few different ways of storing Java enums in a database. This post explores Ordinal values, Enum names, Custom values, or Native enum types, each with its own use cases. It focuses on using the PostgreSQL native enum type. A native enum type is only needed in cases where the application does not have complete control over the data in the database. Specifically, the protection the enum type provides is only helpful in situations where another actor can modify the data. Such cases include migrations from previous databases, shared databases, and heavy reliance on manual modification.

  
  

• 2025-09-27 - Implementing a CQRS Message Bus in Spring with ResolvableType

  An important aspect of Command Query Responsibility Segregation (CQRS) is decoupling the actions a system can perform from the way it performs them. This is usually implemented with a message pattern, where the entry points of the system construct an object corresponding to an action that should be taken, and the internal system executes it. This pattern is known under multiple names, such as mediator, bus, or dispatcher, but this post uses dispatcher. It is typically implemented in the following way:

  
  

• 2025-09-26 - Speeding Up Gradle Sync in Multi-Module Spring Boot Projects

  TL;DR: Switching from the Spring Dependency plugin to Gradle Platforms reduced Gradle Sync time from ∼4-15 minutes to ∼1 minute.

  
  

• 2025-09-22 - Project: Offline MP4 Converter

  MP4 is a great web format: the files are relatively small while still maintaining good quality, and they behave much like GIFs but at a fraction of the size. I wanted a way to easily convert demos and screen recordings into MP4 so I could share them on this blog without bloating page load times. My usual recordings are in the .mov format and are quite large. Converting these without downloading external tools usually means using a cloud service that requires uploading your files. Alternatively, you need to install a tool to do it locally. I wanted a middle ground where I could do the conversion locally, but without installing new software. For this purpose, I built the Offline MP4 Converter.

  
  

• 2025-09-14 - Project: Offline Image Converter

  Offline Image Converter allows you to convert between different image formats directly in the browser. It compiles the Rust image crate to WebAssembly and provides a frontend for converting between the supported image formats. Most of the functionality from the Offline PDF Merger was reused to allow for a quick development period of only 3 days. This post explores the interesting technical challenges of the project.

  
  

• 2025-09-09 - Project: Offline PDF Merger

  During my studies, before every exam, I had a period where I needed a PDF Merger to collect all lecture notes into a single slideshow that I could easily search for information. This wasn’t supported by default on my PC, and the only options were online mergers that required uploading the files or a premium version of Adobe Reader. That’s when I came up with the idea of an Offline PDF Merger using WebAssembly to run an open-source program locally.

  
  

• 2025-09-01 - Project: AnchorURL - Shareable URLs

  Sharing links through physical media is not trivial, because the recipient has to type them out manually. I recently encountered this problem at work, where we had to share a SharePoint document link through a PowerPoint. A custom link was created with a link shortener, making it easier to type. Later, the SharePoint link broke during an update, but the original creator had left the company. I wanted a service that would make it easy to edit a link later. Combined with my interest in diving into the technical aspects of link shorteners, I decided to build AnchorURL. The idea was to optimize it for speed and robustness, while keeping it as cheap to run as possible. This post explores the different techniques I used.

  
  

• 2025-08-10 - Minigame: Guano vs Cars

  Back in 2023, my wife and I decided to spend some time developing a fun little game for mobile. We made the game, but never published it. This summer, we refreshed it so it could be published on the web.

  
  

• 2025-07-25 - Integration Testing with a Real Database

  In software systems that use a database as their primary data store, it’s important to include the database in integration tests. This provides the most accurate representation of how the system behaves in production. You should never mock the database. But this raises an important question: How do you use a real database in an integration test?

  
  

• 2025-07-24 - Complex Test Data Builders

  The Test Data Builder Pattern works incredibly well for constructing test data in a consistent and readable way. It’s easy to set up for simple domain objects without many constraints. However, it becomes trickier when dealing with domain objects that enforce strict rules or state transitions. This post explores how to build a more complex Test Data Builder that respects domain rules and disallows invalid configurations.

  
  

• 2025-07-22 - Test Data Builders with Related Data

  Integration tests often require a lot of related data to satisfy foreign key constraints. If your database enforces these constraints (as it should), setting up test data becomes verbose and repetitive. This typically results in large amounts of duplicated setup code scattered across your test suite—code that’s hard to maintain and distracts from the actual purpose of the test.

  
  

• 2025-07-21 - Domain-Validating Deletion

  Deleting entries in a database is quite straightforward. In SQL, you might write something like:

  
  

• 2025-07-19 - Modelling Draft Objects

  In applications with complex forms, users often need to save their progress to return later or hand the work over to someone else. These drafts are therefore incomplete and contain empty fields or partially filled objects. Representing this in a domain model is challenging, as the domain typically requires valid, complete data for the process that follows submission. This post explores different approaches to modeling such drafts.

  
  

• 2025-07-12 - Never Mock the Database

  When writing automated tests, it’s common to mock or simulate the database. The motivation is clear: mocks are fast, easy to set up, and avoid the overhead of managing a real database. Frameworks like Entity Framework Core offer in-memory implementations that make this approach even more convenient.

  
  

• 2025-07-11 - Test Data Builder

  In unit and integration tests, the construction of test data often becomes bloated and duplicated across projects. This makes it harder to clearly express what a test is verifying and increases the maintenance burden when changes occur over time. The idea behind the Test Data Builder pattern is to introduce a common utility for constructing test data that includes only the data relevant to the specific test. The goal is to make tests as readable as possible while keeping domain objects easy to extend and change.

  
  

• 2025-07-09 - Exceptions are for Exceptional Behavior

  Exceptions are used in many object-oriented languages to handle failures. They provide an alternative control flow that allows you to skip normal method execution. This can be a powerful way to signal errors, but it also introduces invisible state that can be hard to reason about. This post argues that exceptions should only be used for exceptional or unexpected situations, not for regular control flow.

  
  

• 2025-07-06 - Don't rely on the File System

  File systems are ubiquitous in development environments, but this availability often leads developers to assume file access will always be present. This assumption can cause issues in production, especially in containerized or cloud setups. There are two important questions that are often overlooked:

  • Does the program have access to a file system?
  • Is the expected output truly a file?
  
  

• 2025-06-08 - Teams should prioritize live code reviews

  Pull requests were originally created by open-source communities to enable asynchronous collaboration on shared codebases. In these environments, contributions are often reviewed over several days or even weeks, since many contributors participate part-time. This asynchronous approach works well in such settings, allowing maintainers to review code when it’s convenient for them.

  
  

• 2025-06-07 - Complexity vs. collaboration

  The ability to unit test code is highly correlated with the modularization of said code. The more modular code is, the easier it is to write accurate tests for it. When code is tightly coupled, writing good unit tests becomes nearly impossible. Therefore, unit testing has introduced new ways of thinking about code. This post is about one such important concept: separating code into complexity and collaboration. This not only helps with unit testing but also improves modularization and long-term maintainability.

  
  

• 2025-06-06 - Code smell: Public setters

  Public setters have two huge problems: they expose the internal state of objects and therefore increase the coupling of the system over time. This might not be obvious to new developers or to experienced developers who haven’t worked in systems with strong encapsulation practices. Therefore it is a widely used practice that hurts software quality in the industry. Sometimes setters are useful, but there are major downsides to long term maintainability. Overall code becomes clearer and easier to work with over time if public setters are omitted.

  
  

• 2025-06-04 - Don't name it Service!

  Developers often fall into the trap of naming classes XService — like FoodService for food-related logic. Over time, FoodService accumulates methods like add, save, get, build, getMore, and even getXWithYWhileZ. This pattern leads to bloated, unmaintainable code that violates core design principles and creates tightly coupled systems.

  
  

• 2025-05-24 - Intentional Validation: Ditching Frameworks for Clarity and Control

  In most applications, validation is typically done using a validation framework that helps setup validation faster. This article argues that using these validation frameworks is an antipattern to clean code. It introduces complexities that makes the code harder to debug, is hard/impossible to properly test and is not extendable enough. While validation frameworks offer quick setup and standardization, they can introduce hidden complexity and become limiting over time. Instead it is suggested that each project should do its validation manually, because it in the end is more maintainable and stable than the common approach.

  
  

• 2025-05-05 - Eliminating NullPointerExceptions in Java

  In C#, nullable reference types must be explicitly declared. For example, a string is not nullable, but a string? is. By introducing this concept, the developer is forced to consider null for any nullable reference. This concept also exists in languages like Kotlin, a modern JVM language that is fully interoperable with Java. Unfortunately, in Java, all reference types are nullable by default. This post is meant to be practical advice for getting rid of NullPointerException in existing codebases.

  
  

• 2025-05-04 - Feature-oriented folder structure

  In many applications the source code is split into the different layers that the application consists of from a technical architecture perspective. For example with a feature1 and feature2, the following could be the folder structure in a simple onion architecture:

  
  

• 2025-04-29 - Current date is an infrastructure concern

  Getting the current date is an easy task in most languages. In Java you can call LocalDate.now(), in C# DateTime.Now or Rust chrono::offset::Local::now(). This seems quite easy to do, so most developers will do it close to where the date is needed. The argument this article presents is that you want to push this code into the infrastructure layer of your code. This applies both to getting the date and time, but for simplicify, the date is the focus.

  
  

• 2025-04-21 - Code smell: Don't talk to strangers

  “Don’t talk to strangers” can be a useful rule of thumb for identifying code smells when writing code.

  
  

• 2023-06-04 - Code smell: Arrowhead code

  A tip for recognising a common code smell is to look for arrowheads. Consider the following python code:

  
  

• 2023-04-05 - The diminishing returns of rewriting a system without the original authors

  Choosing to rewrite an existing system is a big decision. It usually requires a project to reach a point where the technical debt is too much to deal with, or the technology is so ancient that the compentencies no longer exists. However, it can also come from an engineering team that have gone the wrong way, or chosen to rely on a technology that has become deprecated. This particular story is about the later case. It aims to illustrate the two most important takeaways: domain independence and tribal knowledge.

  
  

• 2022-06-27 - Benchmarking EFCore 3.1 Cartesian explosion problem

  In Entity Framework Core 3.1 any LinQ expression is translated into a single SQL statement. This will not be a problem for most queries, but it can cause performance problems if developers are not cautious of this when crafting queries. This article will introduce a simplified model of a performance problem that was discovered and solved in a production environment.