Nicolas Frankel on foojay.io - Friends of OpenJDK

From a JAR to a full-fledged MacOS app

Thu, 05 Feb 2026 10:15:05 +0000

A couple of years ago, I developed a small Kotlin GUI to help me rename my files in batch. I actually created it with different JVM frameworks to compare their relative merits. In any case, I didn’t use it up until last week. And then, I was surprised to see that it didn’t work to rename a network volume, although it had in the past. In this brief post, I aim to describe the issue and its solution.

Transactions and ThreadLocal in Spring

Tue, 21 Oct 2025 13:27:00 +0000

Two years ago, my friend José Paumard held the talk “Concurrent and Asynchronous Programming : Loom” at the Geneva Java User Group.

In his talk, he mentioned that the Spring team would need to completely redesign their approach to transactions: his reasoning was that the transactions are implemented on top of ThreadLocal object and Loom’s virtual threads break this approach.

I was intrigued because though I used Spring transactions a lot via the @Transactional annotation, I never opened thought about looking at their implementation.

KCDC 2025

Wed, 03 Sep 2025 17:38:36 +0000

When I first started attending conferences, I diligently tried to write down notes and publish them. It forced me to actively listen to the talks I was attending. With the number of conferences rising, I couldn’t keep the rhythm. When I switched my career path to Developer Advocate, I drastically diminished the number of talks I attended in favor of the hallway track. As a result, the last conference “report” I wrote was JPrime’s in 2022.

GitHub workflows tips and tricks

Tue, 26 Aug 2025 12:06:00 +0000

I’ve quite a lengthy experience with GitHub workflows, but not up to the point where I can claim I’m an expert. However, I recently developed a new workflow, and it prompted me to write this post. Feel free to add your own.

What are GitHub workflows?

A workflow is a configurable automated process that will run one or more jobs. Workflows are defined by a YAML file checked in to your repository and will run when triggered by an event in your repository, or they can be triggered manually or at a defined schedule.

Git default options

Tue, 26 Aug 2025 11:59:57 +0000

Git has become a fundamental part of our developers’ daily routine that it’s hard to remember our lives without it. And yet, most of us use a limited set of commands and options. Today, I want to focus on two commands most developers probably use every day and look at the defaults behind them.

git push

After git commit, git push is probably the second most used command. I don’t think I’ll teach you anything with this excerpt from the documentation:

OpenTelemetry configuration gotchas

Sun, 17 Aug 2025 08:01:26 +0000

Last week, I described several approaches to OpenTelemetry on the JVM , their requirements, and their different results. This week, I want to highlight several gotchas found across stacks in the zero-code instrumentation.

The promise of OpenTelemetry

Since its inception, OpenTelemetry has unified the 3 pillars of observability. In the distributed tracing space, it replaced proprietary protocols Zipkin and Jaeger. IMHO, it achieved such success for several reasons:

First, a huge industry pressure to work across proprietary tools
Zero-code instrumentation, allowing developers to be unconcerned by OpenTelemetry
Easy and unified configuration mechanism via environment variables.

The latter is a boon for the Ops team, as they don’t have to know the underlying framework (or stack!) details. They only need to check the Environment Variable Specification and they are done.

OpenTelemetry Tracing on the JVM

Sun, 17 Aug 2025 08:00:39 +0000

You may know I’m a big fan of OpenTelemetry. I recently finished developing a master class for the YOW! conference at the end of the year. During development, I noticed massive differences in configuration and results across programming languages. Even worse, differences exist across frameworks inside the same programming language.

In this post, I want to compare the different zero-code OpenTelemetry approaches on the JVM, covering the most widespread:

Spring Boot with Micrometer Tracing
Spring Boot with the OpenTelemetry Agent
OpenTelemetry Spring Boot Starter
Quarkus
Quarkus with the OpenTelemetry Agent

Commonalities

I keep the architecture pretty simple:

Pattern-matching across different languages

Tue, 05 Aug 2025 07:40:40 +0000

Pattern matching is a major feature in software development. While pattern matching applies in several locations, its current usage is limited to switch case blocks. I want to compare the power of pattern matching across a couple of programming languages I’m familiar with in this post.

I assume that every reader is familiar with the switch case syntax inherited from C. In short:

The switch clause references a value-returning statement
Each case clause sets another statement; if the value matches the statement, it executes the related block
case clauses are evaluated in order. The first clause that matches gets its block executed
In C, case clauses are fall-through; you need to explicitly break to escape the switch, otherwise, the next case is evaluated

Java’s pattern matching

I’ll start with Java, as it was the first programming language I used in a professional context.

Testing an OpenRewrite Recipe

Mon, 14 Jul 2025 09:43:52 +0000

For the last two weeks, I’ve kicked the tires of OpenRewrite.

At first, I created a recipe to move Kotlin source files as per the official recommendations with a set package name.

I then improved the recipe to compute the root automatically . In both versions, I thoroughly tested the recipe.

However, my testing approach was wrong. In this post, I want to describe my mistakes, and how I fixed them.

Book Review: Writing for Developers

Wed, 18 Jun 2025 10:58:31 +0000

Disclaimer: This post includes affiliate links; I may receive compensation if you purchase the book from the different links provided in this post.

This review is about Writing for Developers by Piotr Sarna and Cynthia Dunlop from Manning.

I started my blog as a hobby seventeen years ago, in April 2008. At the time, I had no clue about technical writing. I’m pretty sure it was not even a thing back then: the only content aimed at developers was technical documentation. Since then, the landscape has changed a lot, to the point that companies hire for technical writer positions.

Authoring an OpenRewrite Recipe

Mon, 09 Jun 2025 17:22:13 +0000

I’ve been eying OpenRewrite for some time, but I haven’t had time to play with it yet. In case you never heard about OpenRewrite, OpenRewrite takes care of refactoring your codebase to newer language, framework, and paradigm versions.

OpenRewrite is an open-source automated refactoring ecosystem for source code, enabling developers to effectively eliminate technical debt within their repositories.

It consists of an auto-refactoring engine that runs prepackaged, open-source refactoring recipes for common framework migrations, security fixes, and stylistic consistency tasks – reducing your coding effort from hours or days to minutes. Build tool plugins like the OpenRewrite Gradle plugin and the OpenRewrite Maven plugin help you run these recipes on one repository at a time.

Cloudflare Tunnel for Home Assistant

Tue, 03 Jun 2025 11:29:18 +0000

I continue to take care of my Home Assistant. This week, I replaced my original setup with Cloudflare Tunnel .

This is the 6^th^ post in the My journey with Home Assistant focus series. Other posts include:

The initial setup

My usage of Home Assistant required external access from the beginning.

Getting a single value from a device's state in Home Assistant

Sat, 31 May 2025 09:27:38 +0000

I recently acquired Netatmo smart radiator valves to manage my rooms’ temperature remotely. I’m not skilled at manual tasks, but I could easily replace the old thermo-static valves. I then registered the smart ones in the Netatmo app. Finally, I integrated them in my Home Assistant via the dedicated Netatmo integration . Everything was very straightforward.

I noticed that each valve not only allows remote control but also offers a state with several attributes. I wanted to extract the room’s temperature indicator from it. It was not as easy as I thought it was, so I want to describe how I managed to achieve it.

Improving Maven's dependency:analyze... or not

Mon, 28 Apr 2025 08:28:32 +0000

Recently, my good friend Richard Fichtner advised using the mvn dependency:analyze command to get rid of declared but unused dependencies:

There is another use case for

mvn dependency:analyze

It can show you the dependencies you use in your code but have not declared in your pom.xml. This works because you have a transitive dependency on your classpath. Either don’t use the dependency or declare it.

— Richard Fichtner 💻☕ @richard.fichtner.dev
December 10, 2024 at 2:00 PM

Mutation Testing in Rust

Wed, 09 Apr 2025 12:39:50 +0000

I’ve been a big fan of Mutation Testing since I discovered PIT . As I dive deeper into Rust, I wanted to check the state of mutation testing in Rust.

Starting with `cargo-mutants`

I found two crates for mutation testing in Rust:

cargo-mutants
and mutagen

mutagen hasn’t been maintained for three years, while cargo-mutants is still under active development.

I’ve ported the sample code from my previous Java code to Rust:

The try block in Rust

Wed, 09 Apr 2025 12:37:58 +0000

I wrote previously about libs for error management in Rust . This week, I want to write about the try block, an experimental feature.

The limit of the `?` operator

Please check the above article for a complete refresher on error management in general and the ? operator in particular. In short, ? allows to hook into a function call that returns a Result:

If the Result contains a value, it continues normally
If it contains an error, it short-circuits and returns the Result to the calling function.

fn add(str1: &str, str2: &str) -> Result<i8, ParseIntError> {
 Ok(str1.parse::<i8>()? + str2.parse::<i8>()?)
}

fn main() {
 print!("{:?}", add("1", "2"));
 print!("{:?}", add("1", "a"));
}

The output is the following:

One giant Kubernetes cluster for everything

Tue, 25 Mar 2025 10:33:50 +0000

The ideal size of your Kubernetes clusters is a day 0 question and demands a definite answer.

You find one giant cluster on one end of the spectrum and many small-sized ones on the other, with every combination in between. This decision will impact your organization for years to come. Worse, if you decide to change your topology, you’re in for a time-wasting and expensive ride.

I want to list each approach’s pros and cons in this post. Then, I’ll settle the discussion once and for all and argue why selecting the giant cluster option is better.

WebAssembly on Kubernetes

Tue, 25 Mar 2025 10:32:31 +0000

Like a couple of innovative technologies, different people have different viewpoints on where WebAssembly fits the technology landscape.

WebAssembly (also called Wasm) is certainly the subject of much hype right now. But what is it? Is it the JavaScript Killer? Is it a new programming language for the web? Is it (as we like to say) the next wave of cloud compute? We’ve heard it called many things: a better eBPF, the alternative to RISC V, a competitor to Java (or Flash), a performance booster for browsers, a replacement for Docker.

Pull request testing on Kubernetes: testing locally and on GitHub workflows

Sun, 16 Mar 2025 17:32:27 +0000

Imagine an organization with the following practices:

Commits code on GitHub
Runs its CI/CD pipelines with GitHub Actions
Runs its production workload on Kubernetes
Uses Google Cloud

A new engineer manager arrives and asks for the following:

On every PR, run integration tests in a Kubernetes cluster similar to the production one.

It sounds reasonable.

Engineering manager: I want #integrationtests to run on the app deployed on #Cloud infra for each #GitHub PR ✅

Pull Request testing on Kubernetes: Working with GitHub Actions and GKE

Sun, 16 Mar 2025 15:44:27 +0000

I’m continuing my series on running the test suite for each Pull Request on Kubernetes. In the previous post , I laid the groundwork for our learning journey: I developed a basic JVM-based CRUD app, tested it locally using Testcontainers, and tested it in a GitHub workflow with a GitHub service container.

This week, I will raise the ante to run the end-to-end test in the target Kubernetes environment. For this, I’ve identified gaps that I’ll implement in this blog post:

Pull request testing on Kubernetes: vCluster for isolation and costs control

Sun, 16 Mar 2025 11:47:20 +0000

This week’s article is the third and final in my series about running tests on Kubernetes for each pull request. In the first post , I described the app and how to test locally using Testcontainers and in a GitHub workflow. The second post focused on setting up the target environment and running end-to-end tests on Kubernetes.

I concluded the latter by mentioning a significant quandary. Creating a dedicated cluster for each workflow significantly impacts the time it takes to run. On , it took between 5 and 7 minutes to spin off a new cluster. If you create a GKE instance upstream, you face two issues:

Book Review: DuckDB in Action

Wed, 05 Mar 2025 13:42:59 +0000

Disclaimer: this post includes affiliate links; I may receive compensation if you purchase the book from the different links provided in this post.

This review is about DuckDB in Action by JoMark Needham, Michael Hunger, and Michael Simons from Manning.

The book was sent to me by Michael Simons . He asked for my feedback: I changed my reading schedule, took a few months, and here it is.

Facts

10 chapters
288 pages
$33.59 (eBook)

Note that MotherDuck, the company behind DuckDB, offers a free PDF copy .

Remote Development Made Simple with DevPod

Thu, 13 Feb 2025 16:06:30 +0000

I come relatively late to the subject of Remote Development Environments (also known as Cloud Development Environments).

The main reason is that I haven’t worked in a development team for over six years. However, I’m now working for Loft Labs, and we have a product: DevPod . I wanted to understand our value proposition as was on my way to FOSDEM operating the DevPod booth .

The problem

As a former developer, I vividly remember the pain of setting up each developer’s development environment. At the beginning of my career, the architect had to configure my development machine painfully, so it was similar to his setup. Later on, I did the same for my team members repeatedly. The scope of possible discrepancies impacting development is virtually endless: Operating System, of course, version and flavour of the SDKs, e.g., Java’s Eclipse Temurin vs SapMachine, git hooks, etc. It was sweat, toil, and blood on every project.

My first steps with Playwright

Thu, 30 Jan 2025 11:58:04 +0000

In my previous company, I developed a batch job that tracked metrics across social media, such as Twitter, LinkedIn, Mastodon, Bluesky, Reddit, etc. Then I realized I could duplicate it for my own “persona”. The problem is that some media don’t provide an HTTP API for the metrics I want.

Here are the metrics I want on LinkedIn:

I searched for a long time but found no API access for the metrics above. I scraped the metrics manually every morning for a long time and finally decided to automate this tedious task. Here’s what I learned.

A solution to the problem of cluster-wide CRDs

Thu, 30 Jan 2025 11:55:14 +0000

I’m an average Reddit user, scrolling much more than reading or interacting. Sometimes, however, a post rings a giant red bell. When I stumbled upon If you could add one feature to K8s, what would it be? , I knew the content would be worth it.

The most voted answer is:

Namespace scoped CRDs

A short intro to CRDs

Kubernetes comes packed with existing objects, such as Pod, Service, DaemonSet, etc., but you can create your own: the latter are called Custom Resource Definitions. Most of the time, s are paired with a custom controller called an operator. An operator subscribes to the lifecycle events of CRD(s). When you act upon a CRD by creating, updating, or deleting it, Kubernetes changes its status, and the operator gets notified. What it does depends on the nature of the CRD.

An Example of HACS: Adaptive Lighting

Wed, 15 Jan 2025 08:40:46 +0000

In the previous post of this focus, we replaced Philips Hue automation with the one from Home Assistant. One significant gap we noticed was that Home Assistant doesn’t automatically adjust the brightness according to the time of the day, a feature Philips Hue offers. In this post, we are going to address this gap.

The first step when wanting to add a feature to Home Assistant is to browse through available integrations. While there was no out-of-the-box integration, I discovered an alternative: HACS.

2024 in Retrospective: Nicolas Frankel

Mon, 06 Jan 2025 08:59:26 +0000

For the first article of 2025, I’m continuing my retrospective series!

As last year, before diving in into the report proper, I’d like to remind you that Ukraine is still fighting for its survival after nearly 3 years and countless Russian war crimes. The civilized world can’t allow rewarding the invasion of a sovereign country, lest we see more invasions. Remember that in 1938, in Munich, European “leaders” acknowledged Hitler’s annexation of Czechoslovakia’s Sudetenland. It didn’t prevent Nazi Germany to invade the rest of Europe a year later; worse, it emboldened it!

The Home Assistant Model

Mon, 09 Dec 2024 15:58:27 +0000

Home Assistant (home-assistant.io ) is a massive beast. It can be overwhelming for a newcomer; it was for me.

In this article, I want to describe the underlying model of Home Assistant, which is a good entry point for your home automation journey.

The biggest issue in describing the Home Assistant is the number of conflicting sources for this model:

The helpers package of the GitHub repository
The database; disclaimer: I didn’t find the schema generation in the code, and I wasn’t bold enough to check the deployed SQLite database
The documentation
The web interface

As far as I understand it, here’s the conceptual model.

Why Home Assistant

Mon, 09 Dec 2024 15:54:20 +0000

Last June, I spoke at Berlin Buzzwords . In all honesty, I rarely attend others’ talks for a variety of reasons: lack of time, lack of energy, no interest in the proposed subjects, etc. When I do, I go either for subjects I know and want to deepen my understanding of or for subjects I know nothing about to get a foot in the door.

This time, I attended Monitoring your home, with DevOps observability tools . I thought it would be about OpenTelemetry for your home. After the speaker mentioned Home Assistant (home-assistant.io ), however, I didn’t pay much attention to the rest.

Langchain4J Musings

Sat, 23 Nov 2024 13:57:30 +0000

I’m coming relatively late to the LLM party, but I rarely come very early in the hype cycle.

For example, I never bought into blockchain, the solution still searching for problems to solve, nor in microservices, the latest in the cargo cult IT trends. Despite my late arrival at the LLM party, I have been a regular user of LLMs. I use OpenAI for non-controversial questions outside my cone of knowledge, e.g., linguistics or legal; I use GitHub Copilot in my IDE to improve my code.

Summary of the AJAX Frameworks Comparison

Thu, 14 Nov 2024 11:35:50 +0000

In previous weeks, I’ve analyzed several libraries and frameworks that augment the client with AJAX capabilities.

In this post, I’ll compare them across several axes.

Analysis

Frontend skills:Remember that I started this series from the point of view of a backend developer. In this section, I grade how much you need to know about client technologies to complete the job.
Team organization:In the introduction, I hinted that the decoupling of frontend and backend teams profoundly impacted projects. Each team is fast on its own, and they can parallelize their work, but integrating the two can double the initial development time. Here, I grade how easy it is to integrate frontend and backend.
Ease of setup:How easy it is to set up the tool from the backend.
Ease of styling:Backend developers are not designers by default. Does the tool offer a default, at least average-looking style? How hard is it to create one?

For all intents and purposes, Vue.js and Alpine.js are similar; I’ll refer to them as JavaScript frameworks.

Vaadin: Battery-Included Server-Side AJAX Framework

Tue, 22 Oct 2024 09:39:11 +0000

I’ve written a lot about Vaadin . I was so enthusiastic that I wrote the first book about it (besides the Book of Vaadin), its updated edition for Vaadin 7, and a companion website . Still, I’m amazed that so many people in the JVM world never heard of it.

In this article, I’d like to introduce Vaadin in the context of AJAX and SSR.

Short introduction to Vaadin

The beauty of Vaadin lies in its simplicity - you only write backend code . You read that well. A Vaadin developer only needs to know Java, or any JVM language, and the Vaadin API. At runtime, Vaadin will create the client-side code, i.e., HTML, JavaScript and CSS. This approach empowers developers to focus on the application’s core functionality, making the development process more productive.

Augmenting the client with HTMX

Mon, 14 Oct 2024 12:37:39 +0000

This article is part of a series comparing different ways to implement asynchronous requests on the client to augment the latter. So far, I described the process with Vue.js and Alpine.js . Both are similar from the developers’ point of view: they involve JavaScript.

In this post, I’ll focus on HTMX , whose approach is quite different.

Laying out the work

I’ll follow the same structure as in the previous posts of the series. Here’s the setup, server- and client-side.

Augmenting the client with Alpine.js

Mon, 14 Oct 2024 10:59:44 +0000

This article is part of a series comparing different ways to implement asynchronous requests on the client, which is colloquially known as AJAX. I dedicated the previous post to Vue.js; I’ll dedicate this one to Alpine.js - not to be confused with Alpine Linux.

I’ll follow the same structure as previously.

Laying out the work

Here’s the setup, server- and client-side.

Server-side

Here is how I integrate Thymeleaf and Alpine.js in the POM:

Augmenting the client with Vue.js

Mon, 14 Oct 2024 10:53:42 +0000

In my previous article , I laid the ground to build upon; now is the time to start “for real”.

I heard a lot of Vue.js . Additionally, a friend who transitioned from developer to manager told me good things about Vue, which further piqued my interest. I decided to have a look at it: it will be the first “lightweight” JavaScript framework I’ll study - from the point of view of a newbie, which I am.

Server-Side Rendering with Spring Boot

Mon, 23 Sep 2024 06:58:41 +0000

Understanding the shared steps in the project setup is crucial before delving into the specifics of each client-augmenting technology. My requirements from the last post where quite straightforward:

I’ll assume the viewpoint of a backend developer

No front-end build step: no TypeScript, no minification, etc.

All dependencies are managed from the backend app, i.e., Maven

It’s important to note that the technology I’ll be detailing, except Vaadin, follows a similar approach. Vaadin, with its unique paradigm, really stands out among the approaches.

A Short History of AJAX and SSR

Mon, 23 Sep 2024 06:57:01 +0000

My journey in programming began over two decades ago, a time when JavaScript was a far cry from its current state, and developers were primarily focused on Microsoft Internet Explorer. One of my proudest achievements back then was writing a few lines of code that allowed users to add and remove table rows entirely on the client side. We called it . Many developers today have forgotten about it—or never knew it existed.

Health Check Response Format for HTTP APIs

Thu, 12 Sep 2024 10:02:32 +0000

I’m continuing my journey on getting more familiar with HTTP APIs by reading related . This time, I read the Health Check Response Format for HTTP APIs on the suggestion of Stefano Fago . In this article, I’d like to summarize my reading.

Note that it’s a draft. Moreover, it has been dormant for nearly two years and, thus, has been automatically expired. However, it’s the closest to a specification on health checks and thus deserves some love.

DRY your Apache APISIX config

Thu, 12 Sep 2024 09:59:44 +0000

is an important principle in software development. In this article, you learn how to apply it to Apache APISIX configuration.

The DRY principle

“Don’t repeat yourself” (DRY) is a principle of software development aimed at reducing repetition of information which is likely to change, replacing it with abstractions that are less likely to change, or using data normalization which avoids redundancy in the first place.

– Wikipedia - Don’t repeat yourself

Implementing the Idempotency-Key specification on Apache APISIX

Mon, 02 Sep 2024 20:58:24 +0000

Recently, I wrote an analysis of the IETF Idempotency-Key specification . The specification aims to avoid duplicated requests.

In short, the idea is for the client to send a unique key along with the request:

If the server doesn’t know the key, it proceeds as usual and then stores the response
If the server knows the key, it short-circuits any further processing and immediately returns the stored response

This post shows how to implement it with Apache APISIX .

When (not) to write an Apache APISIX plugin

Mon, 02 Sep 2024 20:50:43 +0000

When I introduce Apache APISIX in my talks, I mention the massive number of existing plugins , and that each of them implements a specific feature.

One of the key features of Apache APISIX is its flexibility. If a feature is missing, you can create your own plugin in Lua or a language compiled into Wasm, showcasing the platform’s adaptability to your specific needs.

In this article, I aim to provide practical alternatives to writing a custom plugin, offering solutions you can quickly implement in your projects.

OpenTelemetry Tracing on Spring Boot, Java Agent vs. Micrometer Tracing

Thu, 22 Aug 2024 08:34:57 +0000

My demo of OpenTelemetry Tracing features two Spring Boot components. One uses the Java agent, and I noticed a different behavior when I recently upgraded it from v1.x to v2.x. In the other one, I’m using Micrometer Tracing because I compile to GraalVM native, and it can’t process Java agents.

I want to compare these three different ways in this post: Java agent v1, Java agent v2, and Micrometer Tracing.

Free tier API with Apache APISIX

Mon, 05 Aug 2024 13:50:08 +0000

Lots of service providers offer a free tier of their service. The idea is to let you kick their service’s tires freely. If you need to go above the free tier at any point, you’ll likely stay on the service and pay.

In this day and age, most services are online and accessible via an API. Today, we will implement a free tier with Apache APISIX .

A naive approach

I implemented a free tier in my post Evolving your RESTful APIs, a step-by-step approach , albeit in a very naive way. I copy-pasted the limit-count plugin and added my required logic.

Differentiating rate limits in Apache APISIX

Mon, 05 Aug 2024 13:37:40 +0000

In my talk Evolving your APIs, I mention that an API Gateways is a Reverse Proxy “on steroids”. One key difference between the former and the latter is that the API Gateway is not unfriendly to business logic. The poster child is rate-limiting.

Rate-limiting is an age-old Reverse Proxy feature focused on protecting against attacks. It treats all clients the same and is purely technical. In this day and age, most API providers offer different subscription tiers; the higher the tier, the higher the rate limit, and the more you pay incidentally. It’s not technical anymore and requires to differentiate between clients.

Random and fixed routes with Apache APISIX

Mon, 05 Aug 2024 13:29:59 +0000

My ideas for blog posts inevitably start to dry up after over two years at Apache APISIX .

Hence, I did some triage on the APISIX repo . I stumbled upon this one question:

We have a requirement to use a plugin, where we need to route the traffic on percentage basis. I’ll give an example for better understanding.

We have an URL where ca is country (Canada) and fr is french language. Now the traffic needs to routed 10% to and the remaining 90% to. And whenever we’re routing the traffic to we need to set a cookie. So for next call, if the cookie is there, it should directly go to else it should go via a 10:90 traffic split. What is the best possible way to achieve this ??

Advanced URL Rewriting with Apache APISIX

Thu, 25 Jul 2024 09:10:06 +0000

I spoke at Swiss PgDay in Switzerland in late June. The talk was about how to create a no-code API with the famous PostgreSQL database, the related PostgREST , and Apache APISIX , of course. I already wrote about the idea in a previous post . However, I wanted to improve it, if only slightly.

PostgREST offers a powerful SELECT mechanism. To list all entities with a column equal to a value, you need the following command:

Dynamic watermarking with imgproxy and Apache APISIX

Wed, 10 Jul 2024 13:38:07 +0000

I described how to add a dynamic watermark to your images on the JVM . I didn’t find any library, so I had to develop the feature, or, more precisely, an embryo of a feature, by myself.

Depending on your tech stack, you must search for an existing library or roll up your sleeves. For example, Rust offers such an out-of-the-box library. Worse, this approach might be impossible to implement if you don’t have access to the source image.

Dynamic watermarking on the JVM

Tue, 09 Jul 2024 07:59:29 +0000

Displaying images on your website makes for an interesting problem: on one side, you want to make them publicly available; on the other, you want to protect them against undue use. The age-long method to achieve it is watermarking:

A digital watermark is a kind of marker covertly embedded in a noise-tolerant signal such as audio, video or image data. It is typically used to identify ownership of the copyright of such signal. “Watermarking” is the process of hiding digital information in a carrier signal; the hidden information should, but does not need to, contain a relation to the carrier signal. Digital watermarks may be used to verify the authenticity or integrity of the carrier signal or to show the identity of its owners. It is prominently used for tracing copyright infringements and for banknote authentication.

Renovate for everything

Thu, 27 Jun 2024 08:18:20 +0000

In my earlier post about moving from Kotlin Scripting to Python , I mentioned several reasons:

Separating the content from the script
Kotlin Scripting is an unloved child of JetBrains
Renovate cannot update Kotlin Scripting files

I was wrong on the third point. Here’s my mea culpa.

First things first, Renovate does indeed manages Kotlin Scripting files - since 2022.

Even better, Renovate can manage any type of file. Thanks to Max Andersen for the tip:

Even More Opentelemetry!

Thu, 20 Jun 2024 06:40:47 +0000

I continue to work on my Opentelemetry demo . Its main idea is to showcase traces across various technology stacks, including asynchronous communication via an MQTT queue. Recently, I added a couple of components and changed the architecture. Here are some noteworthy learnings; note that some of them might not be entirely connected to OpenTelemetry.

Here’s an updated diagram. New components appear in violet, and updated components appear in green.

Foojay Podcast #53: JCON Report, Part 5 – CQRS, JOOQ, GraphQL, API, Vaadin, OpenRewrite, ErrorProne, Gateways, Proxies,...

Mon, 17 Jun 2024 09:24:52 +0000

This is the final part of the JCON interviews. Did I save the best for last? It’s up to you to decide…

In this episode you’ll hear Simon Martinelli, Nicolas Fränkel, Marcus Hellberg, Rick Ossendrijver, and Abdel Sghiouar.

We talked about a bunch of topics like evolving your APIs, GraphQL, Java versus Kotlin versus Rust, Vaadin, AI and ChatGPT, OpenRewrite, ErrorProne, Infrastructure, and a lot more.

Video

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Workflow, From Stateless To Stateful

Wed, 05 Jun 2024 06:11:38 +0000

A (long) time ago, my first job consisted of implementing workflows using the Staffware engine. In short, a workflow comprises tasks; an automated task delegates to code, while a manual task requires somebody to do something and mark it as done. Then, it proceeds to the next task - or tasks.

Here’s a sample workflow:

The above diagram uses Business Process Model and Notation . You can now design your workflow using and run it with compatible workflow engines.

My opinion on the Tauri framework

Thu, 30 May 2024 16:05:06 +0000

I’ve always liked , both desktop-based and browser-based before you needed five years of training on the latter. That’s the reason I loved, and still love Vaadin : you can develop web UIs without writing a single line of HTML, JavaScript, and CSS. I’m still interested in the subject; a couple of years ago, I analyzed the state of JVM desktop frameworks .

I also like the Rust programming language a lot.

The Vary HTTP Header

Wed, 15 May 2024 07:46:26 +0000

I try to constantly to deepen my knowledge of HTTP and REST. Recently, I stumbled upon the list of all registered HTTP Headers . This post is dedicated to the Vary HTTP Header.

The problem

Two years ago, I wrote about web resource caching server-side . The idea is to set up a component between the client and the upstream to cache previously computed results to avoid overloading the latter. Depending on your infrastructure and requirements, this component can be a reverse proxy or an API Gateway. HTTP offers the Cache-Control header to customize the different aspects of caching, e.g. , the time the server holds the resource in cache before it considers it stale. I used plugin configuration in the above post, but you can also delegate to Cache-Control.

Five ways to pass parameters to Apache APISIX

Tue, 30 Apr 2024 14:53:30 +0000

I recently read 6 Ways To Pass Parameters to Spring REST API .

Though the title is a bit misleading, as it’s unrelated to REST, it does an excellent job listing all ways to send parameters to a Spring application.

I want to do the same for Apache APISIX; it’s beneficial when you write a custom plugin.

General setup

The general setup uses Docker Compose and static configuration.

I’ll have one plugin per way to pass parameters.

Using my new Raspberry Pi to run an existing GitHub Action

Tue, 23 Apr 2024 18:45:04 +0000

Recently, I mentioned how I refactored the script that kept my GitHub profile up-to-date. Since Geecon Prague, I’m also a happy owner of a Raspberry Pi:

[

](https://twitter.com/nicolas_frankel/status/1715313240568197233 )

Though the current setup works flawlessly - and is free, I wanted to experiment with self-hosted runners. Here are my findings.

Context

GitHub offers a large free usage of GitHub Actions:

GitHub Actions usage is free for standard GitHub-hosted runners in public repositories, and for self-hosted runners. For private repositories, each GitHub account receives a certain amount of free minutes and storage for use with GitHub-hosted runners, depending on the account’s plan. Any usage beyond the included amounts is controlled by spending limits.

Improving upon my OpenTelemetry Tracing demo

Wed, 03 Apr 2024 06:35:22 +0000

Last year, I wrote a post on Open Telemetry Tracing to understand more about the subject. I also created a demo around it, which featured the following components:

The Apache APISIX API Gateway
A Kotlin/Spring Boot service
A Python/Flask service
And a Rust/Axum service

I’ve recently improved the demo to deepen my understanding and want to share my learning.

Using a regular database

In the initial demo, I didn’t bother with a regular database. Instead:

Apache APISIX North America Tour

Mon, 25 Mar 2024 15:31:08 +0000

Once in a while, I write non-technical blog posts when I’ve something worth sharing. Today, I’d like to write about my North America “Tour” across several conferences and user groups.

The first leg of my journey started in Oakland, California, with Developer Week . Developer Week is an established conference with different editions in several locations and online during the year. Though I’m on their advisory board, this is only the second time I’ve spoken at one of their events. Pro-tip: Avoid being on any board of a conference where you speak. It’s bad taste and casts doubt on whether you validated yourself.

Secure your API with these 16 Practices with Apache APISIX – part 2

Mon, 11 Mar 2024 09:39:24 +0000

We’ve listed 16 practices to help secure one’s APIs and described how to implement them with Apache APISIX.

~~Authentication 🕵️️ - Verifies the identity of users accessing APIs.~~

~~Authorization 🚦 - Determines permissions of authenticated users.~~

Data Redaction 🖍️ - Obscures sensitive data for protection.

Encryption 🔒 - Encodes data so only authorized parties can decode it.

Error Handling ❌ - Manages responses when things go wrong, avoiding revealing sensitive info.

~~Input Validation & Data Sanitization 🧹 - Checks input data and removes harmful parts.~~

Intrusion Detection Systems 👀 - Monitor networks for suspicious activities.

~~IP Whitelisting 📝 - Permits API access only from trusted IP addresses.~~

~~Logging and Monitoring 🖥️ - Keeps detailed logs and regularly monitors APIs.~~

~~Rate Limiting ⏱️ - Limits user requests to prevent overload.~~

Secure Dependencies 📦 - Ensures third-party code is free from vulnerabilities.

Security Headers 📋 - Enhances site security against types of attacks like XSS.

Token Expiry ⏳ - Regularly expiring and renewing tokens prevents unauthorized access.

Use of Security Standards and Frameworks 📘 - Guides your API security strategy.

Web Application Firewall 🔥 - Protects your site from HTTP-specific attacks.

API Versioning 🔄 - Maintains different versions of your API for seamless updates.

Let’s now look at the remaining practices.

Secure your API with these 16 Practices with Apache APISIX - part 1

Mon, 11 Mar 2024 09:35:51 +0000

A couple of months ago, I stumbled upon this list 16 practices to secure your API :

Authentication 🕵️️ - Verifies the identity of users accessing APIs.

Authorization 🚦 - Determines permissions of authenticated users.

Data Redaction 🖍️ - Obscures sensitive data for protection.

Encryption 🔒 - Encodes data so only authorized parties can decode it.

Error Handling ❌ - Manages responses when things go wrong, avoiding revealing sensitive info.

Input Validation & Data Sanitization 🧹 - Checks input data and removes harmful parts.

Intrusion Detection Systems 👀 - Monitor networks for suspicious activities.

IP Whitelisting 📝 - Permits API access only from trusted IP addresses.

Logging and Monitoring 🖥️ - Keeps detailed logs and regularly monitors APIs.

Rate Limiting ⏱️ - Limits user requests to prevent overload.

Secure Dependencies 📦 - Ensures third-party code is free from vulnerabilities.

Security Headers 📋 - Enhances site security against types of attacks like XSS.

Token Expiry ⏳ - Regularly expiring and renewing tokens prevents unauthorized access.

Use of Security Standards and Frameworks 📘 - Guides your API security strategy.

Web Application Firewall 🔥 - Protects your site from HTTP-specific attacks.

API Versioning 🔄 - Maintains different versions of your API for seamless updates.

While it’s debatable whether some points relate to security, e.g.,, versioning, the list is a good starting point anyway. In this two-post series, I’d like to describe how we can implement each point with Apache APISIX (or not).

Hardening Apache APISIX with the OWASP's Coraza and Core Ruleset

Tue, 20 Feb 2024 08:01:56 +0000

The Open Worldwide Application Security Project is an online community that produces freely available articles, methodologies, documentation, tools, and technologies in the fields of IoT, system software and web application security. The OWASP provides free and open resources. It is led by a non-profit called The OWASP Foundation. The OWASP Top 10 - 2021 is the published result of recent research based on comprehensive data compiled from over 40 partner organizations.

Kicking the Tires of Docker Scout

Thu, 08 Feb 2024 08:47:20 +0000

I never moved away from Docker Desktop.

For some time, after you use it to build an image, it prints a message:

What's Next?
 View a summary of image vulnerabilities and recommendations → docker scout quickview

I decided to give it a try. I’ll use the root commit of my OpenTelemetry tracing demo . Let’s execute the proposed command:

docker scout quickview otel-catalog:1.0

Here’s the result:

 ✓ Image stored for indexing
 ✓ Indexed 272 packages
 Target │ otel-catalog:1.0 │ 0C 2H 15M 23L
 digest │ 7adfce68062e │
 Base image │ eclipse-temurin:21-jre │ 0C 0H 15M 23L
 Refreshed base image │ eclipse-temurin:21-jre │ 0C 0H 15M 23L
 │ │
What's Next?
 View vulnerabilities → docker scout cves otel-catalog:1.0
 View base image update recommendations → docker scout recommendations otel-catalog:1.0
 Include policy results in your quickview by supplying an organization → docker scout quickview otel-catalog:1.0 --org <organization>

Docker gives out exciting bits of information:

API Versioning

Mon, 22 Jan 2024 09:00:23 +0000

In my previous article Evolving your APIs , I mention the main API versioning approaches. During the talk of the same name, I sometimes get some questions on the subject. In this article, I’ll detail each of them.

I assume readers know the reasons behind versioning, semantic versioning, and product lifecycle. If not, I encourage you to read a bit about these themes; in particular, chapter 24 of the excellent API Design Patterns book focuses on them.

2023 in Retrospective

Tue, 16 Jan 2024 07:44:39 +0000

Last year, I wrote my first yearly retrospective . I liked the experience, so I’m trying one more time. Let the future decide if it will become a trend or not.

Before diving into our safe technological world, my thoughts go to Ukraine, to my friends who had to flee their own country, to other friends who fought on the front to defend it from an imperial power, and to all victims of an old kleptocrat who clings to power despite the cost to others. The free world needs to support Ukraine more. I hope 2024 will be the year of Ukrainian victory.

Playing with WASM on Docker

Wed, 03 Jan 2024 07:48:29 +0000

The idea of bytecode that can run anywhere dates back to the JVM inception (as far as I know).

WebAssembly is the new implementation of an old idea. While WebAssembly is meant to run in the browser, Docker recently announced its capability to run WASM code without needing containers.

In this post, I want to explore how it can work.

Prerequisite

Running WebAssembly is a beta feature and requires using containerd. To enable containerd, go to the Docker Desktop dashboard, then Settings > Features in development > Beta features > Use containerd for storing and pulling image.

Five Apache Projects You Probably Haven't Heard Of (Yet)

Sun, 24 Dec 2023 10:17:38 +0000

In early 2021, I started to work on the Apache APISIX project. I have to admit that at the time I had never heard about it before.

As a result, in this article, I’d like to introduce some Apache projects that are less well-known than HTTPD or Kafka.

Apache APISIX

APISIX is an API Gateway . It builds upon OpenResty , a Lua layer built on top of the famous nginx reverse-proxy. APISIX adds abstractions to the mix, e.g. , Route, Service, Upstream, and offers a plugin-based architecture.

Canary Releases with Apache APISIX

Tue, 19 Dec 2023 08:01:55 +0000

In a few words, the idea of canary releases is to deliver a new software version to only a fraction of the users, analyze the results, and decide whether to proceed further or not. If results are not aligned with expectations, roll back; if they are, increase the number of users exposed until all users benefit from the new version.

In this article, I’d like to detail this introduction briefly, explain different ways to define the fraction, and show how to execute it with Apache APISIX.

Chopping the monolith in a smarter way

Thu, 07 Dec 2023 07:40:55 +0000

In my previous post Chopping the Monolith , I explained that some parts of a monolith are pretty stable and only the fast-changing parts are worth being “chopped.”

I turned the post into a talk and presented it at several conferences. I think it’s pretty well received; I believe it’s because most developers understand, or have direct experience, that microservices are not a good fit for traditional organizations, as per Conway’s Law .

Exploring the OpenTelemetry Collector

Sun, 03 Dec 2023 12:57:06 +0000

The OpenTelemetry Collector sits at the center of the OpenTelemetry architecture but is unrelated to the W3C Trace Context.

In my tracing demo , I use Jaeger instead of the Collector.

Yet, it’s ubiquitous, as in every OpenTelemetry-related post. I wanted to explore it further.

In this post, I explore the different aspects of the Collector:

The data kind: logs, metrics, and traces
Push and pull models
Operations: reads, transformations, and writes

First steps

A long time ago, observability as we know it didn’t exist; what we had instead was monitoring. Back then, monitoring was a bunch of people looking at screens displaying dashboards. Dashboards themselves consisted of metrics and only system metrics: mainly CPU, memory, and disk usage. For this reason, we will start with metrics.

Feedback from calling Rust from Python

Wed, 22 Nov 2023 10:32:55 +0000

I got plenty of feedback on my post about Calling Rust from Python :

Many comments mentioned pyo3, and I should use it instead of cooking my own. Thanks to the authors, I checked: in this post, I explain what it is and how I migrated my code.

What is pyo3?

Rust bindings for Python, including tools for creating native Python extension modules. Running and interacting with Python code from a Rust binary is also supported.

Python "magic" methods - part 2

Fri, 03 Nov 2023 09:15:44 +0000

Let’s continue our exploration of Python’s magic methods in this second part of the series. This part will focus on numbers and containers, i.e. , collections. You can read the first part here .

Python provides the usual containers, e.g., lists, sets, and dictionaries. You can use the following methods when you want to implement your own.

Common methods

Containers have a size. Python defines two methods to implement to return the number of items in a container: object.__len__(self) for the exact size and object.__length_hint__(self) for an approximation. You should use the latter when getting the exact size is computationally expensive.

Python "magic" methods - part 1

Fri, 03 Nov 2023 09:08:42 +0000

Java was the first language I used professionally and is the scale by which I measure other languages I learned afterward. It’s an statically-typed language. Hence, Python feels a bit weird because of its dynamic typing approach.

For example, Object offers methods equals(), hashCode(), and toString(). Because all other classes inherit from Object, directly or indirectly, all objects have these methods by definition.

Conversely, Python was not initially built on OOP principles and is dynamically typed. Yet, any language needs cross-cutting features on unrelated objects. In Python, these are specially-named methods: methods that the runtime interprets in a certain way but that you need to know about. You can call them magic methods.

Resizing images on-the-fly

Mon, 23 Oct 2023 18:01:05 +0000

As a web architect, one of the many issues is asset management. And the most significant issue in assets is images. A naive approach would be to set an image and let the browser resize the image via CSS:

img {
 height: 100%;
 width: 100%;
 object-fit: contain;
}

However, it means that you download the original image. It entails two problems: the size of the original image and the suboptimal browser-based resizing.

Send Your Logs To Loki

Thu, 12 Oct 2023 08:00:12 +0000

One of my current talks focuses on Observability in general and Distributed Tracing in particular, with an OpenTelemetry implementation. In the demo, I show how you can see the traces of a simple distributed system consisting of: the Apache APISIX API Gateway, a Kotlin app with Spring Boot, a Python app with Flask, and a Rust app with Axum.

Earlier this year, I spoke and attended the Observability room at FOSDEM. One of the talks demoed the Grafana stack: Mimir for metrics, Tempo for traces, and Loki for logs. I was pleasantly surprised how one could move from one to the other. Thus, I wanted to achieve the same in my demo but via OpenTelemetry to avoid coupling to the Grafana stack.

Down the Rabbit Hole of an Apache APISIX Plugin

Wed, 27 Sep 2023 08:43:49 +0000

My demo, Evolving your APIs, features a custom Apache APISIX plugin. I believe that the process of creating a custom plugin is relatively well-documented. However, I wanted to check the parameters of the _M.access(conf, ctx) function, especially the ctx one.

The documentation states:

The ctx parameter caches data information related to the request. You can use core.log.warn(core.json.encode(ctx, true)) to output it to error.log for viewing.

Unfortunately, core.log ultimately depends on nginx’s logging, and its buffer is limited in size. Thanks to my colleague Abhishek for finding the info . For this reason, the ctx display is (heavily) truncated. I had to log data bit by bit; however, it was instructive.

Monkey-patching in Java

Thu, 21 Sep 2023 07:34:22 +0000

The JVM is an excellent platform for monkey-patching.

Monkey patching is a technique used to dynamically update the behavior of a piece of code at run-time. A monkey patch (also spelled monkey-patch, MonkeyPatch) is a way to extend or modify the runtime code of dynamic languages (e.g. Smalltalk, JavaScript, Objective-C, Ruby, Perl, Python, Groovy, etc.) without altering the original source code.

– Wikipedia

I want to demo several approaches for monkey-patching in Java in this post.

System Architecture: Move Authentication to the API Gateway

Fri, 15 Sep 2023 07:47:04 +0000

When exposing an application to the outside world, consider a Reverse-Proxy or an API Gateway to protect it from attacks. Rate Limiting comes to mind first, but it shouldn’t stop there. We can factor many features in the API Gateway and should be bold in moving them from our apps. In this post, I’ll show how to implement authentication at the Gateway API stage.

Overall authentication flow

The API Gateway doesn’t authenticate but delegates authentication to an authentication provider. After authentication, the Gateway forwards the request to the app. The app checks authentication and gets the associated identity and permissions.

Ops friendly Apache APISIX

Wed, 06 Sep 2023 06:27:42 +0000

Though I always worked on the Dev side of IT, I was also interested in the Ops side. I even had a short experience being a WebSphere admin: I used it several times, helping Ops deal with the Admin console while being a developer.

Providing a single package that Ops can configure and deploy in different environments is very important. As a JVM developer, I’ve been happy using Spring Boot and its wealth of configuration options: command-line parameters, JVM parameters, files, profiles, environment variables, etc.

Introduction to the Tower Library

Tue, 22 Aug 2023 08:28:33 +0000

One of the components of my OpenTelemetry demo is a Rust application built with the Axum web framework. In its description, axum mentions:

axum doesn’t have its own middleware system but instead uses tower::Service. This means axum gets timeouts, tracing, compression, authorization, and more, for free. It also enables you to share middleware with applications written using hyper or tonic.

– axum README

So far, I was happy to let this cryptic explanation lurk in the corner of my mind, but today is the day I want to understand what it means. Like many others, this post aims to explain to me and others how to do this.

My Final Take on Gradle (vs. Maven)

Tue, 15 Aug 2023 08:37:24 +0000

I tweet technical content that I consider interesting, but the funny tweets are the ones that get the most engagement.

I attended the JavaLand conference in March, stumbled upon the Gradle booth, and found this gem:

Of course, at some point, a fanboy hijacked the thread and claimed the so-called superiority of Gradle. In this post, I’d like to shed some light on my stance, so I can direct people to it instead of debunking the same “reasoning” repeatedly.

Book Review: "Designing APIs with Swagger and OpenAPI"

Tue, 01 Aug 2023 18:21:08 +0000

Disclaimer: this post includes affiliate links; I may receive compensation if you purchase the book from the different links provided in this post.

This review is about Designing APIs with Swagger and OpenAPI by Joshua S. Ponelat and Lukas L. Rosenstock from Manning.

I’m continuing my API journey by reading books, viewing relevant YouTube videos, and reading relevant s.

Today is a book review.

Facts

21 chapters
$38.39 (eBook)

Chapters

Part 1: Describing APIs
1. Introducing APIs and OpenAPI
2. Getting set up to make API requests
3. Our first taste of OpenAPI definitions
4. Using Swagger Editor to write OpenAPI definitions
5. Describing API responses
6. Creating resources
7. Adding authentication and authorization
8. Preparing and hosting API documentation
Part 2: Design first 9. Designing a web application 10. Creating an API design using OpenAPI 11. Building a change workflow around API design–first 12. Implementing frontend code and reacting to changes 13. Building a backend with Node.js and Swagger Codegen 14. Integrating and releasing the web application
Part 3: Extending APIs 15. Designing the next API iteration 16. Designing schemas with composition in OpenAPI 17. Scaling collection endpoints with filters and pagination 18. Supporting the unhappy path: Error handling with problem+json 19. Improving input validation with advanced JSON Schema 20. Versioning an API and handling breaking changes 21. The API prerelease checklist

The book goes through designing a complete API via a demo project, the Farmstall API .

Evaluating Apache APISIX vs. Spring Cloud Gateway

Thu, 27 Jul 2023 06:29:55 +0000

Given the number of API Gateways available on the market, I’m regularly asked which is better. Better is a very subjective term. However, there’s no denying that if you’re advocating for a product, you should know your product and its competitors. In this article, I’d like to share my understanding of Spring Cloud Gateway and how it compares to Apache APISIX.

I’m cautious when comparing products because most comparisons I read are heavily biased. That’s a risk, especially when working on one of the products one is comparing. I’ll also avoid “benchmarketing” - when you benchmark products in a context that favors your own; I’ll focus on the so-called Developer Experience.

Reactive Database Access on the JVM

Mon, 17 Jul 2023 09:18:37 +0000

A couple of years ago, Reactive Programming was all the rage, but it had one big issue: reactive stopped as soon as you accessed a SQL database.

You had a nice reactive chain up to the database, defeating the whole purpose. Given the prevalence of SQL databases in existing and new apps, one couldn’t enjoy the full benefits of Reactive Programming but still pay the full price of complexity.

Since then, the landscape has changed tremendously. Most importantly, it offers many reactive drivers over popular databases: PostgreSQL, MariaDB and MySQL, Microsoft SQL Server, Oracle, you name it!

Sticky sessions with Apache APISIX - the demo

Fri, 07 Jul 2023 16:54:25 +0000

We’ve described the concept behind sticky sessions : you forward a request to the same upstream because there’s context data associated with the session on that node.

However, if necessary, you should replicate the data to other upstreams because this one might go down. In this post, we are going to illustrate it with a demo.

The overall design

Design options are limitless. I’ll keep myself to a familiar stack, the JVM. Also, as mentioned in the previous post, one should only implement sticky sessions with session replication.

Sticky sessions with Apache APISIX

Fri, 07 Jul 2023 16:51:01 +0000

Sticky sessions, also known as session affinity, is a mechanism by which a routing component that acts as a facade always routes a request to the same underlying upstream node.

In this article, I’ll describe the reason behind sticky sessions, available alternatives, and how to implement them via Apache APISIX.

Why sticky sessions?

Sticky sessions became popular when we stored the state on the upstream node, not the database. I’ll use the example of a simplified e-commerce shop to explain further.

Working on An Unfamiliar Codebase

Sun, 02 Jul 2023 09:00:47 +0000

In our profession, it’s common to work on an unfamiliar codebase.

It happens every time one joins a new project or even needs to work on a previously untouched part in big ones.

This occurrence is not limited to a developer having to fix a bug; it can be a solution architect having to design a new feature or an OpenSource contributor working on a GitHub issue in their free time.

GitLab Pages Preview

Mon, 12 Jun 2023 08:55:31 +0000

When I write Apache APISIX-related blog posts, I want my colleagues to review them first. However, it’s my blog, and since I mix personal and business posts, I want to keep them from the repository. I need a preview, accessible only to a few, something like Vercel’s preview . I’m using GitLab Pages, and there’s no such out-of-the-box feature.

I tried two methods: GitHub gists and PDFs. Both have issues.

Managing Data Residency: The Demo

Mon, 29 May 2023 07:33:28 +0000

I explained the concepts and theory behind Data Residency in a previous post .

It’s time to get our hands dirty and implement it in a simple demo.

The sample architecture

In the last section of the previous post, I proposed a sample architecture where location-based routing happened at two different stages:

The API Gateway checks for an existing X-Country header. Depending on its value, it forwards the request to the computed upstream; If no value is found or no value matches, it forwards it to a default upstream.
The application uses Apache Shardingsphre to route again depending on the data. If the value computed by the API Gateway is correct, the flow stays “in its lane”; if not, it’s routed to the correct database, but with a performance penalty as it’s outside its lane.

I simplified some aspects:

Managing Data Residency: Concepts & Theory

Tue, 16 May 2023 09:18:20 +0000

Cloud computing has opened a Pandora’s Box of many original issues compared to sound old on-premise systems. I believe that chief among them is Data Residency, or Data Location.

Data localization or data residency law requires data about a nation’s citizens or residents to be collected, processed, and/or stored inside the country, often before being transferred internationally. Such data is usually transferred only after meeting local privacy or data protection laws, such as giving the user notice of how the information will be used and obtaining their consent.

Leverage the Richness of HTTP Status Codes

Tue, 02 May 2023 09:34:43 +0000

If you’re not a REST expert, you probably use the same HTTP codes over and over in your responses, mostly 200, 404, and 500.

If using authentication, you might perhaps add 401 and 403; if using redirects 301 and 302, that might be all.

But the range of possible status codes is much broader than that and can improve semantics a lot.

While many discussions about REST focus on entities and methods, using the correct response status codes can make your API stand out.

Fearless Distroless

Fri, 21 Apr 2023 08:59:50 +0000

With the rise of Docker came a new focus for engineers: optimizing the build to reach the smallest image size possible.

A couple of options are available.

Multi-stage builds. A Dockerfile can consist of multiple steps, each having a different Docker base image. Each step can copy files from any of the previous build steps. Only the last one will receive a tag; the others will be left untagged.This approach separates one or more build steps and a run step. On the JVM, it means that the first step includes compiling and packaging, based on a JDK, and the second step comprises running, based on a JRE.
Choosing the smallest base image size. The smaller the base image, the smaller the resulting image.

In this post, I’m going to focus on the second point.

My First Firefox Extension

Mon, 10 Apr 2023 18:36:13 +0000

A couple of weeks ago, I spent the weekend creating another submission helper in the form of a Firefox extension.

It was not a walk in the park.

To help others who may be interested in doing the same (and my future self), here’s my journey!

Context

I’ve written multiple posts about my conference submission workflow .

To sum up:

Everything is based on a Trello board
I created an app that registered a webhook on the board
When I move a conference from one lane to another, it starts or continues a workflow on the app side

I source the board by looking at websites, mainly Papercall and Sessionize , and manually copying conference data on cards. Two automation options are available:

My Evaluation of the Scaleway Cloud Provider

Fri, 31 Mar 2023 09:54:20 +0000

A couple of years ago, I developed an app that helped me manage my conference submission workflow.

Since then, I have been a happy user of the free Heroku plan.

Last summer, Heroku’s owner, Salesforce, announced that it would stop the free plan in November 2022.

I searched for a new hosting provider and found Scaleway .

In this article, I’d like to explain my requirement, why I chose them, and my experience using them.

Book Review: "API Design Patterns"

Sun, 19 Mar 2023 15:20:56 +0000

Disclaimer: this post includes affiliate links; I may receive compensation if you purchase the book from the different links provided in this post.

This review is about API Design Patterns by JJ Geewax from Manning.

I already mentioned how I’m trying to get to speed in the API world: reading books, viewing relevant YouTube videos and reading relevant s.

Facts

30 chapters, $35.00
The author is a Principal Software Engineer at Google
He’s also the author behind

Chapters

Introduction
Design principles 3. Naming 4. Resource scope and hierarchy 5. Data types and defaults
Fundamentals 6. Resource identification: How to identify resources in an API 7. Standard methods: The set of standard methods for use in resource-oriented APIs 8. Partial updates and retrievals: How to interact with portions of resources 9. Custom methods: Using custom (non-standard) methods in resource-oriented APIs 10. Long-running operations: How to handle methods that are not instantaneous 11. Rerunnable jobs: Running repeated custom functionality in an API
Resource relationships 12. Singleton sub-resources: Isolating portions of resource data 13. Cross references: How to reference other resources in an API 14. Association resources: How to manage many-to-many relationships with metadata 15. Add and remove custom methods: How to manage many-to-many relationships without metadata 16. Polymorphism: Designing resources with dynamically-typed attributes
Collective operations 17. Copy and move: Duplicating and relocating resources in an API 18. Batch operations: Extending methods to apply to groups of resources atomically 19. Criteria-based deletion: Deleting multiple resources based on a set of filter criteria 20. Anonymous writes: Ingesting unaddressable data into an API 21. Pagination: Consuming large amounts of data in bite-sized chunks 22. Filtering: Limiting result sets according to a user-specified filter 23. Importing and exporting: Moving data into or out of an API by interacting directly with a storage system
Safety and security 24. Versioning and compatibility: Defining compatibility and strategies for versioning APIs 25. Soft deletion: Moving resources to the “API recycle bin” 26. Request deduplication: Preventing duplicate work due to network interruptions in APIs 27. Request validation: Allowing API methods to be called in “safe mode” 28. Resource revisions: Tracking resource change history 29. Request retrial: Algorithms for safely retrying API requests 30. Request authentication: Verifying that requests are authentic and untampered with

Each design pattern chapter follows the same structure:

Authenticate with OpenID Connect and Apache APISIX

Thu, 09 Mar 2023 07:51:47 +0000

Lots of companies are eager to provide their identity provider: Twitter, Facebook, Google, etc. For smaller businesses, not having to manage identities is a benefit. However, we want to avoid being locked into one provider.

In this article, I want to demo how to use OpenID Connect using Google underneath and then switch to Azure.

OpenID Connect

The idea of an authorization open standard started with OAuth around 2006. Because of a security issue, OAuth 2.0 superseded the initial version. OAuth 2.0 became an in 2012:

Make Your Security Policy Auditable

Tue, 28 Feb 2023 11:14:22 +0000

Following from my previous article, I wrote about putting the right feature at the right place .

I used rate limiting as an example, moving it from a library inside the application to the API Gateway.

Today, I’ll use another example: authentication and authorization.

Securing a Spring Boot application

I’ll keep using Spring Boot in the following because I’m familiar with it. The Spring Boot application offers a REST endpoint to check employees’ salaries.

The Right Feature at the Right Place

Tue, 28 Feb 2023 11:08:14 +0000

Before moving to Developer Relations, I transitioned from Software Architect to Solution Architect long ago.

It’s a reasonably common career move.

The problem in this situation is two-fold:

You know perfectly well software libraries
You don’t know well infrastructure components

It seems logical that people in this situation try to solve problems with the solutions they are most familiar with.

However, it doesn’t mean it’s the best approach.

It’s a bad one in most cases.

Null Safety: Kotlin vs. Java

Mon, 13 Feb 2023 12:12:35 +0000

Last week, I was at the FOSDEM conference. FOSDEM is specific in that it has multiple rooms, each dedicated to a different theme and organized by a team. I had two talks:

Practical Introduction to OpenTelemetry Tracing , in the Monitoring and Observability devroom
What I miss in Java, the perspective of a Kotlin developer , in the Friends of OpenJDK devroom

The second talk is from an earlier post . Martin Bonnin did a tweet from a single slide, and it created quite a stir, even attracting Brian Goetz.

Securing Admin Access to Apache APISIX

Sat, 11 Feb 2023 16:34:59 +0000

API Gateways are critical components in one’s infrastructure.

If an attacker could change the configuration of routes, they could direct traffic to their infrastructure.

Consequences could range from data theft to financial losses.

Worse, data theft could only be noticed after a long time by mirroring the load.

Hence, protecting your API Gateway is of utmost importance.

In this short article, I’ll list a couple of ways to secure your Apache APISIX admin access.

Quest for REST

Fri, 27 Jan 2023 14:48:38 +0000

Since I started working for Apache APISIX , I have tried to deepen my understanding of REST via various means. Did you read my review of API Design Patterns book ?

In the current literature, REST is generally promoted as the best thing since sliced bread. Yet, it comes with lots of challenges. In 2010(!), Martin Fowler wrote a post on the glory of REST . He lists three steps for an API to become truly REST:

2022 in Retrospective

Tue, 10 Jan 2023 08:19:43 +0000

2022 is over, and not a moment too soon. I’ll never forget it: some of my friends had to flee their own country; others are fighting for their freedom as I write this post. I hope they will be safe and that their wishes will come true in 2023.

On the personal and technical side, here’s a summary of the past year from my perspective.

Job change

First and foremost, I changed jobs. I worked for Hazelcast for 3½ years.

Spring Modulith: Have We Reached Modularity Maturity?

Thu, 29 Dec 2022 07:07:29 +0000

One of the main reasons to design microservices is that they enforce strong module boundaries .

However, the cons of microservices are so huge that it’s like chopping off your right hand to learn to write with the left one; there are more manageable (and less painful!) ways to achieve the same result.

Even since the microservices craze started, some cooler heads have prevailed.

In particular, Oliver Drotbohm , a developer on the Spring framework, has been a long-time proponent of the moduliths alternative.

Preparing to Move Away from Twitter

Fri, 16 Dec 2022 06:42:40 +0000

I opened my Twitter account more than 13 years ago, in August 2009. For 12 years, I kept focusing on professional-related content: Java, the JVM, programming, etc. I built my audience, trying to promote good technical content, either my own or stuff that I enjoyed reading.

Then, on February 24^th^, Russia invaded Ukraine. My first visit to Ukraine was in 2014, just after the Maidan revolution. During eight years, I returned there often and made plenty of friends.

Web resource caching: Server-side

Fri, 09 Dec 2022 15:32:42 +0000

The subject of Web resource caching is as old as the World Wide Web itself.

However, I’d like to offer an as-exhaustive-as-possible catalog of how one can improve performance by caching.

Web resource caching can happen in two different places: client-side - on the browser and server side.

In the previous post , I explained the former; this post focuses on the latter.

While client-side caching works well, it has one central issue: to serve the resource locally, it must first have it in the cache. Thus, each client needs its cached resource. If the requested resource is intensive to compute, it doesn’t scale.

Web resource caching: Client-side

Fri, 09 Dec 2022 15:27:44 +0000

The subject of Web resource caching is as old as the World Wide Web itself.

However, I’d like to offer an as-exhaustive-as-possible catalog of how one can improve performance by caching.

Web resource caching can happen in two different places: client-side - on the browser and server-side.

This article is dedicated to the former; the next article will focus on the latter.

Caching 101

The idea behind caching is simple: if a resource is a time- or resource-consuming to compute, do it once and store the result.

A Poor Man's API

Tue, 29 Nov 2022 09:13:38 +0000

Creating a full-fledged API requires resources, both time and money.

You need to think about the model, the design, the REST principles, etc., without writing a single line of code.

Most of the time, you don’t know whether it’s worth it: you’d like to offer a Minimum Viable Product and iterate from there.

I want to show how you can achieve it without writing a single line of code.

The solution

The main requirement of the solution is to use the PostgreSQL database . It’s a well-established Open Source SQL database.

Geo-routing with Apache APISIX

Mon, 07 Nov 2022 16:41:47 +0000

Apache APISIX, the Apache-led API Gateway, comes out of the box with many plugins to implement your use case.

Sometimes, however, the plugin you’re looking for is not available.

While creating your own is always possible, it’s sometimes necessary.

Today, I’ll show you how to route users according to their location without writing a single line of Lua code.

Why geo-routing?

Geo-routing is to forward HTTP requests based on a user’s physical location, inferred from their IP. There are many reasons to do that, and here is a couple of them.

Structured Error Messages for HTTP APIs

Tue, 01 Nov 2022 11:01:18 +0000

Ever since I started to work on the Apache APISIX project, I’ve been trying to improve my knowledge and understanding of REST RESTful HTTP APIs.

For this, I’m reading and watching the following sources:

Books. At the moment, I’m finishing API Design Patterns . Expect a review soon.
YouTube. I’d recommend ErikWilde’ channel . While some videos are better than others, they all focus on APIs.
s. Most RFCs are not about APIs, but a friendly person compiled a list of the ones who are .

Today, I’d like to introduce the “Problem Details for HTTP APIs” RFC, aka , RFC 7807 .

Discuss the Problem, Not the Solution!

Tue, 01 Nov 2022 10:56:17 +0000

As a tech guy, I love to discuss technologies. And as discussions go, it’s generally the comparison kind: JVM vs. Net, Java vs. Kotlin, Go vs. Rust, Maven vs. the unspeakable one, etc.

However, it’s too easy to fall into the quagmire of the merits and flaws of our beloved toys, talk about them for hours, and not reach a satisfactory agreement.

A couple of years ago, I worked as a “Solution Architect”.

Renovate: Dependabot Alternative

Fri, 28 Oct 2022 07:17:55 +0000

I won’t introduce Dependabot . Lots and lots of developers use it daily on GitHub. I do use it as well. However, it suffers from two drawbacks:

While it’s perfectly integrated with GitHub, integrations with other platforms are less seamless.
It’s limited in the list of ecosystems it supports For example, I generally use Docker Compose files for my demos. When necessary, I use Kubernetes. Dependabot supports none.Worse, Dependabot doesn’t accept contributions to add new ecosystems .

Recently, I watched Viktor Farcic’s Automate Dependency Management With Renovate . I found Renovate super neat, thought about using it, and… forgot. Then I stumbled upon another mention of it. It pushed me to implement it in two locations:

Handling Exceptions in Java Lambdas

Sat, 22 Oct 2022 11:36:46 +0000

Java introduced the concept of checked exceptions . The idea of forcing developers to manage exceptions was revolutionary compared to the earlier approaches .

Nowadays, Java remains the only widespread language to offer checked exceptions. For example, every exception in Kotlin is unchecked.

Even in Java, new features are at odds with checked exceptions:the signature of Java’s built-in functional interfaces doesn’t use exceptions.It leads to cumbersome code when one integrates legacy code in lambdas.It’s evident in Streams.

The Maze of Python Dependency Management

Mon, 03 Oct 2022 12:49:11 +0000

For over 20 years, I’ve developed code for the JVM, first in Java, then in Kotlin.

However, the JVM is not a silver bullet, e.g., in scripts:

Virtual machines incur additional memory requirements.
In many cases, the script doesn’t run long enough to gain any benefit performance-wise. The bytecode is interpreted and never compiles to native code.

For these reasons, I now write my scripts in Python. One of them collects social media metrics from different sources and stores them in BigQuery for analytics.

Apache APISIX Loves Rust! (And Me Too)

Mon, 26 Sep 2022 09:23:23 +0000

Apache APISIX is built upon the shoulders of two giants:

NGINX , a widespread Open Source reverse-proxy
OpenResty , a platform that allows scripting NGINX with the Lua programming language via LuaJIT

This approach allows APISIX to provide out-of-the-box Lua plugins that should fit most business requirements. But it always comes a time when generic plugins don’t fit your requirements. In this case, you can write your own Lua plugin.

Introduction to Kubernetes Extensibility

Tue, 20 Sep 2022 09:44:43 +0000

Kubernetes offers a lot of benefits: an enormous ecosystem with plenty of actors, self-healing capabilities, etc. There’s no free lunch, though. It also comes with downsides, chief among them its complexity and operating costs.

However, the more I work with Kubernetes, the more I think its most significant asset is extensibility. If you need something that the platform doesn’t provide by default, there’s an option to develop it yourself and integrate it. In this post, I’d like to list such extension points.

A Quick Glance at the Kubernetes Gateway API

Mon, 12 Sep 2022 09:55:16 +0000

In one of my recent blog posts , I described several ways to access Kubernetes pods. One can access a pod through its IP, but pods are naturally transient. The nominal way is to configure a Service: its IP is stable, and Kubernetes’ job is to keep the mapping between a Service and its underlying pods up-to-date.

Different kinds of services are available: internal only, NodePort to finally allow access from outside the cluster, and LoadBalancer that relies on a third-party component - in general, a cloud provider one.

On Cosmetics vs. Intrinsics in Programming

Mon, 12 Sep 2022 09:39:56 +0000

A ruthless battle occurs every day on the World Wide Web. Its goal is to decide which programming flavor is the best: or ? I assume that imperative and procedural programming are not part of the contenders.

Arguments range from the factual to the irrelevant to the utterly stupid. A couple of years ago, I wanted to listen to a video of Martin Odersky (of Scala fame). I remember neither the exact talk nor the subject. What I remember is the introduction, though: he explained that FP was more popular than OOP… because there were many more conferences dedicated to the former than to the latter.

Learning by Auditing Kubernetes Manifests

Mon, 05 Sep 2022 08:44:17 +0000

Last year, I spoke at the National DevOps Conference that took place at the British Museum. I had already visited the museum before, but speaking there was a fantastic experience. Besides, we had the museum all for ourselves for a couple of hours. If you’ve ever visited the place, you know what I mean.

Anyway, I also attended a talk about Checkov :

Checkov scans cloud infrastructure configurations to find misconfigurations before they’re deployed.

End-to-End Tracing with OpenTelemetry

Mon, 29 Aug 2022 14:24:00 +0000

Whether you implement microservices or not (and you probably shouldn’t), your system is most probably composed of multiple components.

The most straightforward system is probably made of a reverse proxy, an app, and a database.

In this case, monitoring is not only a good idea; it’s a requirement.

The higher the number of components through which a request may flow, the strongest the requirement.

However, monitoring is only the beginning of the journey.

Back to Basics: Accessing Kubernetes Pods

Mon, 22 Aug 2022 13:56:58 +0000

Kubernetes is a colossal beast. You need to understand many different concepts before it starts being useful.

When everything is set up, you’ll probably want to expose some pods to the outside of the cluster.

Kubernetes provides different ways to do it: I’ll describe them in this post.

Setup

For the sake of the demo, I’ll be using Kind :

kind is a tool for running local Kubernetes clusters using Docker container “nodes”. kind was primarily designed for testing Kubernetes itself, but may be used for local development or CI.

Backend-for-Frontend: The Demo

Mon, 15 Aug 2022 18:29:48 +0000

In one of my earlier posts , I described the Backend-for-Frontend pattern.

In short, it offers a single facade over multiple backend parts.

Moreover, it provides each client type, e.g., desktop or mobile, exactly the data that it needs and not more in the format required by this client type.

The use-case

Imagine the following use-case.

In an e-commerce shop, the home page should display multiple unrelated data at once.

Products: The business could configure which items are shown on the home page. They could be generic, “hero” products, or personalized, products that the customer ordered previously.
News: Again, the newsfeed could be generic or personalized.
Profile-related information
Cart content
Non-business related information, such as build number, build timestamp, version, etc.

Depending on the client, we want more or less data. For example, on a client with limited display size, we probably want to limit a product to its name and its image. On the other hand, on desktop, we are happy to display both the above, plus a catch phrase (or a more catchy - and longer - name) and the full description.

Write Your Own Service Discovery Client for Apache APISIX

Mon, 01 Aug 2022 10:27:42 +0000

API Gateways in general, and Apache APISIX in particular, provide a single entry point into one’s information system.

This architecture allows for managing load balancing and failover over similar nodes.

For example, here’s how you can create a route balanced over two nodes in Apache APISIX:

curl http://localhost:9080/apisix/admin/routes/1 -H 'X-API-KEY: edd1c9f034335f136f87ad84b625c8f1' -X PUT -i -d '{
 "uri": "/*",
 "upstream": {
 "type": "roundrobin",
 "nodes": {
 "192.168.0.1:80": 1, # 1
 "192.168.0.2:80": 1 # 1
 }
 }
}'

Every request has a 50/50 chance of being sent to either node

It worked for a long time, but in this day and age, nodes are probably not pets but cattle: they come, and they go. Hence, it’s essential to dynamically update the nodes list when it happens.

Discussing Backend For Front-end

Mon, 25 Jul 2022 14:49:18 +0000

In the good old days, applications were simple. A browser sent a request to a webapp endpoint; the latter fetched data from a database and returned the response.

The rise of mobile clients and integrations with other apps upset this simplicity. I want to discuss one solution to handle the complexity in this post.

The increased complexity of system architecture

Let’s first model the above simple architecture.

Mobile clients changed this approach. The display area of mobile clients is smaller: just smaller for tablets and much smaller for phones.

How to Secure Your Web Apps With An API Gateway

Mon, 18 Jul 2022 18:50:10 +0000

API management solutions, also known as API gateways, are a must in this day and age of APIs.

However, once you’ve set up such a gateway, you can use it for different purposes unrelated to APIs.

Today, I want to show you how to improve the security of web apps.

Prevent sniffing

Browsers are fantastic pieces of technology that try to make the life of users as comfortable as possible.

Taking VSCodium for a Spin

Tue, 12 Jul 2022 08:10:30 +0000

As part of my new job on Apache APISIX , I write less Java and Kotlin code.

And when I do, the code is really simple .

My coding hours (unfortunately not days) involve:

A lot of containerization, including Dockerfile, docker-compose.yml, and soon Kubernetes manifests
Some Python for scripting jobs - I abandoned Kotlin Scripting for this
A bit of Lua because I want to learn it as part of my job
A bit of Rust because I want to learn it for fun
A bit of Kotlin because I still love it

Because of this, I didn’t renew my IntelliJ Ultimate license early this year, and I fell back on the Community one.

Hard Things in Computer Science

Mon, 27 Jun 2022 08:13:01 +0000

If you’ve more than a couple of years of experience in IT, you probably have stumbled upon the following quote:

There are only two hard things in computer science: cache invalidation and naming things. – Phil Karlton

Then, because it’s such a great quote, it evolved:

However, I think that the initial quote is misleading. A lot of things are hard in computer science. This post aims to describe some of them.

What I Miss in Java, the Perspective of a Kotlin Developer

Wed, 15 Jun 2022 08:15:34 +0000

Java has been my bread and butter for almost two decades.

Several years ago, I started to learn Kotlin; I never regretted it.

Though Kotlin compiles to JVM bytecode, I sometimes have to write Java again.

Every time I do, I cannot stop pondering why my code doesn’t look as nice as in Kotlin.

I miss some features that would improve my code’s readability, expressiveness, and maintainability.

This article is not meant to bash Java but to list some features I’d like to find in Java.

My Summary of jPrime 2022

Wed, 08 Jun 2022 18:37:55 +0000

Writing summaries of conference talks is the best way to focus on the talk and listen actively.

Before conference speaking became part of my job, I was already doing it.

However, I don’t attend that many talks now, and I don’t take notes when I do.

jPrime is a conference in Bulgaria, and after two cancellations due to Covid, they had their edition this week.

Probably, for this reason, the atmosphere is quite emulating: I attended a couple of talks and here are my notes.

Running Jekyll on a Mac

Mon, 06 Jun 2022 17:41:49 +0000

At the beginning of the year, I had two new Macs in a row in one month. I changed my company and had to return my previous laptop. Thus, I ordered a replacement one, but due to the current hardware shortage, the shipping took weeks: I had to rent one in the meanwhile.

It means I had to install my Jekyll stack twice in a row. The first time took quite some time; the second one was much faster.

Chopping the Monolith: The Demo

Mon, 23 May 2022 12:53:49 +0000

In my previous blog post Chopping the Monolith , I explained my stance on microservices and why it shouldn’t be your golden standard.

However, I admitted that some parts of the codebase were less stable than others and had to change more frequently.

I proposed “chopping” these few parts to cope with this requirement while keeping the monolith intact.

As Linus Torvalds once wrote:

Talk is cheap, show me the code!

Toying with Kotlin's Context Receivers

Mon, 16 May 2022 10:39:04 +0000

Kotlin added the idea of Context Receivers in version 1.6.20.

In this article, I’d like to toy with them to understand how useful they can be.

Note that if you want to play along, you’ll need to compile with the -Xcontext-receivers flag.

The main idea behind context receivers is to pass additional parameters to a function without having to do it explicitly.

A simplified model sample

Let’s start with a simple example to show how it works. We want to model a simple transfer operation between two bank accounts.

Conditional Builds on GitLab

Mon, 09 May 2022 09:16:26 +0000

Regular readers of my articles know that I’m using Jekyll to generate my static blog site, together with GitLab. When I push on the master branch, it triggers the generation job.

However, Jekyll is Ruby-based and requires a couple of Gem dependencies. I’ve also added a few plugins. For this reason, I’ve created a Docker image with all required dependencies . Regularly, I update the versions in the Gemfile.lock via Bundler. Afterward, I need to rebuild the Docker image.

Securely Authenticate to Google Cloud from GitHub

Mon, 02 May 2022 08:57:00 +0000

Recently, I designed a simple metrics-tracking system.

A Python script queries different providers’ APIs for metrics, e.g., Twitter, GitHub, etc.

The idea is to run this script each day, store them in Google BigQuery and provide an excellent data visualization in Google Data Studio.

I’m a big fan of automation, so I’m using GitHub Actions.

Accessing Google Cloud with a Service Account

I query the different APIs with different Python libraries. All of them allow authenticating by passing a parameter. In general, it’s a token. One can store the value in a GitHub secret, get it as an environment variable in the GitHub Action and use it in the code.

Chopping the Monolith: Foojay.io Today

Mon, 25 Apr 2022 19:06:50 +0000

If you attend conferences or read technical articles, you could think that microservices are the correct and only way to build a system at the moment.

Despite some pushback from cooler heads, the default architecture is microservices.

In this post, I’d like to argue why it’s wrong.

I’ll first get back to the origin of microservices and the fundamental reason to use them.

Then, I’ll describe why microservices don’t fit most organizations’ structures.

How To Beautify Your GitHub Repo

Tue, 19 Apr 2022 08:16:37 +0000

Whether you like it or not, GitHub has become the primary provider to host one’s code.

You or your company are probably using GitHub.

In this article, I want to highlight some files that you can use to beautify your GitHub repository and make it welcoming and inspiring to those who stop by.

README

I hope that by now, everybody is familiar with READMEs. If you place a README file at the root of your repo, GitHub will display its content on the repo’s homepage.

Handling Null: Optional and Nullable Types

Mon, 04 Apr 2022 08:06:37 +0000

Java has long been infamous for its NullPointerException. The reason for the is calling a method or accessing an attribute of an object that has not been initialized.

var value = foo.getBar().getBaz().toLowerCase();

Running this snippet may result in something like the following:

Exception in thread "main" java.lang.NullPointerException
 at ch.frankel.blog.NpeSample.main(NpeSample.java:10)

At this point, you have no clue which part is null in the call chain: foo, or the value returned by getBar() or getBaz()?

APISIX: An API Gateway the Apache Way

Mon, 28 Mar 2022 07:40:15 +0000

During the pioneer area of the World Wide Web, the content was static. To serve it, a group of developers created a web server, which is now known as the Apache Web Server .

The Apache Web Server is built around a modular architecture. Developers created a module to run CGI scripts to add dynamic content to the lot. Users wrote early CGI scripts in Perl. After a while, it became evident that generating a complete HTML page from scratch was not the best way and that templating - providing an HTML page with placeholders - was a much better approach. The PHP language started like this as a simple templating engine interpreted by a module.

Error Handling in Java and Across Different Languages

Mon, 21 Mar 2022 11:23:46 +0000

I’ve tried Go in the past, and the least I could say is that I was not enthusiastic about it. Chief among my griefs was how the language handled errors, or more precisely, what mechanism it provided developers with to manage them.

In this post, I’d like to describe how a couple of popular languages cope with errors.

A time before our time

I could probably go back a long time, but I needed to choose a baseline at some point. In this post, the baseline is C.

Lessons learned from previous projects

Mon, 14 Mar 2022 13:02:01 +0000

An exciting part of software development is what was unanimously considered good practice at one point in time can be more ambiguous years later. Or even plain wrong. However, you generally need to do it multiple times over time to realize it. Here are my top learnings from my experience in Java projects.

Packaging by layers

When I started my developer career in Java, every project organized their classes by layers - controllers, services and s (repositories). A typical project’s structure would look like this:

Alternatives to DTO

Mon, 07 Mar 2022 11:03:23 +0000

More than a decade ago, I wrote about the :

“A data transfer object is an object that carries data between processes. The motivation for its use is that communication between processes is usually done resorting to remote interfaces, where each call is an expensive operation. Because the majority of the cost of each call is related to the round-trip time between the client and the server, one way of reducing the number of calls is to use an object (the DTO) that aggregates the data that would have been transferred by the several calls, but that is served by one call only.” – Wikipedia

Avoiding Stringly-typed in Kotlin

Mon, 28 Feb 2022 16:35:28 +0000

A couple of years ago, I developed an application in Kotlin based on Camunda to help me manage my conference submission workflow. It tracks my submissions in Trello and synchronizes them on Google Calendar and in a Google Sheet. Google Calendar offers a REST API. As REST APIs go, it’s cluttered with String everywhere. Here’s an excerpt of the code:

fun execute(color: String, availability: String) {
 findCalendarEntry(client, google, execution.conference)?.let {
 it.colorId = color // 1
 it.transparency = availability // 2
 client.events()
 .update(google.calendarId, it.id, it).execute()
 }
}

Set the event’s color. Valid values are “0”, “1”, … to “11”
Set the event’s availability. Valid values are "transparent" and "opaque"

However, my experience has taught me to favor strong typing. I also want to avoid typos. I want to list some alternatives to using String in this post.

System Logger

Fri, 18 Feb 2022 12:34:57 +0000

December was not a good time for Java developers and even less for Ops. The former had to repackage their apps with a fixed Log4J’s version, and the latter had to redeploy them - several times. Yet, every cloud has a silver lining. In my case, I learned about System.Logger.

[

](https://twitter.com/OndroMih/status/1469599938782932992 ) In short, System.Logger is a façade over your logging engine. Instead of using, say, SFL4J’s API and the wanted implementation, you’d use System.Logger instead of SLF4J. It’s available since Java 9, and it’s a bummer that I learned about it only recently.

Backpressure in Reactive Systems

Fri, 11 Feb 2022 10:07:46 +0000

Mid-January, I held a talk at Kotlin.amsterdam based on my post Migrating from Imperative to Reactive (a Spring Boot application).

Because it was a Kotlin meetup, I demoed Kotlin code, and I added a step by migrating the codebase to coroutines.

During Q&A, somebody asked whether coroutines implemented backpressure. I admit I was not sure of the answer, so I did a bit of research.

This post provides information on backpressure in general and how RxJava (v3), Project Reactor and Kotlin’s Coroutines handle it.

The Flatten Maven plugin - fooay.io

Mon, 31 Jan 2022 14:06:05 +0000

One of the Apache Maven committers recently wrote about their plans for Maven 5 . I consider the following one of the most significant changes:

In summary, we need to make a distinction between two POM types: the build POM, stored in the project source control, that uses v5 schema for build time, requiring a new Maven version able to use the new features associated with the new schema. The other one is the consumer POM, that is published to Maven Central in the good old v4 schema, so every past or future build tool can continue to consume pre-built artifacts as usual for their dependencies.

Treat Security as a Risk

Thu, 27 Jan 2022 11:26:57 +0000

Security is the poster child of a Non-Functional Requirement: most people don’t care until the proverbial matter hits the rotary propeller.

Consequences can range from losing reputation to legal liability to putting the business out. In my post on running unsecured code , I concluded that you should treat security as a risk - and left it at that. I think it warrants a dedicated post.

Risk management is pretty much documented . You can find it in many engineering disciplines, if not every one of them. A risk management process consists of the following steps:

You're Running Untrusted Code!

Mon, 17 Jan 2022 08:28:24 +0000

Last December, Log4Shell shortened the nights of many people in the JVM world. Worse, using the earthquake analogy caused many aftershocks after the initial quake.

I immediately made the connection between Log4Shell and the Security Manager. At first, I didn’t want to write about it, but I’ve received requests to do so, and I couldn’t walk away.

[

](https://twitter.com/nicolas_frankel/status/1471140080366632968 )

As a reminder, the Oracle team deprecated the Security Manager in Java 17. One of the arguments it based its decision on is that it was initially designed to protect against applets. Applets were downloaded from the Internet, so they had to be considered untrusted code. Hence, we had to run them in a sandbox.

A Tentative Comparison of Fault Tolerance Libraries on the JVM

Tue, 11 Jan 2022 09:31:19 +0000

If you’re implementing microservices or not, chances are that you’re calling HTTP endpoints. With HTTP calls, a lot of things can go wrong.

Experienced developers plan for this and design beyond just the happy path. In general, fault tolerance encompasses the following features:

Retry
Timeout
Circuit Breaker
Fallback
Rate Limiter to avoid server-side 429 responses
Bulkhead: Rate Limiter limits the number of calls in a determined timeframe, while Bulkhead limits the number of concurrent calls

A couple of libraries implement these features on the JVM. In this post, we will look at Microprofile Fault Tolerance, Failsafe and Resilience4J.

Beautify Third-Party APIs with Kotlin

Tue, 21 Dec 2021 08:15:42 +0000

Scala has popularized the “Pimp my library” pattern:

This is just a fancy expression to refer to the ability to supplement a library using implicit conversions.

– Pimp My Library Pattern in Scala

Kotlin does provide the same capability. However, it achieves it via extension functions. While the generated bytecode is similar to Java’s static methods, the developer experience is the same as adding functions to existing types.

This approach has limitations, though. One cannot update the type hierarchy.

Native-image with Quarkus

Mon, 13 Dec 2021 17:50:08 +0000

So far, we have looked at how well Spring Boot and Micronaut integrate GraalVM native image extension. In this post, I’ll focus on Quarkus :

A Kubernetes Native Java stack tailored for OpenJDK HotSpot and GraalVM, crafted from the best of breed Java libraries and standards.

Creating a new project

Just as Spring Boot and Micronaut, Quarkus provides options to create new projects:

A dedicated quarkus CLI
A Web UI

Quarkus offers a definite improvement over its competitors. Every dependency has a detailed contextual menu that allows:

Multiple Spring Boot Applications in the Same Project

Wed, 08 Dec 2021 16:42:44 +0000

I frequently use the Spring Boot framework in my demos. The latest one is no different. It shows how to achieve using two different code paths:

the command part is implemented via Spring Data JPA
the query part via jOOQ

My use case is a banking application that offers a REST layer allowing clients to call any parts. Demoing the query part is easy enough with curl as the URL is not complex:

Port Management in Local Kubernetes Clusters

Mon, 29 Nov 2021 08:44:25 +0000

Most of my talks contain a demo. A fair share of these demos require multiple “infrastructure” dependencies: a database (or more), Elasticsearch, you name it. To ease my setup and avoid messing up my machine, I use either Docker Compose or Kubernetes locally on my Mac. Both rely on Docker Desktop.

To expose a cluster Service on my host, I use nodePort. Hence, I set a dedicated node port for each service. I need to remember each of them for each demo. Worse, services might be (are) declared across different manifest files.

Native-image with Micronaut

Mon, 22 Nov 2021 10:18:53 +0000

Last week, I wrote a native web app that queried the Marvel API using Spring Boot . This week, I want to do the same with the Micronaut framework.

Creating a new project

Micronaut offers two options to create a new project:

A web UI :

As for Spring Initializr, it provides several features:

Preview the project before you download it
Share the configuration
An API

I do like that you can check the impact that the added features have on the POM. 2. A Command-Line Interface :In parallel to the webapp, you can install the on different systems. Then you can use the mn command to create new projects.

Native-image with Spring Boot

Fri, 19 Nov 2021 11:47:19 +0000

The Cloud has enabled a lot of new usages that were not possible before. Among them stands Serverless:

Serverless computing is a cloud computing execution model in which the cloud provider allocates machine resources on demand, taking care of the servers on behalf of their customers. Serverless computing does not hold resources in volatile memory; computing is rather done in short bursts with the results persisted to storage. When an app is not in use, there are no computing resources allocated to the app.

A List of Cache Providers

Thu, 18 Nov 2021 08:01:25 +0000

Recently, we described several criteria to look at to choose a cache . Now it’s time to list Java cache providers based on these criteria.

Java Caching System
Guava
Caffeine
Ehcache
Infinispan
Coherence Community Edition
Ignite
Geode
Hazelcast

Java Caching System

JCS is a distributed caching system written in Java. It is intended to speed up applications by providing a means to manage cached data of various dynamic natures. Like any caching system, JCS is most useful for high read, low put applications. Latency times drop sharply and bottlenecks move away from the database in an effectively cached system.

Extending Third-Party APIs in Different Languages

Mon, 08 Nov 2021 08:36:05 +0000

The need for shorter and shorter Time-To-Market requires us to integrate more and more third-party libraries. There’s no time for the NIH syndrom anymore, if it ever was. While most of the time the library’s API is ready to use, it may happen that one needs to “adapt” it to the codebase sometimes. How easy the adaptation is depends a lot on the language.

For example, in the JVM, there are a couple of Reactive-Programming libraries: RxJava, Project Reactor, Mutiny, and coroutines. You might need a library that uses types of one library, but you based your project on another.

Hazelcast + Kibana: Best Buddies for Exploring & Visualizing Data

Thu, 04 Nov 2021 14:22:15 +0000

A lot, if not all, data science projects require some data visualization front-end to display the results for humans to analyze. Python seems to boast the most potent libraries, but do not lose hope if you’re a Java developer (or if you’re proficient in another language as well).

In this article I will describe how you can benefit from such a data visualization front-end without writing a single line of code.

Kotlin and FaaS: An Impossible Union?

Tue, 02 Nov 2021 08:40:48 +0000

Some time ago, I read a post describing how to run a serverless Kotlin function on OpenFaaS . While the content is technically correct, I believe the concept itself is very wrong. Such posts can lead people to make ill-advised decisions: “because we can” is hardly a winning strategy.

In this article, I’d like to first explain why the JVM platform is a bad idea for . Then, I’ll proceed to propose alternatives to use Kotlin nonetheless.

How to Choose a Cache: Capabilities

Tue, 26 Oct 2021 13:20:11 +0000

Today, I’d like to provide some help on how to choose a cache solution. I will organize it into two parts:

In this post, we will list what features a cache must have and which ones it can optionally provide. Most criteria are general and can be used regardless of the tech stack, while a couple is specific to the JVM.
In the second part, I’ll list providers and verify their respective capabilities

Why cache?

First, let’s bust a common myth. Using a cache is not the sign of a badly-designed system per se, though it might be the case. Like in many design decisions, a cache is a trade-off.

On Reassessing TestNG vs. Junit

Tue, 19 Oct 2021 08:28:48 +0000

In a recent article on Spring , I advised reassessing one’s opinion now and then as the IT world changes so fast. What was true a couple of years ago could be dead wrong nowadays, and you probably don’t want to base your decisions on outdated data. This week, I’d like to follow my advice.

One of my first posts was advocating for TestNG vs. JUnit. In the post, I mentioned several features that JUnit lacked:

Faster Maven Builds (Part 2): Inside Docker

Thu, 14 Oct 2021 08:33:09 +0000

Following on from different techniques to speed up your Maven builds, I’d like to widen the scope and do the same for Maven builds inside Docker.

Between each run, we change the source code by adding a single blank line; between each section, we remove all built images, including the intermediate ones that are the results of the multi-stage build. The idea is to avoid reusing a previously built image.

Baseline

To compute a helpful baseline, we need a sample project. I created one just for this purpose: it’s a relatively small Kotlin project.

How to Do Faster Maven Builds (Part 1)

Thu, 14 Oct 2021 08:27:35 +0000

Builds require a few properties, chief among them reproducibility. I would consider speed to be low on the order of priorities. However, it’s also one of the most limiting factors to your release cycle: if your build takes T , you cannot release faster than each T. Hence, you’ll probably want to speed up your builds after you’ve reached a certain maturity level to enable more frequent releases.

I want to detail some techniques you can leverage to make your Maven builds faster in this article. The next article focuses on how to do the same inside of Docker.

Multiple Ways to Configure Spring

Wed, 06 Oct 2021 08:55:34 +0000

Two weeks ago, I wrote how you could write a Spring application with no annotations.

Many alternatives are available to configure your Spring app.

I’d like to list them in this post, leaving Spring Boot out of the picture on purpose.

Core concepts

A couple of concepts are central in Spring. The related documentation doesn’t describe most of them. Here is my understanding of them:

Bean : A bean is an object managed by the Spring container
Bean Factory : A bean factory is a component that manages the lifecycle of beans, especially regarding the instantiation of new objects
Bean Definition : A bean definition is the set of properties given to the Spring container and that the requested bean will have, e.g., class, name, scope, dependencies, etc.
Context: A context is a bean factory with additional capabilities (mainly internationalization and event publishing)

To configure a Spring application, one creates one or more contexts and registers the necessary bean definitions in the desired ones. In the following sections, we will configure the following simple model:

Introducing Jetpack Compose for Desktop

Mon, 27 Sep 2021 07:36:24 +0000

The previous articles of this series were dedicated to frameworks that adopted the same traditional Object-Oriented-Programming approach. Components were modeled as classes. This week’s article is dedicated to Jet Compose for Desktop, the new kid on the block that offers a completely different approach.

Getting your feet wet

Originally, Jetpack Compose is a framework for the Android runtime. Compose for Desktop is its port to the .

A Return to Annotation-Free Spring

Fri, 17 Sep 2021 12:03:24 +0000

Some, if not most, of our judgments regarding technology stacks come either from third-party opinions or previous experiences. Yet, we seem to be adamant about them. For a long time (and sometimes even now), I’ve seen posts that detailed how Spring is bad because it uses XML for its configuration. Unfortunately, they blissfully ignore the fact that annotation-based configuration has been available for ages.

And probably for of the same reason, I recently read that Spring is bad… because of annotations. If you belong to this crowd, I’ve news for you: you can get rid of most annotations and even more so if you’re using Kotlin.

Timely Computation of Derived Values

Fri, 10 Sep 2021 09:22:36 +0000

In a recent article here on Foojay , on a real world stream collector, I described the use-case of an e-commerce shop.

In general, interactions in such a shop are the following:

You can browse a catalog of items
Each item has a price tag
You can put x items in your cart

This is where the exciting part starts.

On most pages, you want to give users a condensed view of their cart’s state.

Looking For Free Docker Registries

Tue, 24 Aug 2021 07:19:37 +0000

Since Docker announced that it would remove unused images from Docker Hub, I’ve been interested in listing places where I could host mine.

As it’s for personal purposes, I’m interested in free plans. Here’s what I found:

| Provider | Private? | Monthly limit || Details |

Provider	Private?	Storage	Transfer	Details
Docker Hub	1	❓	* Anonymous: 100 pulls / 6 hours * Authenticated: 200 pulls / 6 hours
GitLab	✅	10Gb	❓	* Storage quota is per-project * Quota includes all artifacts, including code
GitHub	✅	> GitHub Container Registry is currently in public beta and subject to change. During the beta, storage and bandwidth are free
AWS	* First year only * 500Mb storage	50Gb	* Anonymous: 500Gb * Authenticated: 5Tb
IBM Cloud	✅	500Mb	5Gb

Here are some additional options with their associated pricing model:

Updating Data Files: Commits vs. Pull Requests?

Wed, 18 Aug 2021 17:22:05 +0000

For once, I’m wondering a bit if this article can be helpful to somebody else since I believe my context is pretty specific. Anyway, just in case it might be the helpful case, here it is!

My Jet Train project makes use of GTFS . GTFS stands for General Transit Feed Specification. It models public transportation schedules and their associated geographic information.

GTFS is based on two kinds of data, static data, and dynamic data. Static data may change but do so rarely, e.g., transit agencies and bus stations. They are available as static files that you need to download now and then. Before, I had to download and overwrite them every time I run the demo.

GitLab: Your Continuous Deployment One-Stop Shop

Wed, 04 Aug 2021 07:44:20 +0000

This week, I want to take a break from my Rust series and focus on a different subject. I’ve already written about my blogging stack in detail.

However, I didn’t touch on one facet and that facet is how I generate the static pages from Jekyll. As I describe in the blog post, I’ve included quite a couple of customizations. Some of them require external dependencies, such as:

A for PlantUML diagrams generation
The graphviz package for the same reason
etc.

All in all, it means that I require a fully configured system. I solved this problem by using containerization, namely Docker. Within the Dockerfile, I’m able to install all required dependencies. Then, in my GitLab build file, I can reference this image and benefit from all its capabilities.

An Introduction to Rust and the JVM

Tue, 27 Jul 2021 10:26:20 +0000

So far, we have learned the basics of Rust syntax, developed a custom Kubernetes controller, and integrated with the front-end with .

This is the 7^th^ post in the in the Start Rust series.

I’ve been using the for two decades now, mainly in Java. The JVM is a fantastic piece of technology. IMHO, its most significant benefit is its ability to adapt the native code to the current workload; if the workload changes and the native code is not optimal, it will recompile the bytecode accordingly.

Announcement: Friends of OpenJDK Podcast #1

Fri, 09 Jul 2021 08:39:39 +0000

Foojay community members discuss recent news:

JavaFX Skins for cross-platform apps on Android, iOS, and regular computers.
BlockHound, for detecting cases of blocking in reactive (non-blocking) applications.
JEP 411, the SecurityManager deprecation
The recent Snyk/Azul community survey

Sorry, this recording got “lost in cyberspace…”

BlockHound and Blocking Calls: How It Works

Tue, 22 Jun 2021 17:09:13 +0000

One of the talks in my current portfolio is Migrating from Imperative to Reactive . The talk is based on a demo migrating from Spring WebMVC to Spring WebFlux in a step-by-step approach. One of the steps involves installing BlockHound : it allows to check whether a blocking call occurs in a thread it shouldn’t happen and throws an exception at runtime when it happens.

I’ve presented this talk several times in the previous week, both in its Java version and its Kotlin one. One such presentation was at Javaday Istanbul . After the talk, one of the questions I received was, “How does BlockHound work?” I admit that at the time, I couldn’t remember. After the surprise had passed, but too late, I remembered it involved a Java agent. But I wanted to go down the rabbit hole.

Getting Started Hacking Third-Party APIs on the JVM

Thu, 27 May 2021 06:27:58 +0000

The JVM ecosystem is mature and offers plenty of libraries, so you don’t need to reinvent the wheel. Basic - and not so basic - functionalities are just a dependency away. Sometimes, however, the dependency and your use-case are slightly misaligned.

The correct way to fix this would be to create a Pull Request. But your deadline is tomorrow: you need to make it work now! It’s time to hack the provided API.

Querying Your In-Memory-Data-Grid: Why and How?

Fri, 21 May 2021 07:11:28 +0000

An in-memory data grid (IMDG) is a set of networked/clustered computers that pool together their random access memory (RAM) to let applications share data with other applications running in the cluster. Though IMDGs are sometimes generically described as a distributed in-memory data store, IMDGs offer more than just storage. IMDGs are built for data processing at extremely high speeds. They are designed for building and running large-scale applications that need more RAM than is typically available in a single computer server. This enables the highest application performance by using RAM along with the processing power of multiple computers that run tasks in parallel. IMDGs are especially valuable for applications that do extensive parallel processing on large data sets.

Introducing Teeing: A Hidden Gem in the Java API

Wed, 12 May 2021 07:15:07 +0000

Last week, I described a use-case for a custom Stream Collector. I received a intriguing comment on Twitter:

Hats off to you, Miguel! Your comment revealed a method I didn’t know!

So I decided to investigate what is the teeing() method about.

Returns a Collector that is a composite of two downstream collectors. Every element passed to the resulting collector is processed by both downstream collectors, then their results are merged using the specified merge function into the final result.

A Real-World Example of a Stream Collector

Fri, 07 May 2021 07:34:45 +0000

Java Stream’s Collectors methods fit most use-cases. They allow returning either a Collection or a scalar. For the former, you use one of the toXXX() method, for the latter, one of the reducing() one.

Let’s imagine an e-commerce platform that implements a shopping cart. The cart is modeled as the following:

This diagram might translate into the following (abridged) code:

public class Product {

 private final Long id; // 1
 private final String label; // 1
 private final BigDecimal price; // 1

 public Product(Long id, String label, BigDecimal price) {
 this.id = id;
 this.label = label;
 this.price = price;
 }

 @Override
 public boolean equals(Object object ) { ... } // 2

 @Override
 public int hashCode() { ... } // 2
}

Getters
Only depend on id

public class Cart {

 private final Map<Product, Integer> products = new HashMap<>(); // 1

 public void add(Product product) {
 add(product, 1);
 }

 public void add(Product product, int quantity) {
 products.merge(product, quantity, Integer::sum);
 }

 public void remove(Product product) {
 products.remove(product);
 }

 public void setQuantity(Product product, int quantity) {
 products.put(product, quantity);
 }

 public Map<Product, Integer> getProducts() {
 return Collections.unmodifiableMap(products); // 2
 }
}

Organize products into a map. The key is the Product; the value is the quantity.
Remember to return a read-only copy of the collection to maintain encapsulation.

Once we have defined how we store data in memory, we need to design how to display the cart on-screen. We know that the checkout screen needs to show two different bits of information:

Taking a Closer Look at Kotlin's Delegation

Fri, 30 Apr 2021 13:53:00 +0000

Kotlin offers many exciting features. In general, developers tend to cite null safety as their favorite. For me, it’s function extensions. But delegation comes a close second.

The delegation pattern

The delegation pattern is described in the book:

Delegation is a way to make composition as powerful for reuse as inheritance [Lie86, JZ91]. In delegation, two objects are involved in handling a request: a receiving object delegates operations to its delegate . This is analogous to subclasses deferring requests to parent classes. But with inheritance, an inherited operation can always refer to the receiving object through the this member variable in C++ and self in Smalltalk. To achieve the same effect with delegation, the receiver passes itself to the delegate to let the delegated operation refer to the receiver.

An Example of Overengineering - Keep it WET

Wed, 28 Apr 2021 09:20:52 +0000

This week’s post is pretty short. I’ve already written about overengineering , but this adds a personal touch.

I had to rewrite my Jet Train demo to use another data provider, switching from a Swiss one to a Bay Area one. One of the main components of the demo is a streaming pipeline.

The pipeline:

Reads data from a web endpoint
Transforms data through several steps
Writes the final data into an in-memory data grid

Most of the transform steps in #2 enrich the data. Each of them requires an implementation of a BiFunction.

Hazelcast, from Embedded to Client-Server

Fri, 23 Apr 2021 06:58:00 +0000

Java developers are particularly spoiled when using Hazelcast. Because Hazelcast is developed in Java, it’s available as a JAR, and we can integrate it as a library in our application. Just add it to the application’s classpath, start a node, and we’re good to go. However, I believe that once you start relying on Hazelcast as a critical infrastructure component, embedding limits your options. In this post, I’d like to dive a bit deeper into the subject.

How to create your own custom Spring Data repository

Wed, 14 Apr 2021 07:33:08 +0000

Frameworks promise to speed up one’s development pace provided one follows the mainstream path.

The path may be more or less narrow. I’m a big fan of the Spring ecosystem because its design is extensible and customizable at different abstraction levels: thus, the path is as large as you need it to be.

Functional Programming is becoming more and more popular. Spring provides a couple of s for the Kotlin language. For example, the Beans DSL and the Routes DSL allow for a more functional approach toward Spring configuration. On the type side, Vavr (previously Javaslang) is pretty popular in Java, while Kotlin has Arrow .

How to Change a Field's Type in Recent JDKs

Thu, 08 Apr 2021 07:40:56 +0000

A couple of years ago, I attended a talk by my former colleague (but still friend) Volker Simonis . It gave me the idea to dig a bit into the subject of how to secure the JVM. From the material, I created a series of blog posts as well as a talk .

From that point on, I submitted the talk at meetups and conferences, where it was well-received. Because I like to explore different areas, I stopped to submit other proposals. Still, the talk is in my portfolio, and it was requested again in 2021. I have already presented it twice since the beginning of the year at the time of this writing.

A (Definitive?) Guide to LazyInitializationException

Mon, 29 Mar 2021 07:19:49 +0000

Posts that have been written about Hibernate’s LazyInitializationException could probably fill whole books.

Yet, I believe each of them focuses on a particular aspect of it: some on a specific solution, some on how to solve it with Spring Boot, etc.

I’d like this post to be the definitive guide on the subject, even though I’m pretty sure it won’t. At least, I’ll be able to point others to it!

Kicking Spring Native's Tires with GraalVM

Mon, 22 Mar 2021 17:18:05 +0000

I’ve been playing with GraalVM Ahead-Of-Time compilation capability since I became aware of it. As a long-time Spring aficionado , I carefully monitored the efforts that the engineers at Tanzu have put into making Spring AOT-compatible. Recently, they announced the beta version of the integration.

In this post, I want to check how easy it is to produce a (working!) Docker image from an existing Spring Boot application.

Introduction

GraalVM provides many different features. Among them, the component known as Substrate VM allows to AOT-compile regular bytecode to a native executable. The process “walks” the application starting from the main method at build time. Substrate VM leaves out the code that it doesn’t follow out from the resulting binary.

Monitoring Across Frameworks: Spring Boot, Quarkus, Micronaut, Helidon

Tue, 02 Mar 2021 18:44:07 +0000

Gone are the times when developers’ jobs ended with the release of the application. Nowadays, developers care more and more about the operational side of IT: perhaps they operate applications themselves, but more probably, their organizations foster increased collaboration between Dev and Ops.

I started to become interested in the Ops side of software when I was still a consultant. When Spring Boot released the Actuator, I became excited. Via its convention-over-configuration nature, it was possible to add monitoring endpoints with just an additional dependency.

Learning About Optional.stream() in OpenJDK and Java

Mon, 22 Feb 2021 17:11:33 +0000

This week, I learned about a nifty “new” feature of Optional that I want to share in this post. It’s available since Java 9, so its novelty is relative.

Let’s start with the following sequence to compute the total price of an order:

public BigDecimal getOrderPrice(Long orderId) {
 List<OrderLine> lines = orderRepository.findByOrderId(orderId);
 BigDecimal price = BigDecimal.ZERO; // 1
 for (OrderLine line : lines) {
 price = price.add(line.getPrice()); // 2
 }
 return price;
}

Provide an accumulator variable for the price
Add each line’s price to the total price

Nowadays, it’s probably more adequate to use streams instead of iterations. The following snippet is the equivalent to the previous one:

How to Create Self-Contained Executable JARs

Mon, 01 Feb 2021 08:40:08 +0000

When your application goes beyond a dozen of lines of code, you should probably split the code into multiple classes. At this point, the question is how to distribute them. In Java, the classical format is the Java ARchive, better known as the JAR. But real-world applications probably depend on other JARs.

This article aims to describe ways to create self-contained executable JARs, also known as uber-JARs or fat JARs.

Nicolas Frankel on foojay.io - Friends of OpenJDK

From a JAR to a full-fledged MacOS app

Transactions and ThreadLocal in Spring

KCDC 2025

GitHub workflows tips and tricks

What are GitHub workflows?

Git default options

git push

OpenTelemetry configuration gotchas

The promise of OpenTelemetry

OpenTelemetry Tracing on the JVM

Commonalities

Pattern-matching across different languages

Java’s pattern matching

Testing an OpenRewrite Recipe

Book Review: Writing for Developers

Authoring an OpenRewrite Recipe

Cloudflare Tunnel for Home Assistant

The initial setup

Getting a single value from a device's state in Home Assistant

Improving Maven's dependency:analyze... or not

Mutation Testing in Rust

Starting with cargo-mutants

The try block in Rust

The limit of the ? operator

One giant Kubernetes cluster for everything

WebAssembly on Kubernetes

Pull request testing on Kubernetes: testing locally and on GitHub workflows

Pull Request testing on Kubernetes: Working with GitHub Actions and GKE

Pull request testing on Kubernetes: vCluster for isolation and costs control

Book Review: DuckDB in Action

Facts

Remote Development Made Simple with DevPod

The problem

My first steps with Playwright

A solution to the problem of cluster-wide CRDs

A short intro to CRDs

An Example of HACS: Adaptive Lighting

2024 in Retrospective: Nicolas Frankel

The Home Assistant Model

Why Home Assistant

Langchain4J Musings

Summary of the AJAX Frameworks Comparison

Analysis

Vaadin: Battery-Included Server-Side AJAX Framework

Short introduction to Vaadin

Augmenting the client with HTMX

Laying out the work

Augmenting the client with Alpine.js

Laying out the work

Server-side

Augmenting the client with Vue.js

Server-Side Rendering with Spring Boot

A Short History of AJAX and SSR

Health Check Response Format for HTTP APIs

DRY your Apache APISIX config

The DRY principle

Implementing the Idempotency-Key specification on Apache APISIX

When (not) to write an Apache APISIX plugin

OpenTelemetry Tracing on Spring Boot, Java Agent vs. Micrometer Tracing

Free tier API with Apache APISIX

A naive approach

Differentiating rate limits in Apache APISIX

Random and fixed routes with Apache APISIX

Advanced URL Rewriting with Apache APISIX

Dynamic watermarking with imgproxy and Apache APISIX

Dynamic watermarking on the JVM

Renovate for everything

Even More Opentelemetry!

Foojay Podcast #53: JCON Report, Part 5 – CQRS, JOOQ, GraphQL, API, Vaadin, OpenRewrite, ErrorProne, Gateways, Proxies,...

Video

Podcast Apps

Workflow, From Stateless To Stateful

My opinion on the Tauri framework

The Vary HTTP Header

The problem

Five ways to pass parameters to Apache APISIX

General setup

Using my new Raspberry Pi to run an existing GitHub Action

Context

Starting with `cargo-mutants`

The limit of the `?` operator