Development on Ctrl + Champagne

Jumping the queue? Yes, but in constant time

Sun, 29 Mar 2026 14:00:00 +0000

The Problem

Classic interview setup: you walk in, sit down, and the interviewer says:

“Design a FastQueue class. It stores entries, where each entry has a long id and a String family.

You need three operations, all in O(1) time: add(entry), removeLast(), and removeLast(family).

Space complexity is O(N) for all operations.”

Let’s unpack that. You have a queue of entries, each tagged with a family group. At any point, you can eject the oldest entry within a given family, all in constant-time.

JUnit 5 Tricks Recap

Wed, 11 Jun 2025 13:45:56 +0000

JUnit: Lay of the Land & Mutation testing

Alright, what do we know about unit tests?

A unit test verifies an individual unit of code works as expected,
It is small, fast and isolate a single functionality

They are generally named based on what the test verifies, e.g. testInvalidAccountIdThrowsException; they are independent from each other even though grouped in the same class as related tests.

We create them in the same package structure as the source code but under the src/test/java directory. With Maven, tests can be run using lifecycle phases like test, install, etc.

We all need a Holiday Destination Finder

Sat, 12 Apr 2025 13:45:56 +0000

Tiptoeing Through the Asynch Door with the CompletionStage Interface JSE17

When it comes to holidays, I’m as spontaneous as they come. I enjoy not planning and picking the best option available just before or even while traveling.

So I needed a holiday… and a reason to explore Java’s async magic.

We’ll get to this Holiday Finder but first let’s get the theory out of the way, shall we?

Diving Right In

Considering two API calls A & B, API A is called first, and then API B. This is what synchronous code does: it waits before executing the next task and things run in order. However, could the thread blocked on the API response be doing some other work instead?

Lambdas & Single Abstract Method Interfaces

Mon, 24 Mar 2025 11:45:56 +0000

Quick Tour of Java Functional Interfaces

A functional interface is an interface with just one abstract method, such as Runnable, Comparator, Callable, etc. The main benefit of functional interfaces, with the introduction of lambdas in Java 8, is that they allow you to pass behavior (code) to a function the same way you’d pass data (objects) to a method. This means we can pass a lambda expression when a method is accepting a functional interface. Since there is only one function to override, it is possible to infer which function to implement when using a lambda expression.

No Huff and Puff—Just Compress!

Sun, 16 Mar 2025 13:45:56 +0000

The Huffman’s Algorithm

The Huffman’s algorithm was born in 1952 as a way to perform a lossless compression on data files. Its efficiency comes from the frequency analysis of characters present in the text to encode: shorter codes are used to encode more frequent characters while longer codes are used to encore less frequent ones.

It constitutes the foundation of modern text compression.

You can read more on variable-length encoding and tree representations under the Design tag on this blog.

When Strings go wrong

Tue, 04 Mar 2025 13:45:56 +0000

Encoding for Web apps internationalisation

Some theory about Information Content & Entropy

Encoding is the process of converting data from one form into another using an unambiguous mapping. It can refer to transforming human-readable characters into a machine-readable format. The main question it raises is: how many bits do I need to encode ‘a’ (and the rest of the characters)?

The Information Content (Shannon information) quantifies the amount of “uncertainty” associated with a particular piece of information.

`x = Pépin, y = x` I'm Pépin too, says y

Tue, 25 Feb 2025 13:45:56 +0000

Pass-by-Value or Reference: the Great Debate

Background on Heap and Stack

The stack referred to when talking about memory is the same as the run-time call stack. It is composed of stack frames and stores things. It controls the function calls and program execution by storing in its frames the function parameters, the return address, local variables - among other things. The stack has a fixed-size so in some cases, for instance deep recursion, it can run out of memory. Remember this one time you forgot a stopping condition in your code and got a StackOverflowError or RecursionError: that’s the call stack telling you it’s full. Stack frames only exist during the execution of a function. This means everything stored in it becomes unavailable after the function has returned. This makes the allocation and de-allocation of memory automatic, which helps prevent memory leaks.

topic=logFormatting context=distributedSystems

Fri, 14 Feb 2025 13:45:56 +0000

Structured logging in Java for distributed systems

Where do applications log end up anyway?

Applications typically write to standard output. Logs can either be handled by the app’s supervising process or be passed to the next supervision layer to be processed. For example Kubernetes collects logs written to stdout and stderr by containers and stores them in node-specific log files (usually /var/log/containers based on name). From there, they can be accessed by tools like kubectl logs.