tty4.dev

Usage of Git worktrees

Sat, 14 Mar 2026 15:38:00 +0100

Recently, I read more and more about Git working trees being used for parallel agents for example in Cursor or VSCode.

However, worktrees are also useful for maintaining an uninterrupted workflow when working on multiple things within the same repository.

git worktree commands are used to manage working trees.
They are executed from the main repository.

Create a worktree

git worktree add -b feat-a ../feat-a main

What this does:

Creates a directory relative to the repository in ../feat-a
Checks out a new branch named feat-a in that directory
The branch starts from the commit currently pointed to by main

The directory structure will look something like this with the given branch and commit:

Client-side inference using onnxruntime

Thu, 26 Feb 2026 20:20:00 +0100

This post is part of a series. Here is an overview of all posts.

tl;dr you can use the model here, play around and check the code.

The ONNX Runtime for web makes it possible to serve an ML model and run inference within browsers. This enables ML on Edge and enhances the privacy of the user.

Using the runtime I serve my latest favour model. It’s possible to use it here. Type in the data and see how likely I’d like the article (calculation skews are possible).

5 practical use-cases for an ML-powered RSS digest

Mon, 23 Feb 2026 18:54:00 +0100

This post is part of a series. Here is an overview of all posts.

Creating an RSS digest is fun, but it’s even more fun, when you have a real use-case for it.

So this post checks the different possible ways of using it. Keep in mind that these are all ideas I have to use it, I’m sure there are many more, you can let me know if you have a nice idea. :)

Optimizing a model by using metrics

Fri, 20 Feb 2026 21:17:00 +0100

This post is part of a series. Here is an overview of all posts.

The past post mentioned metrics to track the performance of a model.

This post shows how to use them for optimizing a model and how it helped to improve the AUC from 0.59 to 0.84.

Tracking metrics

During the model training the following five metrics have been tracked:

Loss: Measures prediction error; if training loss drops while validation loss climbs, the model is likely overfitting. This means the model is memorizing rather than generalizing.
AUC (Area Under the ROC Curve): Evaluates how well the model ranks positives over negatives.
Precision: The accuracy of positive predictions, or the percentage of “flagged” articles that were actually correct.
Recall: The model’s “find rate,” measuring what percentage of all truly positive articles were successfully identified.
F1 Score: The harmonic mean that balances precision and recall into a single representative number.

These metrics can be used to track training progress and use them for model optimizations!

Defining, tracking and training a machine learning model

Fri, 13 Feb 2026 21:39:00 +0100

This post is part of a series. Here is an overview of all posts.

This continues the journey on creating a RSS digest. The final step to get a working machine learning model is to implement the training pipeline.

In a previous post the data has been prepared. This post shows how to define the model, train it and use it for predictions.

Defining the model

PyTorchs nn.Module can be sub-classed and nn.Sequential used to define the sequence of layers to be used in a model:

Building an RSS digest: All posts

Fri, 13 Feb 2026 21:21:00 +0100

This aims to give a better structure to read the posts about the RSS digest implementation.

To give a better entrypoint about the existing posts and in which order to read what, if interested:

Building an ML-powered RSS digest outlines the idea and motivation.
Technical view of a recommendation system is a good entrypoint for a general overview of the system.
Collecting labels to train a model for an RSS digest collects the labels used for the model.
Selecting the features for the RSS digest uses feature engineering to collect the input data.
Training two models for better results in recommendation systems describes the idea of training two models for getting better results in the RSS digest.
Dataset preparations for training a machine learning model prepares the data for the training.
Defining, tracking and training a machine learning model trains the model and tracks metrics.
Optimizing a model by using metrics has a closer look at the metrics and how to use them for optimizations.
Optimizing a model by using metrics checks some use-cases for the results the model gives.
Client-side inference using onnxruntime shows how to serve and use a model for inference in the browser.

This list will be kept up to date.

Note taking in 2026

Mon, 09 Feb 2026 10:17:00 +0100

Since my last post about note-taking many things have changed.

Not so long after starting using Trilium I changed back to a flow based on the Foam VSCode extension + VSCode snippets.

Although Trilium provides many helpful features like a good text search, desktop app, mobile site and many more, I found very early that it’s the wrong tool for my everyday usage as a software engineer.

The main purpose of a note-taking tool should be to serve only one purpose: Let me write down things fast to find it later again. I don’t want to maintain the tool and I don’t want to need to re-discover features after an UI update etc.

Dataset preparations for training a machine learning model

Sat, 07 Feb 2026 16:27:00 +0100

This post is part of a series. Here is an overview of all posts.

Before running the training of a model the following things need to be done:

Features need to be selected: deciding which input variables/attributes will be used to make predictions
Featuresets need to be labelled: annotating the data with the correct outputs/targets
Dataset need to be prepared: organizing features into a structured format suitable for training (handling missing values, splitting into train/test sets, normalization, …)

This posts will give a sample on how to prepare the dataset based on the recommendation system project.

Training two models for better results in recommendation systems

Tue, 03 Feb 2026 19:08:00 +0100

This post is part of a series. Here is an overview of all posts.

The first version of the machine learning model I’ve created for the recommendation system based on my RSS feed should be trained on two labels: The click & favorite label.

The initial idea was to have two labels represented as an array: [ P(click), P(favoured) ].

A clicked and favoured article would look like [1, 1]. And the model would return a prediction like [0.98, 0.71].

docfind - the static search for the VSCode site

Sun, 25 Jan 2026 19:39:00 +0100

In the past I’ve been writing about some approaches I did for creating a static search for this page.

The search is removed due to the additional maintenance needed when creating the site, but my interest in this topic still exists to some degree.

Recently, I stumbled upon this blog entry about the static search created for the VSCode website. It’s called docfind and uses also WebAssembly and a pre-created index.

Under the hood docfind (which is open sourced at GitHub) uses a more engineered approach for fast search results. Also, it’s nice to see that others are having same problems they solve with a comparable tech-stack.

Technical view of a recommendation system

Sat, 17 Jan 2026 14:00:00 +0100

This post is part of a series. Here is an overview of all posts.

This post in the series about building an RSS digest takes a look at the system.

The following gives an overview of the components to be build.

The rectangles are components and the ellipses / circles are outputs.

In the following sections the components and their outputs will be described more closely

The labeller

The Labeller is responsible for labelling the articles according to how the user interacts with the UI. This is an API which retrieves the following payload:

Selecting the features for the RSS digest

Thu, 08 Jan 2026 21:00:21 +0100

This post is part of a series. Here is an overview of all posts.

The previous post described how to label articles in a feed reader and store the labels.

The post also contained this small view on the idea:

Label articles → Create model → Use model to predict click/fav rate.

This post will focus on a sub-step of the “Create model” part: Feature Engineering.

Features are the input data for the model to be trained on. The Labels created in the post before are the outputs the model should create based on the features.

Collecting labels to train a model for an RSS digest

Sun, 04 Jan 2026 14:08:11 +0100

This post is part of a series. Here is an overview of all posts.

As written in a post before I aim to create an RSS digest for the feeds I subscribed to.

The very high-level idea is:

Label articles → Create model → Use model to predict click/fav rate.

The first step towards this goal is to label articles in the feed reader.

This article describes which labels will be collected and how/where they’re stored. I used FreshRSS, but I’ll keep this article agnostic to every other reader and describe the general ideas.

Building an ML-powered RSS digest

Fri, 02 Jan 2026 12:59:45 +0100

This post is part of a series. Here is an overview of all posts.

RSS is one of my favorite ways to consume tech news and blogs.

Although it seems to be pretty dead for the broad masses, RSS feeds enable nice features through feed readers:

Subscribe to and collect multiple sources at one place - no browsing and manual search needed.
No push notifications - I can read it whenever I want.
Self-hosted feed readers - I own my data and don’t need to pay.

I don’t collect any statistics about it, but by my feeling I’m pretty sure that my feed reader is one of the top 5 sites which I visit daily.

Temporary script, turned into a long-term solution

Sun, 21 Dec 2025 12:46:05 +0100

It was in one of my first jobs where I got tasked to serve a customer a file with some interesting data points about users of a system created for him.

All the customer wanted to create a JSON file and place it on an SFTP server on regular basis, so that he could pull it and do some magic with Power BI.

I was instructed to not use too many resources on it, because it was supposed to be only a temporary solution which was planned to be replaced within the next weeks and the customer won’t pay much for it.

I deleted my Windows installation

Sun, 14 Dec 2025 13:58:11 +0100

Until recently I had two installations on my computer: One SSD contained my Windows installation and the other one Fedora.

I decided to uninstall Windows, as I kept it mainly due to few reasons which proved wrong:

Old data laying there
Keep my Windows skills up to date
For the case I need to solve a problem where Fedora can’t help

All of this proved wrong. I didn’t boot Windows for problem solving since I installed Fedora.

Agent Skills - a thin alternative to the Model Context Protocol?

Sat, 13 Dec 2025 16:40:02 +0100

Just a year passed since the Model Context Protocol (MCP) has been introduced by Anthropic and despite of the traction it got in 2025, it got already concurrency by Anthropic itself: Agent Skills.

Also, it seems that OpenAI is experimenting with the idea.

This makes it worth to have a short look at the differences between the two. I also post some links below if you want to see examples for Agent Skills.

Improving loading times of this site

Sat, 18 Oct 2025 17:02:11 +0100

Although I haven’t posted something on here for a pretty long-time I didn’t forget that this page exists.

Recently, I wanted to do something small. So, I checked this site for something which was bugging me already for a long time: The loading time and size of artifacts loaded.

Although it is a very simple static site, I saw loading times of ~7-10 seconds in my self-experiments. Also, the size of the loaded page was around 6MB.

Building RAG is hard

Wed, 02 Jul 2025 20:51:09 +0100

Building Retrieval-augmented generation (RAG) is hard. At least if you want to get helpful and reliable results.

Take as an example the IIOT (Industrial Internet of Things) world: No one wants to be responsible for a document management system powered by an LLM and RAG that cites incorrect results, potentially leading to machines being maintained improperly.

At best, it costs the company money. At worst, human lives could be in danger.

How GitHub Copilot Serves 400 Million Completion Requests a Day

Mon, 30 Jun 2025 20:11:12 +0200

At QCon San Francisco Dave Cheney gave an insightful talk about how GitHub Copilot works under the hood and is able to serve 400 Million completion requests a day.

Basically, every request goes through a Proxy that makes use of HTTP/2 and allows to keep the connection open. The powerful HTTP handler in Go makes it possible to drop requests without the need of closing a connection.

The large load is handled by many different locations and concatenating the streams passed to a pool of connections that are talking with the model.

Experiencing Cross-Team Collaboration

Tue, 03 Jun 2025 20:25:02 +0200

The company I’m working for is organizing an event which brings people from different teams together and allows them to work on a topic for one week.

After day two I can say that I enjoy this very much as it enables knowledge sharing and collaboration between teams.

The topic we’re working on is exciting and makes fun. It’s different from my usual day-to-day work and a great learning opportunity.

Cool URIs don't change

Mon, 28 Apr 2025 19:02:11 +0100

During Easter, there was a sale on domains at my hosting provider, and I saw my moment had come and secured a domain I had been eyeing for several weeks.

As you can see, the site has now moved from blog.dkwr.de to tty4.dev. Somehow it all looks more pleasing to my eye, and besides that, the domain is just plain cool and hopefully easier to remember.

But in keeping with “Cool URIs don’t change”, all old references redirect to the new domain via HTTP 301. So nobody - including myself - needs to check everywhere if the domain still works. I also know how annoying it is when you’ve saved bookmarks and after a few weeks the site is no longer available.

A New Home for Home Assistant

Tue, 04 Feb 2025 19:55:20 +0100

I was thinking about moving my Home Assistant instance away from my homelab to an own instance, e.g. to a Raspberry Pi.

The strength of my homelab is that it’s more powerful than a Raspberry Pi. But I found that this has also a few downsides like a higher power consumption. While the noise of the fan is ok for me, it also leads to a higher power consumption.

Furthermore, devices on the other side of my flat have connection problems: Light bulbs occasionally loose their connection and raw bluetooth devices just can’t connect.

Overview of Messaging in Distributed Systems

Fri, 31 Jan 2025 20:50:20 +0100

Messaging in distributed systems is a problem field which has own patterns and aspects. This post takes a brief look at the most important concepts and intends to be used as a primer for further research.

Synchronous vs. asynchronous

First, let’s check the difference between synchronous and asynchronous requests:

Synchronous: A service client makes a request to a service and expects an answer immediately.
Asynchronous: A service client makes a request and isn’t bound to the other service until it answers. The other service replies later when it’s ready.

Asynchronous requests enable loosely coupled services!

Implementing Retrieval-augmented generation (RAG) with an own LLM

Sun, 12 Jan 2025 13:46:19 +0100

In my last post I wrote about Retrieval-augmented generation (RAG) and why it’s needed.

This post shows a practical implementation for the LLM created in my repository.

Choosing a Framework

RAG can be implemented manually, but there are a few frameworks which help to implement the pipeline and make things easier.

I decided to use LlamaIndex for this post, but there are few others like: Haystack or LangChain.

There’s a link for a tutorial at the bottom of the page if you’re interested how to do RAG in LangChain.

Retrieval-Augmented Generation in Large Language Models: The Theory

Tue, 07 Jan 2025 20:38:15 +0100

This post is part of a series. Here is an overview of all posts.

In my former posts I wrote about my experiences in building an LLM from Scratch.

While fine-tuning worked well to make the model better in a specific domain, it opens up the question if the model needs to be re-trained every time when new information is available or how to enhance it with domain-specific knowledge.

The need for Retrieval-augmented generation

Let’s use a coding assistant as an example:

Fine-tuning LLMs Locally vs. In The Cloud

Fri, 03 Jan 2025 11:12:19 +0100

This post is part of a series. Here is an overview of all posts.

This is a short write-up about my experience of training and fine-tuning an LLM. It intends to give an overview about the dimensions which impact good hardware has on training.

I’ve done this in the course of working with the “Build an LLM from Scratch” book. You can find my review in another post, if interested.

This post will give a few numbers to get a feeling for the resources needed and the costs involved. I’ll outline my personal opinion about the different ways I trained the model.

Book review: Building an LLM (From Scratch)

Thu, 02 Jan 2025 10:01:19 +0100

There are many free resources which try to explain what LLMs are and how they work internally. Same applies for implementations. But looking at code and explanations didn’t give me the feeling that I really understand from the ground up how they work. Especially what exactly the transformer architecture is and how it’s implemented.

Luckily, 2024 Sebastian Raschka published the book Build a Large Language Model (From Scratch) at Manning.

I recommend this for anyone, who’s interested in building an LLM by himself to understand the transformer architecture etc.

Visiting the largest computer museum of the world

Sun, 29 Dec 2024 21:46:48 +0100

When driving in Germany on the Autobahn and passing a medium-sized or larger city you’ll see a sign which shows a tourist attraction nearby.

For Paderborn it’s the Heinz Nixdorf MuseumsForum (short: HNF). The HNF is one of the (if not the) largest computer museum of the world.

This year a dream came true and I visited it.

The museum isn’t just about computers: It gives visitors a journey through the history of information and information technology. It shows how information was preserved and carried from one point to another in human history.

Retrospective on Androids: The Team that Built the Android Operating System

Mon, 23 Dec 2024 19:46:11 +0200

I just completed Androids: The Team that Built the Android Operating System by Chet Haase and can fully recommend this book. It’s a book which provides insights into the first days of the Android OS.

The book gives an overview of why Android was started and which underlying ideas led to the big market growth in a highly competitive field.

Also, it shows some tricks that were used to work in such a resource-constrained world as it was when the first smartphones appeared.

Hexagonal Architecture: The Good And The Hard Parts

Fri, 20 Dec 2024 19:34:11 +0100

There’s a lot of stuff written about Hexagonal Architecture. I also wrote some things about it, but covered just the basics.

Now with more experience of using the Hexagonal Architecture style in Java with Spring Boot, I thought it’s time to reflect what are the good and the hard parts of it.

Few Words For The Beginning

You may notice that I don’t write “The Good And The Bad Parts”. That’s because on one side I really like the application of Hexagonal Architecture in the context of professional work. On the other side I found that the “hard parts” are a challenge in nearly every architecture style and not just in Hexagonal Architecture.

Move Code Changes Between Branches With Git Patch Files

Thu, 05 Dec 2024 19:46:11 +0200

With patch files Git provides an easy-to-use way to move code changes between branches.

A patch file contains information about the changed lines in a comparable way like it’s shown when doing a git diff.

Here’s how to use it.

Move code from branch A to branch B

Move code from branch A to branch B, where branch B does not depend on branch A.

On branch A create patch file:

git format-patch -1 COMMIT_ID

On branch B apply the created patch file:

git apply PATCH_FILE

Interactively choose hunks to add:

git add -p

If branch B depends on branch A and you want to move a change to branch B, then you can do the same. But you need to remove the conflicts.

Use dnsmasq for local DNS with wildcard support

Sun, 01 Dec 2024 15:38:34 +0100

Recently, I set up new projects in my homelab.

Generally, my homelab is reachable via the domain atlas.internal.

All projects have their own subdomains like git.atlas.internal, files.atlas.internal, etc..

But beside of that I can reach them also via an opened port.

Security-wise that’s no problem, as my homelab is reachable only within my home network.

The annoyances of this setup

Anyway, I don’t like this:

I need to map ports around and remember them. (Sub-)Domains are far easier to remember.
On my computer I need to extend the /etc/hosts file every time I add a new service.

The last problem is really annoying, as /etc/hosts doesn’t support wildcard domains. So, when I add or remove a service, I need to maintain the hosts file.

Trying local LLMs

Sat, 16 Nov 2024 11:40:34 +0200

There are quite a lot of tools which try to give the same experience as ChatGPT or claude.ai: A nice UI with model selections etc.

Recently, I just wanted to try out different models and found once more that Simon Willisons llm was the best hassle-free solution for this.

Just install the Python package and you’re good to go (see the official page).

llm integrates different plugins to support different formats. One of these is the gpt4all plugin which are available by the GPT4All project

Generating recommendations for blog posts with machine learning

Sun, 27 Oct 2024 20:10:18 +0200

I already wrote twice how to generate recommendations for blog posts with machine learning:

I’m pretty happy about the results and it works without any problems since one year. So, I’ve done a little cleanup of the code and decided to publish it.

You can find the code and general instructions in the repository on GitHub.

Use the recommendations for Hugo

Here’s a small extra for Hugo users.

Git rebase fails because of uncommitted changes, but there are no uncommitted changes

Sat, 26 Oct 2024 15:53:28 +0200

Recently I got the following error when I was doing a git rebase master:

error: Your local changes to the following files would be overwritten by checkout:
      <Omitted list of files>
Please commit your changes or stash them before you switch branches.
Aborting
error: could not detach HEAD

git status showed no unstaged changes, and I confirmed that there were no changes in .gitignored files."

Normally, it helped to execute the following on the branch-to-rebase:

Define An Extensible Or Generic JPA Repository

Sun, 20 Oct 2024 11:22:29 +0200

The @NoRepositoryBean annotation allows to define an extensible / generic JPA repository in Spring Boot:

@NoRepositoryBean
public interface BaseAnimalRepository<T> extends JpaRepository<T, Long>

From the documentation of the @NoRepositoryBean:

This will typically be used when providing an extended base interface for all repositories in combination with a custom repository base class to implement methods declared in that intermediate interface. In this case you typically derive your concrete repository interfaces from the intermediate one but don’t want to create a Spring bean for the intermediate interface.

Capture Logs In Spring Boot Tests

Fri, 11 Oct 2024 20:01:10 +0200

To assert that a specific message is logged in a Spring Boot application, the OutputCaptureExtension can be used.

Here’s an example test:

@ExtendWith(OutputCaptureExtension.class)
public class MyServiceTest {

    private MyService myService = new MyService();
    private static final String MESSAGE = "Hello World!";

    @Test
    public void testLogMessage(CapturedOutput output) {
        myService.logMessage(MESSAGE);
        assertThat(output.getOut()).contains(MESSAGE);
    }
}

The CapturedOutput API serves different methods to get the output.

Ceramic Designs Generated By Claude

Thu, 10 Oct 2024 19:39:10 +0200

Few weeks ago my girlfriend took me to a pottery workshop.

While I like the idea behind it (painting, firing, …) I faced one problem: The last time I was doing art by intention was probably 12 years ago in school.

I got told that the best thing is to paint something ‘simple’ and to paint it according to a template.

A color gradient is maybe the most simple thing, but I thought it would be boring to paint a gradient for 2.5 hours.

Cleaning Up My Digital Life

Sat, 07 Sep 2024 09:39:10 +0200

Currently, I don’t blog that much. This site has a second priority due to summer and other things I do (which I may also be blogging about in the future).

One of these things is cleaning up my digital life.

So, first I have resolved some issues on my homelab, refactored the docker compose scripts and cleaned old data. It feels more organized and more stable now. Furthermore it reflects my current knowledge of docker compose, now. I decided to not rewrite everything, but refactor it. And I think it was a good idea as it didn’t take that long.

Revisiting the HTC Desire (Bravo)

Wed, 21 Aug 2024 17:51:10 +0200

Recently I was thinking about the Smartphones I had and remembered my first one: The HTC Desire (codename Bravo, sometimes also A8181).

That was 13 years ago!

Out of interest I checked eBay and saw that someone was selling it for 15€.

I’m not an impulsive buyer, but this time nostalgia won.

When I unpacked it first, I was surprised. I didn’t remember it being that small.

Here’s a comparison between an iPhone 13 (6.1-inch) and the HTC Desire (3.7-inch):

Wasm Component Model By Example

Thu, 25 Apr 2024 20:49:47 +0200

It’s time to get some practice after answering what the Wasm component model is.

You can find the code at GitHub

Preparations

Before we start, prepare the environment:

You need the latest version of Rust.
Install cargo component:

cargo install cargo-component

Install wasm-tools

cargo install wasm-tools

Install a Wasm runtime which supports the component model, like wasmtime:

curl https://wasmtime.dev/install.sh -sSf | bash

Overview of the application

The application is simple: A component string-operations which exports operations on strings. In this example it’s a function that takes one string parameter and returns its length.

Wasm: What Is The Component Model

Tue, 23 Apr 2024 20:30:10 +0200

In the beginning of this year the WASI preview 2 reached a milestone by being launched.

It got enabled by two things: the WIT IDL and the component model. Let’s check in this post what it is.

From the WASI repository:

WASI Preview 2 represents a major milestone for WASI. It marks the moment when WASI has fully rebased on the Wit IDL and the component model type system and semantics, making it modular, fully virtualizable, and accessible to a wide variety of source languages.

Recommended Apps, Websites And Services For Traveling To Japan

Mon, 15 Apr 2024 20:16:10 +0200

I’m back from Japan and want to give a small collection of tips for apps, websites and services which I found useful before and during my trip.

eSIM

First, I really recommend to get an eSIM.

This will help you to get around easily. Navigating and checking out for restaurants or even translation or product searches will make your life a lot easier.

I think that having an internet connection took out a lot of potential stress during this trip: We took only once a wrong train. And even then it was just a few seconds to get an alternative route.

Wasm: The Garbage Collection proposal

Sun, 14 Apr 2024 10:24:10 +0200

While you can compile languages that rely on a Garbage Collector to Wasm already, there is a big downside: They need to ship with a Garbage Collector.

For example: PHP to Wasm compiled modules ship with a compiled GC. That’s contrary to the idea of Webassembly to serve thin modules.

Furthermore it doesn’t make much sense to come with a compiled GC, because the host most of the time already has a Garbage Collector.

Deep Work For Developers

Mon, 25 Mar 2024 19:26:10 +0100

I have reservations about fully embracing Cal Newport’s Deep Work 100% for software developers. It may work when you have a really high position where you can offload tasks to other people or where it is okay to just not answer emails for a whole day.

What Software Development is Made Of

Software development is a team sport. While I think that the best way of solving hard problems or one(!) task is actually when you get into a flow for 4-5 hours, it may not always be applicable. Sometimes you need to ask someone else for help and distract team members. Other times, someone else on your team needs your help and distracts you. And that’s absolutely fine because that is what software development is made of.

Few Words About Using GitHub Copilot at work

Sun, 24 Mar 2024 10:26:10 +0100

tl;dr:

CoPilot can be really useful, and I don’t want to miss it anymore.
Nevertheless, it’s important to keep in mind that it’s currently not the universal remedy for developer productivity.

By the end of the past year, the company I’m working for bought Github Copilot licenses for (nearly?) all developers.

I was curious if and in which way it helps me in my daily work. So, I took notes about my thoughts.

About: How Netflix Really Uses Java

Fri, 01 Mar 2024 20:26:10 +0100

This talk about “How Netflix Really Uses Java” by Paul Bakker at QCon gives some interesting insights.

Especially the first ~20 minutes about the overall architecture and how it evolved is nice to see.

But, beside of that there were some other think pieces about using Java at higher scale:

Netflix tries to save resources and money, by leveraging configurable Java features like Garbage Collection.

Also, Netflix seemed to be trying to use RxJava, but found some downsides, as many devs did: It is really hard to understand and debug. Some people say it’s hard to develop, because you need to exactly think about what could happen in beforehand. But this can also slow down development.

How Spring MVC Handles Requests: A Detailed View

Sun, 04 Feb 2024 20:54:10 +0100

In my last post I already about the high-level view of how Spring MVC handles incoming requests.

Foreword

This post provides a more detailed view of how Spring handles requests like this:

@PostMapping(value = "login", consumes = MediaType.APPLICATION_JSON_VALUE)
public String login(@RequestBody User user)  {
    return "Logged in!";
}

However, please note: It pertains to version 6.1 of the Spring Framework and may change in the future. Furthermore, it only covers the request processing from the filter chain until the resolution of the request body.

The high-level view of how Spring MVC handles requests

Sat, 03 Feb 2024 19:01:10 +0100

In the recent days I tried to understand how Spring Boot handles requests like this:

@PostMapping(value = "login", consumes = MediaType.APPLICATION_JSON_VALUE)
public String login(@RequestBody User user)  {
    return "Logged in!";
}

Spring MVC is responsible for the handling.

The result is this high-level overview of it which separates its work in three blocks:

A post with a more detailed view follows, but the main block with the component which controls everything is shown in the image: The DispatcherServlet.

Spring: Bind values in x-www-form-urlencoded requests

Tue, 30 Jan 2024 19:59:10 +0100

In Spring Boot it’s not possible to map request field names to property fields with @JsonProperty when a request method is consuming application/x-www-form-urlencoded type of requests. The reason is that there’s no JSON payload in the body to consume.

To resolve this @BindParam has to be used.

Note This feature is available since Spring 6.1. and Spring Boot 3.2.0.

Check the following working example:

@RestController
@RequestMapping(path = "/user/")
public class UserController {

    @PostMapping(value = "login", consumes = MediaType.APPLICATION_FORM_URLENCODED_VALUE)
    public String login(User user)  {
        // user.username is not null
        return "Logged in!";
    }

    @Data
    @AllArgsConstructor
    public static class User {
        @BindParam("user_name")
        private String username;
        private String password;
    }
}

The username property will get the value of the user_name field passed in the request. That behaves the same as using the @JsonProperty in requests of the type application/json with Jackson.

Aggregate exceptions in Spring with ControllerAdvice

Sun, 21 Jan 2024 15:26:10 +0100

Exceptions can affect the readability of code in a negative way. One way to mitigate this is to handle exceptions in one central place.

In Spring Boot you can use @ControllerAdvice for this.

I’ll show an example, but keep in mind that there’s more than shown here. So, read up the Javadoc for ControllerAdvice to get more information on the features and ways to configure it.

The problem

Let’s say the following exception is thrown anywhere in the code:

Javadoc Generation Error: Bad HTML Entity

Sun, 07 Jan 2024 12:24:10 +0100

Recently when I tried to generate some Javadoc I got an error like this:

error: bad HTML entity
     * Get the current date & time.

The generation fails as Javadoc tries to get the character entity although an ampersand character (&) is no character entity.

I think of 3 different solutions for it.

Use the character entity

One solution for it can be to just use the character entity:

Daily Bash Scripts

Sat, 06 Jan 2024 18:26:32 +0100

During my work I encountered repetitive commands which I reused by typing the command again or by using CTRL + R in the CLI.

That approach is definitely not using the full power of a UNIX system and feels really counterintuitive.

Furthermore, there are some things which I like to do in the morning and be part of my morning routine. By that I mean doing the following:

Pull the latest changes from the remote repositories to my local repository and show me the changes. With that I see what happened the past day.
Update all local images. This keeps the environment updated and by using always the latest images it’s easier to notice side-effects of changes or if a change which came in the day before may affect todays work.

I found this two things to be really helpful for me, but I didn’t like to change to the directories and execute the commands in every directory.

Creating A Cloud Development Environment with code-server and nix shell

Thu, 04 Jan 2024 13:55:10 +0100

tl;dr: Install nix-shell in the code-server to have a nice development environment within the container. See Dockerfile below.

Sometimes when I’m traveling, I’d like to use some time and write a blog post or develop small things on my homelab.

The way I did it til now

Usually, when I don’t have my notebook with me I use my Chromebook to connect via Wireguard + SSH to my homelab and use a CLI editor to edit files etc.

Retrospective Of 2023

Sun, 31 Dec 2023 15:14:10 +0100

2023 comes to an end, and it’s time for some small retrospective.

Generally, I’d say it was a good year with a lot of challenges, new experiences, lots of traveling (counting personal and work-related travel, I visited 6 countries!) and new things I learned.

It was the year where I probably read even more books from cover to cover than during my studies.

Here are some of my thoughts on my personal development. I keep most of it job-related.

Suppressing unchecked cast warnings with Spring CastUtils

Sun, 17 Dec 2023 23:24:10 +0100

Let’s say there are classes which are types of Vehicle. For example:

public class Bike extends Vehicle {}
public class Car extends Vehicle {}

Now, when there’s a class with a method that returns a T it may look like this:

public T getVehicle(String type) {
    if (Objects.equals(type, "car")) {
        return carWorker.get();
    }

    return bikeWorker.get();
}

Note: That’s a simplified method to focus on the problem.

The IDE will show directly the error that Vehicle or Car is not of type T.

Clone before use: preventing TOCTOU attacks

Sun, 17 Dec 2023 17:24:10 +0100

Mutable variables can lead to vulnerabilities or unexpected behavior.

Consider the following piece of code as a demonstration:

public boolean checkDomain(HttpCookie httpCookie) {
    if (httpCookie == null) {
        throw new NullPointerException();
    }

    if (httpCookie.hasExpired()) {
        // throw exception
    }

    return isDomainValid(httpCookie.getDomain());
}

What could go wrong here? The problem with this code is that the method doesn’t has any control about what happens with the httpCookie.

So, the value of it could change between the check (if-clause) and the use (return statement). E.g. the cookie’s domain could be changed before it is checked.

Using VSCode as a Java IDE

Sat, 16 Dec 2023 10:30:00 +0100

Some unsorted thoughts about using VSCode as a Java development environment.

I tried more than once to use VSCode as my Java editor, but it didn’t give me the same experience as IntelliJ IDEA.

The UX was often really low and sometimes I just didn’t understand why I got error pop-ups or where I can find the settings for my use case.

There is a lot more to say like the low debugging-experience in VSCode while IntelliJ is outstanding in many matters or how tight the integration of Java into IntelliJ is.

Bring Java CRaC into your IDE (VSCode and a little bit about IntelliJ IDEA)

Fri, 15 Dec 2023 15:46:00 +0100

After looking at CRaC I thought it would be nice to create checkpoints from within an IDE. It’s more comfortable, to do it from within the IDE then using the CLI. Furthermore it may be easier to do it when you start your service every time with the -XX:CRaCCheckpointTo command.

The code is in this commit on GitHub.

Key takeaways

Before I show you how I did it for VSCode here are some takeaways:

Java CRaC

Thu, 14 Dec 2023 16:46:00 +0100

Java is not a language which is famous for its fast startup-time when using a framework like Spring. Sometimes you need this when running time-sensitive applications or for example functions as a service which build on top of fast start-up times.

Luckily there’s some work regarding this like GraalVM or CDS.

Another feature which promises to solve this problem is built on top of Linux’ CRIU and is called Coordinated Restore at Checkpoint or abbreviated CRaC.

about: HomeLab

Mon, 27 Nov 2023 19:46:00 +0100

In the end of the last year I started to build an own HomeLab. This post covers some superficial thoughts on this.

Quick facts

Here are some quick facts:

I bought an used Fujitsu Esprimo Q920. Specs:
- Costs: 148€
- Intel i5 (4.Gen) processor
- 16GB RAM
- 500GB SSD
- ⌀11W Power consumption
I use Fedora as the OS.
Everything runs inside my local network.
I use Wireguard to reach it from the outside.
I use docker compose to run services.
Whenever possible I try to centralize services (e.g. using only one Postgres database).

Tools that I use

The awesome-selfhosted repository on GitHub gives a good list to grasp when searching for things to set up. With Docker it is really easy to try out software, run it and throw it away or keep it if needed.

Takeaways from the last company event

Sun, 26 Nov 2023 20:43:00 +0100

In the last week I attended a 2-day company event which included a lot of talks about corporate identity, branding, flair and more. All talkers were from management-level positions and so were the talks more on a high-level.

However, I got some takeaways from the talks which help me to get a better feeling about corporate life and on how to work on things to align within the company. Some things are just “lessons learned” and don’t need to be necessary true, but can help to initiate further thoughts on this.

Java Generics: Upper Bounded and Lower Bounded Wildcards

Thu, 16 Nov 2023 22:09:10 +0100

I already took a look at the difference between Wildcards and Types in Java.

Now it’s time to take a closer look at Wildcards. Specifically, bounded and unbounded wildcards.

You may sometimes came across this when seeing either this signature parameter or error message:

List<? super Animal> animals

capture of ? extends Animal

Let’s see what this means.

Bounded Wildcards

Generally, bounded wildcards can be used to relax or restrict wildcard variables.

There are two of them: Lower Bounded Wildcards and Upper Bounded Wildcards.

Java Generics: When to use Wildcards and when to use Types?

Thu, 16 Nov 2023 22:09:00 +0100

When reading Effective Java by Joshua Bloch I came across the chapter about Generics and the difference between using Wildcards and Types.

I did some further research to understand it more and this is the write up of it. Let it confuse you as much as me or let it be helpful.

When to use which

I found three statements which describe when to use what:

If a type parameter appears only once in the declaration, then replace it with a wildcard. (Effective Java by Joshua Bloch)

Using LLMs for test data generation

Mon, 23 Oct 2023 20:30:00 +0200

Recently I had the idea to use generative AI for test data generation.

To be precise: To generate JSON payloads out of an OpenAPI specification.

The rough idea is:

Read the OpenAPI spec.
Pass the spec to gpt-3.5-turbo or a local running Llama 2. Give it instructions which type of request is expected (valid/non-valid request, XSS attack, …)
Execute the requests

I’ve used the spring-petclinic-rest project to test the idea and implementation.

The crucial distinction between equals and compareTo in Java

Thu, 21 Sep 2023 20:35:00 +0200

… or: Why 1 is not equals 1.0 when using BigDecimal.

Languages have sometimes their own special behavior, which you need to know when you want to use it right.

Sometimes you forget about it and then you remember some specific behavior when you try to use it.Let’s take a look at the crucial difference between equals and compareTo in Java.

`equals` of `BigDecimal`

Look at this two BigDecimals:

final BigDecimal BIG_DECIMAL_1 = BigDecimal.valueOf(1);
final BigDecimal BIG_DECIMAL_1_0 = BigDecimal.valueOf(1.0);

Normally you’d say that they have two equal values, and should be equal, because 1 = 1.0.

A simple STOMP server & producer application

Sun, 10 Sep 2023 15:04:00 +0200

When developing a STOMP client I think it’s nice to have a simple, local running STOMP server to subscribe to. That’s what I recently did while updating my STOMP in Spring Boot article.

Well, here’s what worked for me:

Server

I used RabbitMQ as the server. For this I created this Dockerfile which activated STOMP within the RabbitMQ server.

FROM rabbitmq:latest
RUN rabbitmq-plugins enable --offline rabbitmq_web_stomp

Build and run it:

docker build -t rabbitmq-custom .
docker run -i -p 61613:15674

Client (producer)

To produce messages which can be then consumed I’ve used node and implemented the @stomp/stompjs library.

How to get Spring STOMP to parse messages successfully

Sun, 10 Sep 2023 15:04:00 +0200

Recently I updated my article about STOMP in Spring Boot and faced some issues to get a running example with the latest Spring Boot and websocket version.

I tested the code with Spring Boot 3 and the version 3.2.0-SNAPSHOT of the websocket library. My problem was that the message which I received wasn’t parsed correct.

Here are some notes to attack and prevent some of the appeared problems. Maybe they’re helpful for someone (or me in the future).

The Dual Clocks of Computing: Time-of-Day and Monotonic

Tue, 29 Aug 2023 02:00:00 -0100

Our computers have two clocks:

The time of day clock (also: wall-clock time).
The monotonic clock.

The following lines are dedicated to them.

*Imagine The Persistence of Memory by Salvador Dali inserted here.*

Time-of-day clocks

The time-of-day clock returns the current time in accordance to a calendar.

This is what you get when calling System.currentTimeMillis() in Java. It returns the passed time since January 1, 1970, midnight (UTC) using the Gregorian calendar and doesn’t count leap seconds.

All Java 21

Mon, 21 Aug 2023 02:00:00 -0100

Just few days left until Java 21 is generally available (September 19, 2023).

I’ve read and collected resources which discuss all the features which 21 will bring.

You can follow the schedule one the page of the OpenJDK project.

The four available JEPs

Namely, there are 4 JEPs which are final and can be used in production:

JEP 431: Sequenced collections

Enhances the Java collection framework with a Collection that contains elements in a particular order. The SequencedCollection interface has been introduced for this.

Testcontainers in Spring Boot 3.1

Fri, 18 Aug 2023 09:00:00 -0100

I already wrote two times about Testcontainers. Once I showed an example for the usage in Spring Boot. And the other time how to manage the lifecycle state and tear the connection down.

Spring Boot 3.1 changed the way how you can use Testcontainers. There are a lot ways to use Testcontainers and now there’s another, far easier way to do it.

Before Spring Boot 3.1

Before Spring Boot 3.1 you had two ways to connect to a Testcontainer.

JUnit 5: Annotations for @ParametrizedTest

Wed, 16 Aug 2023 02:00:00 -0100

I like the idea of parametrized tests in JUnit 5. Instead of writing 5 methods for one method and just changing the arguments, write the test case once and serve the arguments as a stream.

This makes refactoring and maintenance of test code far easier.

But, when you want to implement a ParametrizedTest you need to use the correct annotations and sources for the arguments.

Check the following example:

@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = {DeviceService.class})
public class DeviceServiceTest
{
   @Autowired
   private DeviceService deviceService;

   private static Stream<Arguments> deviceArgs() {
      return Stream.of(
            Arguments.of(Device.builder().deviceId(1).name("Raspberry Pi").build()),
            Arguments.of(Device.builder().deviceId(2).name("Banana Pi").build())
      );
   }

   @ParameterizedTest
   @MethodSource("deviceArgs")
   public void storeDeviceTest(Device device) {
      deviceService.storeDevice(device);
   }
}

streamDevices serves the Arguments. This method must be static.

Catching the best prompt

Sat, 12 Aug 2023 02:00:00 -0100

Recently I had the idea to leverage generative AI and use it to generate random data for me. For that, I played around with the OpenAI API. Even when their pricing seems fair for me, I tried to find the best prompt to fit my needs without eating up my money as I’d like to use the prompt very often.

Finding a good prompt for a recurring task is a thing with a higher complexity than expected. A good prompt decides how good the results you get are. The challenge is to find concise and precise words. The german language sometimes tends to nested sentences. This pattern should be avoided when crafting prompts.

The five most useful commands for the docker cli

Wed, 09 Aug 2023 02:00:00 -0100

IMHO there are five docker commands which you need to have a successful start in containerized application development:

Build an image of a Dockerfile:

docker build -t IMAGE_NAME .

Start a container for an image:

docker run --name CONTAINER_NAME IMAGE_NAME

Get and follow logs of the container.

docker logs -f CONTAINER_NAME

Execute a bash inside the container. Can be helpful for further introspection:

docker exec -it CONTAINER_NAME bash

Show all running containers.

Exploration of Wasm Workers Server

Wed, 02 Aug 2023 02:00:00 -0100

One direction towards which Webassembly (Wasm) is heading is the usage as serverless applications in the cloud or on the edge.

The idea to do this is in my opinion great, because of few reasons. Naming some of them:

Wasm modules have a minimal footprint.
Wasm modules run in a sandbox and provide that way a security benefit out of the box.
With one runtime you can run easily many code bases.

Wasm Workers Server

VMware Wasm Labs spublished Wasm Workers Server (WWS) which provides such an environment to run different code bases beside each other.

Wasm: SIMD operations

Fri, 07 Jul 2023 02:00:00 -0100

WebAssembly (Wasm) has support for SIMD.

There is a big instruction set related to SIMD. This post covers some of them.

`v128`

v128 is the SIMD type for vectors. It is also the only one which is currently served by Wasm! So, when working with SIMD in Wasm this is the type used.

That means that you can use 4 32-bit int values (or any other value that fills in). This is also called the lane.

Step by step towards wasm tables

Thu, 29 Jun 2023 02:00:00 -0100

Tables in Wasm can be used to store references to functions (= function pointers).

In its core tables are arrays of references. These references can be accessed by index from Wasm code.

Why Wasm needs tables

Normally you can also call Wasm functions by the call instruction. But, this only works when the function is known at compile time.

Tables can store function references at runtime. With that the function to be called can be determined at runtime.

Getting a higher confidence in spaCy similarity

Sat, 24 Jun 2023 02:00:00 -0100

That’s a fast and small addendum to my recent post about similarity calculation of my blog posts. You can find part 1 here.

I used spaCy to get the similarities between my posts, was unhappy with that.

Well, the solution is far easier than I thought.

After some research I found out that using another model leads to far better results!

I used en_core_web_lg in conjunction with universal-sentence-encoder:

nlp = spacy.load("en_core_web_lg")
nlp.add_pipe('universal_sentence_encoder')

And this leads to really good results.

Calculate automatically the similarity between my posts

Wed, 21 Jun 2023 02:00:00 -0100

Keen readers may have recognized the box below every post. This shows you similar posts to the one you’ve read and give you even more things to read.

The box currently works as follow:

Get the last 5 posts with the same tags, ordered by latest date.
If no earlier posts with the same tags are available, show nothing.

I don’t really like the second case, because then it just shows you nothing. So why not use machine learning to calculate similar posts?

Wasm variable instructions

Sat, 17 Jun 2023 02:00:00 -0100

The everyday business in each programming language is the usage of variables. Wasm also has them. Here’s how to use them.

The scope of variables

The scope of variables can be either local or global.

If you are experienced in any higher language like JavaScript or Java, you may probably know what it means.

Local variables

Local variables have their scope in the functions body. They are referenced through the local indices in the function’s body or their names.

One year of knowledge management: My switch to Trilium

Sat, 10 Jun 2023 10:00:00 -0100

It’s been over a year since I last wrote about my knowledge management system. Since then, I’ve made a significant change in the tool I use – I switched to Trilium. This self-hosted desktop application has been a game changer for me in terms of usability and linking interrelated topics.

What I have been using before

Short recap: Before I switched to Trilium, I have been using FoamBubbles which acts as a VSCode Plugin (see my post).

Thoughts on event sourcing

Thu, 08 Jun 2023 10:00:00 -0100

In my recent posts I showed an approach on how to implement event sourcing in Java. During the implementation everything went as usual: I had the knowledge to start and build a mental model. And I had some resources to solve the first hurdles. The implementation went pretty good so far.

But then.. things changed during writing the post. I realized that my application is a good foundation and shows the basics of event sourcing. But, beside of this a lot of questions appeared which weren’t answered in the post.

Event sourcing in Java: First steps

Wed, 31 May 2023 10:00:00 -0100

This post belongs to a series about my DDD journey.

Check also: Concepts of Event Sourcing.

In this post I will write up my approach to implement event sourcing in a Java application. This sample application aims to give a feeling about the DDD building blocks and which challenges in event sourcing are coming up.

The service

Let’s assume that we shall build a service for a shop which contains clients and orders. As a first step we will build the service with the client model which applies event sourcing.

Calculate multiple data points in one instruction: SIMD

Mon, 22 May 2023 02:00:00 -0100

SIMD is short for Single Instruction, Multiple Data.

In parallel computing you split your data and operate on every dataset at once.

SIMD works different, as it is not using threads.

SIMD uses many operating units and all of them execute the same operation at the same CPU cycle (= at the same time). That’s where the name comes from: With a single instruction you operate on multiple data. And this is the reason, why it is so fast.

Comand-Query Responsibility Segregation (CQRS)

Wed, 17 May 2023 02:00:00 -0100

In DDD you will clearly come over the term “Command and Query Responsibility Segregation” or also: CQRS.

This article describes this pattern and shows how it works together with Event Sourcing.

The problem

In an usual application you use the same data model for read and write operations in/from the database.

This works good in simple applications, but can be messy in more complex applications. So data transfer objects (DTO) may be introduced to return a model that fits into the query.

Accessing and storing to memory in Wasm

Thu, 11 May 2023 02:00:00 -0100

Wasm has also a memory which helps you to store and access data at any point in your module.

Memory can be created in the module itself or imported into the module. This post has a main focus on the first case, but will also introduce the latter case in the following section.

The concept of memory

In Wasm, the memory is linear. So from JavaScript perspective it is just a buffer of unsigned bytes from which you can read from and store into.

Released: Wasm-powered static search

Fri, 05 May 2023 03:00:00 -0100

I’m thrilled to announce that I released the Wasm-powered static search, now.

After integrating my index-generation service into Jenkins, I am now able to release new posts and automatically generate a new index on the fly!

Every search is executed & computed locally on client-side machines by using Webassembly.

You can follow some of my thoughts and technical challenges during the implementation here:

Dive into Wasm: Control flow instructions

Thu, 04 May 2023 03:00:00 -0100

Wasm provides ways to control the flow of the code. This influences the way which results and which behavior a Wasm module shows.

This post gives a quick glance at the instructions to control the flow and shows their usage with WAT examples.

The `unreachable`

The unreachable instruction marks a code part which should be unreachable. This leads to a trap and stops the execution of the module.

The following code leads to a trap.

A static search for my blog

Sun, 30 Apr 2023 10:00:00 -0100

More than once I’ve been thinking about a static search for this blog.

This site is using Hugo as a site generator. There are some search solutions for Hugo sites, but I thought it would be a fun project to work on and create a solution for my own.

So I split the problem up in three parts:

Create a JSON-representation of my blog.
Create an index out of this json representation.
Search the index on the client-side.

flowchart LR subgraph js['Site generator'] direction TB Blog(Page content) Blog --> Hugo Hugo -->|generate| JSON1(page.json) end subgraph ig ['Index generator'] IG[Index Generator] JSON1 --> IG IG -->|generate| IDX(index.json) end subgraph se['Search engine'] IDX --> SE[Search Engine] Terms(Search terms) --> SE SE --> |output| Res(Results) end UI --> Terms

The following sections are about the implementation and give insight to my thoughts.

Dive into Wasm: Functions

Thu, 20 Apr 2023 03:00:00 -0100

Functions are one of the main building blocks of Wasm. In the following sections I discover how to use them and how they are built.

The first function

WAT code is represented as functions in this syntax:

( func <signature> <locals> <body> )

The signature declares the input parameters and the return values.
The locals are variables.
The body is a list of low-level instructions.

Here is the syntax definition.

This function takes two 32-bit params and results one 64-bit float:

Writing Wasm: modules

Sun, 16 Apr 2023 02:00:00 -0100

The most simple Wasm module doesn’t need much code. This post describes the definition of it, and how the resulting binary code looks like. It shall give the basis for further WAT-styled code.

Pre-requisites

Before you start to write Wasm modules, you need some tooling.

So, install wabt first. This includes wat2wasm and allows you to compile .wat files to .wasm with the following command:

wat2wasm sample.wat

With that you’ll get the Wasm binary with the .wasm ending.

Experiencing functional programming in Java

Sun, 02 Apr 2023 01:00:00 -0100

In the recent days I’ve been working on my Functional Programming skills in Java.

Reading about it and implementing small functions makes it easy to understand the basics. But it’s always better to have hands-on experience.

So I gave myself the task to implement a service which creates a simple search index for this blog.

The idea

The core idea is to realize the following flow:

As you can see, this is already a pipe which can be realized through the chaining of functions:

What is eBPF?

Thu, 23 Mar 2023 02:00:00 -0100

In the cloud landscape there is currently one technology, that was raising questions to me: eBPF.

I want to give a short answer what eBPF is and how it is used for Cloud Native development.

eBPF is not a ‘fresh and new’ idea from yesterday. In fact, it exists since 2014, but has risen more and more attention in the past years. It is often referred to as ‘JS, but for Kernel programmers’.

Functional Programming in Java

Sun, 12 Mar 2023 02:00:00 -0100

Functional programming can be achieved in Java, though it needs a lot of discipline to not mix things up. This post discusses the different ways of doing things in a functional way in Java.

When you know the basics of functional programming and want to start with that style in Java, you should keep the following interfaces in your mind:

Supplier       ()    -> x
Consumer       x     -> ()
BiConsumer     x, y  -> ()
Callable       ()    -> x throws ex
Runnable       ()    -> ()
Function       x     -> y
BiFunction     x,y   -> z
Predicate      x     -> boolean
UnaryOperator  x1    -> x2
BinaryOperator x1,x2 -> x3

(List from stackoverflow.com)

The shift of thinking: Imperative vs. declarative programming

Sat, 04 Mar 2023 02:00:00 -0100

A key characteristic of functional programming is the declarative way of describing how software shall behave.

In contrast to that stands the imperative style, where you give step-by-step instructions what the program shall do.

Von Neumann Architecture

The reason why the imperative style lasts so long and is so old, lays in the way how computers work.

The basis of our computers til today is the von Neumann architecture.

In the von Neumann architecture the computer gets instructions which tell it how it should work. So the algorithm is imperative and tells which data should be loaded and which instruction shall be executed.

Optimizing Wasm and JS module size and load time.

Thu, 23 Feb 2023 02:00:00 -0100

Recently I’ve thought of a static search for this blog without the need to run a backend.

So I started to build the following ‘search engine’:

I don’t know until now if I will deploy this anytime, but it’s a good project to make use of a little bit functional programming, Rust and Wasm.

However, one problem I faced was the size of the Wasm module and JS overhead for the search.

Wasm: A technical view

Tue, 14 Feb 2023 02:00:00 -0100

WebAssembly is one of the most recent technologies of the web and stands for itself in the browser. Historically it is an successor of asm.js.

When supported, code which is written in C, C++, Rust or any other language can be compiled into Wasm bytecode (= .wasm file) and loaded into the JS page and executed in there (source):

const importObject = { imports: { imported_func: (arg) => console.log(arg) } };

WebAssembly.instantiateStreaming(fetch("simple.wasm"), importObject).then(
  (obj) => obj.instance.exports.exported_func()
);

The execution happens inside an own runtime. Currently every major browser supports Wasm.

Ways to compile from Rust to Wasm/WASI

Wed, 08 Feb 2023 12:00:00 -0100

When you follow tutorials for Rust and Wasm, you’ll find different ways of how to compile your code to a .wasm file.

To untangle the confusion this post shows the ways and what the differences are.

This tutorial follows especially the wasm32-wasi target, but gives also insights to the wasm section.

1. Using the rustc compiler

If you want to compile one file (e.g. projects that are not libs), you can use the compiler directly:

Hexagonal architecture: Delaying decisions

Thu, 02 Feb 2023 08:00:00 -0100

One fundamental concept of the hexagonal architecture is the isolation of different layers from each other. This is realized by the communication via interfaces and appliance of dependency inversion.

Exactly this characteristic makes it possible to delay decisions in regards of technical dependencies. Lets see how.

Making use of abstractions

In the hexagonal architecture, the application core defines the ports for the infrastructure and UI layers via the concept of interfaces. The core itself contains the business and domain logic.

The hexagonal architecture

Fri, 27 Jan 2023 10:00:00 -0100

Using the hexagonal architecture for more complex projects gives more and better abstraction layers. This is an introduction into the ports and adapters (or: hexagonal architecture) and how it interplays with Domain Driven Design.

Many very good things are written in the web about the hexagonal architecture, so I’ll only cover things which are important in the context of Domain Driven Design.

Why hexagonal architecture?

There are different architecture styles for services like the layered architecture as an example for the simplest one.

Creating an own WASI function

Thu, 19 Jan 2023 02:00:00 -0100

One of the core concepts of WASI is to make the execution of Wasm code portable. This means: Every WASI runtime needs to implement the WASI specification and serve the needed methods for the Wasm module.

When you followed along my post about the implementation of WASI in Rust you might have seen the following import of the fd_write function in the compiled Wasm module:

(import "wasi_snapshot_preview1" "fd_write" (func (;0;) (type 10)))

The function fd_write will be imported from the wasi_snapshot_preview1 module and needs implement the interface which is defined as type 10.

Under the surface of WASI in Rust

Wed, 11 Jan 2023 02:00:00 -0100

In the recent years WebAssembly (Wasm) got more and more popular: For different codebases you have one runtime in the web. So you can bring your C or Rust code into the web browser!

Few years ago WebAssembly broke out of the web and started to aim the system as a runtime environment. With the WebAssembly System Interface you can run WebAssembly directly on the machine - no browser needed. This enables a wider range of possibilities.

Java, Cloud, IoT Trends in 2023

Tue, 03 Jan 2023 02:00:00 -0100

I hope you all had a good start into the new year! 2023 is just a few days old and it is not only time to look at the things that happened in the past year. Here I want to give insights on to the trends which I think Cloud developers should keep an eye on. As my experience mainly lays in the cloud, java and IoT area, this is the part at which I’ll focus on here.

Behind containerized applications

Tue, 27 Dec 2022 02:00:00 -0100

When you work with containerized applications you have probably written a Dockerfile, built and run it.

Maybe you’ve started with a base image like Alpine Linux to have a small basis to run your application. When you check the Dockerfile of the alpine image you’ll see that the alpine image bases on another image called scratch:

FROM scratch
ADD alpine-minirootfs-3.17.0-x86_64.tar.gz /
CMD ["/bin/sh"]

scratch is the most minimal image in the docker world and serves a starting point for base images. You are not able to pull, run or tag an image with scratch, but you can use it in a Dockerfile.

Concepts of event sourcing

Sun, 18 Dec 2022 10:00:00 -0100

This post belongs to a series about my DDD journey.

Event sourcing is a pattern which interacts very well with DDD and creates something like a log book of your application state. This helps you to recreate your app state every time when needed. This post will introduce you to this topic and show the challenges in this pattern.

The idea behind event sourcing is, that every change of the state in an application is captured in an event object. These events are stored in an append-only database and read by the application when a recreation is needed.

The key points of Domain Driven Design

Fri, 16 Dec 2022 12:00:00 -0100

This is the first post in the DDD journey.

In this post I’ll show the definitions and concepts of Domain Driven Design.

As the name Domain Driven Design states, the design of the application is all about the Domain. Maybe you have read the book ‘Problem Frames’ by Michael Jackson (no, not this Michael). He states:

It is more helpful … to recognize that the solution is located in the computer and its software, and the problem is in the world outside. …

The Domain Driven Design Journey

Thu, 15 Dec 2022 10:00:00 -0100

Domain Driven Design (DDD) is an software engineering approach, which interplays well with microservices. It helps a lot to build and design application in accordance to the domain where it shall solve problems.

The concepts of DDD are at first theoretical, but can be easily and fast introduced in practice. But where to start?

This post series will explain the concepts of DDD and show a sample implementation. The series will cover the following topics and links will be added as soon as a new post appears.

Bash script for automatic Hugo site updates

Tue, 29 Nov 2022 10:00:00 -0100

On the bottom of this page you can see that this page is generated by hugo.

After nearly one year of blogging I finally invested some time to write a bash script which updates this blog automatically.

Although I think that scripts can be a little bit useless, when you don’t have exactly the same repository setup, you may want to adapt it. You can use it in a pipeline, after a commit hook or even manually!

Testcontainers revisited: Managing the lifecycle of the database

Mon, 28 Nov 2022 02:00:00 -0100

I created a follow-up for Spring Boot 3.1. Check it here

Even when things changed, the concept of Testcontainers is the same and you can use it also in the way it is described here.

Few weeks ago I was taking a look at Testcontainers.

Two questions arrived:

How to keep the database connection open and reuse it.
Clean up the database between tests.

The post was Spring Boot specific, but here I’ll also have a look at plain Java projects.

The skill radar: A better way to visualize and classify your knowledge

Tue, 22 Nov 2022 02:00:00 -0100

tl;dr: Build your own skill radar with this code from Github.

When you’re building a portfolio you may want to show which skills you have.

My site exists since ~2016 and I never found a way which makes me happy enough to show what I can. A list of skills just never made me happy, though I’m using it til now. But: This makes it look like a lot of buzz words which don’t show how much experience I have and how confident I feel in the technologies.

Timescaledb: Insert data into a compressed chunk

Fri, 18 Nov 2022 02:00:00 -0100

When you want to add an entry into your timescale database, you may get the following error messages:

ERROR: insert into a compressed chunk that has primary or unique constraint is not supported

or:

ERROR: insert with ON CONFLICT or RETURNING clause is not supported on compressed chunks

If you check the documentation you see that ON CONFLICT and RETURNING statements and PRIMARY KEYs are not supported on compressed chunks.

There are also two issues on GitHub for this (#3323, #4113) which discuss this topic.

Notes I made during reading Clean Code by Robert C. Martin

Wed, 16 Nov 2022 02:00:00 -0100

Not so many books are recommended by so many generations of software developers as Clean Code by Robert C. Martin. And after reading it I can just agree on this.

This book can make you a better developer or if you already have professional experience give you advices to strengthen and encourage your existing techniques.

Some of the things written down may seem outdated or you may not agree on them (which is also the intention of the author), but it will give you a guide and frame for coding on which I think every developer will agree.

Using Testcontainers in a Spring Boot application with MariaDB

Sun, 13 Nov 2022 09:00:00 -0100

I created a follow-up for Spring Boot 3.1. Check it here

Even when things changed, the concept of Testcontainers is the same and you can use it also in the way it is described here.

When writing integration tests for a service one of the problems which need to be attacked is the database: You want to assure that an entry is really stored in the database.

For that there are multiple ways, like using a test instance of a database, using a deployed database and use a prefix for all data for later deletion, a local database or an in-memory database like H2.

Review: Code by Charles Petzold

Mon, 07 Nov 2022 09:00:00 -0100

Code by Charles Petzold provides a compact bottom to top overview of how computers really work. And what technically the difference between hardware and software is.

Petzold starts with some real life examples and adapts them to our computers. After this introduction electrical circuits are build to a working CPU with an ALU and memory. And within this you’ll see how they are really working and bound together!

Furthermore there is also a chapter to my beloved topic of clocks!

How to use Mockito to test the behavior of a Java application - in a nutshell

Mon, 24 Oct 2022 02:00:00 -0100

Mockito is a really powerful tool. And even more: It’s documentation and logs are so good, that you don’t need to look at the documentation if you’re misusing it! Here I’ll show some of the common functions I’m using with a small example.

Example application

I’ll show you an example application, which I’ll use within the next sections. The example may not to seem so logical, but it will show you the most important things.

Implementation of an external authorizer for Istio in Java

Tue, 18 Oct 2022 09:00:00 -0100

In my last posts I was writing about using an external authorizer for Envoy to use Istio to authorize requests (check part 1 and part 2).

In part 2 I wrote that I will also show an example of the authorization service in Java. Here is it.

Code example

Full code example available at GitHub.

You can see the full code example with a Dockerfile in my repository. The following subsections explain you to it step-by-step. This project uses grpc-java for the server.

Using Istio as an external authorizer. Part 2: The implementation

Sun, 16 Oct 2022 09:00:00 -0100

This is the second part of a series about using Istio as an external authorizer. Here’s part 1.

Prerequisite

To follow and understand this guide you need the following prerequisites:

Read and understand the authorization concepts of Istio.
Important: Setup your local cluster accordingly to this guide, as I’ll use the application as an example.

The external authorizer

The external authorizer needs to implement the Protobuf interface defined by Envoy.

I’ll write more of the implementation of it as a Java service in another post, but let’s use the sample application by Istio.

Using Istio as an external authorizer. Part 1: The theory

Sun, 16 Oct 2022 08:00:00 -0100

This is the second part of a series about using Istio as an external authorizer. Here’s part 2.

Authorization to applications is one of the most security critical parts of a development process. Every public available service needs it.

But, in a microservice architecture most of the time the authorization doesn’t belong to the business logic of a service. For sure there are many ways to implement it, but the best thing is to implement it once for all. This can be done via a library or middleware.

Using an Istio gateway to access a Spring Boot application in minikube

Tue, 11 Oct 2022 09:00:00 -0100

In the last days I was trying to run and experiment with Istio. I followed the getting started guide by Istio itself, but I couldn’t make it run with kind. I followed some guides, but I didn’t want to install explicitly an nginx ingress, because I like it when things are as lightweight as possible when I’m learning new stuff.

So here’s a guide how to run a Spring Boot application and access it through an Istio Gateway.

Building and running a Docker container for a Java application

Sat, 24 Sep 2022 09:00:00 -0100

There are different ways to build a Docker image locally of your Java application and start a container.

This one is more of a step-by-step guide, which can also be automated by a local script. If you want you can also move the build steps into the Dockerfile, if it doesn’t give you any conflicts in a pipeline.

The Dockerfile

First, create a Dockerfile in the root of your project. Consider to choose the right JDK version for your project.

Use a locally built Docker image in kind

Sat, 24 Sep 2022 09:00:00 -0100

If you create a local cluster with kind and try to use a locally built Docker image in one of your Pods, you’ll probably face the issue that this image cannot be found!

Well, the problem is that kind on one side looks after the image at the official Docker repositories and on the other side doesn’t serve a local registry out of the box, like minikube for example does.

You can create a local registry when you create your cluster, but this may not work on Windows or without any problems.

A story about Docker, failed builds and package locks

Wed, 14 Sep 2022 10:00:00 +0000

Recently I faced an issue where a docker build failed. The content of the Dockerfile was something like this:

FROM node:16-alpine as BUILDER
WORKDIR /usr/app

# COPY statements of the /src directory to /usr/app

RUN npm ci --only=prod
RUN npm run build

Running the npm i and npm run build commands were working perfect when executed in my local CLI. In the Dockerfile the problem threw some tsc errors saying that there are incompatible types.

The day I called Microsoft Support

Fri, 02 Sep 2022 02:00:00 -0100

The first computer I got was a desktop PC by HP in the year 2003. It was running Windows XP and introduced me into the world of computers.

I was just 10 years old, and I had a fantastic time diving into various games and tinkering with computer-specific settings. Many people liked Win XP. I even know people who work with clients that continue to run their businesses on machines equipped with this age-old software. Luckily not connected to the internet!

Review: Designing Data-Intensive Applications by Martin Kleppmann

Fri, 26 Aug 2022 09:00:00 -0100

Short version: If you are maintaining, touching, planning, developing or interested in systems which are working with a lot of data, then read this book.

It gives on one side a good overview of the best practices, tools, concepts and scientific work in this field and goes in-depth to the most-important topics, so that you can understand them good enough for decision finding.

I think everyone from the group of people I mentioned in the first paragraph should have a copy of it and keep it as a reference book. Even if it doesn’t go deep enough for you, you can take a look at the bunch of references at the end of every chapter.

The biggest change ever made

Thu, 25 Aug 2022 09:00:00 -0100

Let me tell you the story of the biggest change I’ve ever made in my current career and how I would do it better today.

In a project I worked we had three classes like the following one:

public class Book {
    private bookId;
    private bookshelfId;
    private title;

    public Book(int bookId, int bookshelfId, String title) {
        // more code here ...
    }
    // Getter and setter
}

However one day, we needed to change the bookshelfId parameter to a reference of a new introduced class named Bookshelf.

CI/CD pipelines as a documentation of the build process

Wed, 24 Aug 2022 09:00:00 -0100

CI/CD Pipelines don’t only exist to build and deploy projects automatically without any obstacles and loss of time, they also assure the quality of a project.

So beside a build process pipelines can execute tests, linters or fitness functions to assure architectural quality. And even more!

Recently I was working on a project and thought about how great it is to have the build process documented in the pipeline side-by-side in the code.

Using go-templates to get insights into a Kubernetes cluster

Fri, 12 Aug 2022 09:00:00 -0100

Sometimes you need information of your cluster state or properties and need to iterate through many resources like all deployments or so.

You can use different tools to get an insight.

But beside of hoping that the tool has the correct plugin or feature, there is also a more ’elegant’ way for this. Elegant means in this context: Customized to your needs.

Using go-templates to retrieve information

With go-templates you can use your kubectl output to show it in a way you like. You can think of a filtering out properties on conditions or show them in a formatted way. Let’s check an example.

azsecd: High memory consumption on Azure AKS cluster node

Wed, 10 Aug 2022 09:00:00 -0100

Recently the monitoring fired some alarms due to a high memory consumption in the production cluster.

A look into the monitoring, revealed that at least all Pods behaved normally and without any unexpected loads. So why the alarm?

Well, investigating further with the kubectl node-shell command I saw that a process called azsecd was using nearly 60% (!) of the node memory.

A look into the syslogs with the following command gave more information:

Using DBRider for a clean state between JUnit tests

Fri, 05 Aug 2022 09:00:00 -0100

Whenever you write Java/Spring Boot tests which are using database access (e.g. when running a @SpringBootTest), you should clean up the database to have a clean state between your tests.

In fact, this is not a trivial task as some of these problems can appear:

You may need to check that you don’t insert or delete data between tests and provoke Unique Key or Foreign Key exceptions.
You may tear down and set up the database between test runs.
You could tend to define an order of test runs which works. But this is not good as this creates a ‘happy path’ for your tests.
You may tend to insert data always with already set primary keys. These primary keys are not allowed to be used by other tests. That’s not good as you need the knowledge of all these primary keys.

But that’s not good! When you test the behavior of your application you should not implement extra database checks to make sure that before and after your test you have a good state of the database.

Tools to manage Kubernetes resources

Fri, 29 Jul 2022 02:00:00 -0100

There are quite a lot of tools to view and manage your Kubernetes resources. I tried some of them and want to give you a small insight into what I think is the best way to view, update, delete and check resources of your Kubernetes cluster.

kubectl

With kubectl you’ll get a tool directly by the makers of Kubernetes.

I think that you don’t need to use it mandatory all the time, as the other tools I’ll present you here will make your workflows faster. But I think that knowing how to use kubectl will give you more flexibility: You’ll always know which commands you’re firing and what they do. Your knowledge in regards of a Kubernetes cluster will be enhanced and last but not least: When you update your Kubernetes cluster and kubectl, you can be sure, that you’ll be always up-to-date and can use the latest features.

Docker images as compilers

Mon, 25 Jul 2022 02:00:00 -0100

Today I saw a blog post about non-obvious Docker uses. And one of them states to use Docker as a compiler.

Here’s a story for this.

Once I was using Docker to compile C++ modules to WebAssembly.

This was an idea which came in my mind, when I wanted to do a PoC of a Wasm-based library for an existing implementation.

The reasons why I choose this have been:

The setup of the C++ -> Wasm Toolchain wasn’t really obvious. The way was too hard and too long for a PoC which should be done within few hours. So I checked the Docker images and luckily found one, which fitted in my case! (Side note: I don’t know anymore which image this was.)

48 hours of Rust

Sun, 17 Jul 2022 03:00:00 -0100

I wanted to have a look at the Rust programming language and gave me a small coding challenge.

For sure, I could check the Rust documentation, read it from cover to cover, but this would not help me to think like a Rust developer. I think after the 48 hours coding challenge, I still don’t think like a Rust developer and I need a lot more hours to be confident with the language. But I know a lot more about the way of problem solving, compile errors, types and language quirks than before and than I would when reading just the documentation.

Quick overview of how to setup Azure AD B2C (AADB2C)

Mon, 11 Jul 2022 02:00:00 -0100

Azure ADB2C (or: AADB2C) is a whitelabel authentication solution by Microsoft Azure.

You can use AADB2C to implement a whole authentication flow within your Azure Cloud subscription with your own branding.

This series describes the components of Azure ADB2C, which resources you need and how they do work together.

How Azure ADB2C works

AADB2C acts a central authority for your web/mobile applications or API.

You can bind many identity providers like Facebook, Google, LinkedIN or E-Mail, Phone Call, SMS, … with ADB2C. All that without any implementation of an API!

On testing realtime services for the cloud

Fri, 08 Jul 2022 08:00:00 -0100

Testing realtime services for the cloud can increase the confidence for your service working correct.

First, let us define what a realtime system is. Here’s a good definition by K. Erciyes from Distributed Real-Time Systems Theory and Practice (ISBN: 978-3-030-22569-8)

A real-time system operates with a time constraint, where the time that the output produced is significant […] producing the output at some other time than the required time may be meaningless. Alternatively, a real-time system is a data processing system which responds to external inputs within a finite specified time called deadline.

Adding a NodeJS backend to Uberspace

Tue, 28 Jun 2022 04:10:00 -0100

Recently I added a NodeJS backend to my Uberspace webspace, which can be controlled by start/stop/logs scripts.

This can be useful if you want to serve an API via your Uberspace account.

Here is how I did it.

Note: For these examples dennis is the username of the uberspace. Just change it.

Install dependencies

If you need to run for example a NestJS application instead of a pure node application, then install it globally. For NestJS it would be:

Kubernetes basics: DaemonSet

Wed, 22 Jun 2022 09:00:00 -0100

DaemonSet

A DaemonSet ensures that all (or a specific part of) Nodes run a copy of a Pod.

When a new Node is added, then a new Pod is added.

DaemonSets are typically used to run a cluster storage, log collector or node monitor on every node.

Specifying a DaemonSet

A DaemonSet specification consists of the apiVersion, kind, metadata and spec sections.

The spec section is the indivudual one of the DaemonSet and consists the DaemonSetSpec object. The spec.template contains the pod information of the DaemonSet.

Kubernetes basics: ReplicaSet

Tue, 21 Jun 2022 09:00:00 -0100

ReplicaSet

A ReplicaSet maintains a stable set of replica Pods and is used to ensure the availability of a specified number of Pods.

A ReplicaSet contains a PodTemplate and creates/deletes Pods until the desired state is reached.

But mostly the direct usage of a ReplicaSet doesn’t make sense. Deployment is also using a ReplicaSet to manage the availability of Pods and adds other useful features.

So most of the time when a ReplicaSet is needed, a Deployment can be the better choice.

Kubernetes basics: Objects

Mon, 20 Jun 2022 09:00:00 -0100

Ingress

When you want to expose HTTP(S) routes from outside the cluster right to the services running within a cluster, then you need Ingress.

If you configure an Ingress it can serve the following functionalities:

externally-reachable URLs,
loadbalancing traffic
SSL / TLS
name-based virtual hosting

To fulfill the Ingress an Ingress controller is needed.

The Ingress controller

… is needed to make the Ingress work! Just specifying it won’t work.

Kubernetes basics: StatefulSet

Sun, 19 Jun 2022 09:00:00 -0100

StatefulSets

StatefulSets are managing the deployment and scaling of a set of Pods and add a sticky identity to each Pod. The Pods are not interchangeable - which are in Deployments.

StatefulSets are useful for persistent storage, unique network identifiers and for applications which require ordered updates, deployment and scaling.

A StatefulSet can add set a PersistenVolumeClaim which returns to the provisioning of a storage which is available for the Pod.

Building a knowledge base as a software developer

Sat, 18 Jun 2022 10:00:00 -0100

When I started to work at my new job this year I also started to reflect the way I am taking notes and writing down things.

In the companies I worked nearly every developer had Notepad++ installed and a lot of tabs where they wrote down cheatsheets, things they learned, log messages they try want to investigate and a lot more.

But is this the correct way? Trying to find something which happened months earlier is not so good with unsaved Notepad++ tabs. I’m more of an analog guy when it comes to notes: In nearly every meeting I am taking a lot of notes, scribbling and drawing diagrams of application architecture and designs in a sketchpad.

Kubernetes basics: Services

Sat, 18 Jun 2022 09:00:00 -0100

If you want to expose an application (one or a set of Pods) as a network service, then the Service is the right choice.

Why we need services

Everytime a Pod is started - via a Deployment for example - it gets its own IP address. But when you do an update or change the specifications, this Pod gets deleted and another Pod gets started. But this one will get another IP.

Kubernetes basics: Deployments

Thu, 16 Jun 2022 00:00:00 -0100

A deployment describes the desired state and provides declarative updates for Pods and ReplicaSets.

With a deployment you can rollout a ReplicaSet, update the state of a Pod, rollback deployments and much more.

Deployment specification

A Deployment gets specified by a YAML file which is kind of Deployment.

A Deployment needs at least the apiVersion, kind and metdata fields set.

The spec field is the specification of the desired behavior of the deployment (DeploymentSpec).

Get the tree of processes under Linux including the full command

Wed, 08 Jun 2022 02:00:00 -0100

If you want to get the tree of all processes which are running on your Linux machine, including the full command with parameters, you can use the following command:

ps -aef --forest | more

The negative impact of communication between services in a distributed architecture

Fri, 03 Jun 2022 02:00:00 -0100

These days nearly every new project is set up as a microservice architecture. These small, fine-grained service can help with scalability, deployability, availability and testability, as they are focused on one small task. This modularity speeds up the time-to-market.

But as in every architecture, you also need to keep some things in mind, to take the advantages of these architecture style. One is the communication between services. These can have a negative impact on the architecture characteristics.

How to fix H2 error: 'Syntax error in SQL statement ... expected identifier'

Sun, 29 May 2022 02:00:00 -0100

I had an Entity User in my Spring Boot application and storing information with a Repository to my MariaDB database worked fine.

But when testing it with a H2 database, I got the following issue:

Syntax error in SQL statement "select user0_.user_id as col_0_0_ from [*]user user0_ where user0_.email=? limit ?"; expected "identifier"; SQL statement:
select user0_.user_id as col_0_0_ from user user0_ where user0_.email=? limit ? [42001-212]

Well I know that H2 behaves sometimes different than MySQL even if you set the mode to MySQL. So I dig deeper.

Adding custom fonts to jsPDF in an Angular application

Thu, 19 May 2022 02:00:00 -0100

Recently I was adding new fonts to an Angular application which is using the awesome jsPDF library. Here is how I did it.

TL;DR

Encode your .ttf file to bas64
Add it to your application (replace the uppercase values with string):

const doc = new jsPDF();
doc.addFileToVFS(TTF_NAME, BASE64);
doc.addFont(TTF_NAME, FONT_NAME, FONT_WEIGHT);

Do it again for all font weights. Where you set FONT_WEIGHT to one of normal, italic, bold, bolditalic.

Done!

Read on to see a more detailed description for your Angular application.

Hash tables, SSTables, BTrees: A quick glance at index types

Mon, 16 May 2022 02:00:00 -0100

If you think of a simple database, where you just append a file with new entries and query the whole file for an entry, you’ll see a basic trade-off: Writing (= appending the file) is pretty simple and fast. Reading (= reading the whole file and querying every entry) can be complex and will take more time than writing.

This is where indexes come into play. Let’s have a quick glance at the most spread indices: Hash indexes, SSTables and BTrees.

Debug and analyze NodeJS Heap

Fri, 13 May 2022 02:00:00 -0100

Sometimes you run into issues with memory leaks or JavaScript heap out of memory errors within your NodeJS application and need to analyze it.

The Chrome DevTools ship with a useful tool for this where you can debug your application and inspect the Heap.

The following steps are needed to start inspecting your application:

Start Node process in inspection mode. For this add the --inspect flag in your run command:

node --inspect index.js

For Typescript based projects you can use:

Dynamic Disk provisioning with Kubernetes

Thu, 12 May 2022 02:00:00 -0100

Kubernetes can automatically provision PersistentVolume for you and make them available for your PersistentVolumes. This can be helpful if you are for example in a cloud provider like Azure.

You need the interaction between the StorageClass, PersistentVolumeClaim and Pod resources to make it work.

The StorageClass resource

For this you need to create a StorageClass resource which describes the classes of storages you offer.

You can list your available StorageClass resources via the following command:

Kubernetes basics: Lifecycle hooks, Workloads and Resources

Mon, 02 May 2022 09:00:00 -0100

Containers do have Lifecycle Hooks:

PostStart: Is executed immediately after container is created. No guarantee is given that the hook will execute before containers ENTRYPOINT. Can be exec or http.

PreStop: hooks are not executed asynchronously from the signal to stop the Container; the hook must complete its execution before the TERM signal can be sent.

If either a PostStart or PreStop hook fails, it kills the container.

Workloads

A Workload is an application running on Kubernetes. It can be a single component or several components working together (running in a set of Pods).

How to find out how much space is left on Azure Disk resource

Fri, 29 Apr 2022 04:10:00 -0100

I was searching for a way to see the current free/available/used space of the Disk resource of Azure.

Unfortunately in the Azure Portal you cannot see anything except of some I/O metrics. If you want more, you need to do some hacks with Monitoring tools.

Too bad as I just needed the information.

But well, if you have mounted the Disk for example via Kubernetes to a Pod. And you know at which directory, then you can just use the df command to fetch the information:

Kubernetes: Use kubectl to get information about PersistentVolume of a Pod

Thu, 28 Apr 2022 04:10:00 -0100

If you want to use kubectl to get information about a PersistentVolume of a Pod, then use the following steps:

Get information about the Pod:

kubectl describe pod [POD_NAME] -n [NAMESPACE]

This will give you information about the Pod. Search for PersistentVolumeClaim. Or grep it with:

kubectl describe pod [POD_NAME] -n [NAMESPACE]e | grep 'PersistentVolumeClaim' -A 1

Use the ClaimName part to get information about the PersistentVolumeClaim:

kubectl describe pvc [CLAIM_NAME] -n [NAMESPACE]

Get the Volume out of the result of the above command and use it to describe the Volume:

Software architects as developers

Wed, 27 Apr 2022 04:10:00 -0100

In a classic way the software architect did some decisions on the architecture characteristics, the style and component structure.

This created models have been handed over to the development team and told to design the system accordingly.

But this has a pitfall: The communication is unidirectional from the architect to the dev team. This means:

The architect will never get feedback from development team in regards of how and if they realized the decisions.
The teams are split up and don’t work together. In times of agile development this is not possible as software and requirements can change in every iteration.

So a better way is to have a collaboration between the architect and software developer. Where the architect gets feedback by the dev team about the current status, pitfalls in the realization and in return the architect leads the team in a proper way to realize models and (domain) requirements.

Kubernetes basics: Pods

Sat, 23 Apr 2022 09:00:00 -0100

The smallest deployable unit in a Kubernetes cluster is the Pod. And in terms of Docker it is not just a container. It is a group of one or more containers which share storage and network resources.

A Pod is not a process. It is an environment for running container(s).

So basically, a Pod can run multiple containers within a share context.

But: Usually Pods are not created individually like with the YAML file below:

Example for Dependency Inversion

Fri, 15 Apr 2022 03:00:00 -0100

Click here to read more about the concepts of dependency inversion.

Let’s assume that we have a button which shall (de)activate a lamp after a click.

A **simple (non dependency inversion) approach could look like the following one:

public class Lamp {
   private boolean isOn;

   public void turnOn() {
      isOn = true;
   }

   public void turnOff() {
      isOn = false;
   }
}

public class Button {
   private Lamp lamp;
   private boolean isPressed;

   public Button(Lamp lamp) {
      this.lamp = lamp;
   }

   public void press() {
      isPressed = !isPressed;
      if(isPressed) {
         lamp.turnOn();
      } else {
         lamp.turnOff();
      }
   }
}

In this case the Button class has control over the Lamp class.

Concepts of Dependency Inversion

Fri, 15 Apr 2022 02:00:00 -0100

Click here for a code example.

The dependency inversion principle was introduced first by Robert C. Martin in the year of 1996.

It is a concept how to design applications to prevent rigidity, fragility and immobility.

It can be used where one class sends a message to another.

Citing M. Fowler the principle has two underlying concepts:

High level modules should not depend upon low level modules. Both should depend upon abstractions.
Abstractions should not depend upon details. Details should depend upon abstractions.

In this series I’ll show the concepts of dependency inversion and one example for it.

Debugging SIGTERM/SIGINT signals in a NodeJS application (VSCode)

Thu, 14 Apr 2022 07:00:00 -0100

tl;dr Get the PID of the running process and send the signal via CLI.

If you are working in a NodeJS environment, then you possibly do have something like the following code piece:

process.on('SIGINT', shutdownHandler)
process.on('SIGTERM', shutdownHandler)

This handles the SIGINT and SIGTERM signals received during the termination of a process.

To stop your application gracefully, you can wait til all open connections to databases are closed or until all requests are done.

How to use class-validators with ValidationPipes in NestJS

Wed, 13 Apr 2022 09:00:00 -0100

If you want to validate the values of an incoming request body (like for example whether the e-mail is valid), then you can use in NestJS ValidationPipes.

This build-in feature allows you to abstract the validation away from your business logic. This makes it a good alternative to Joi.

A package which has these built-in pipes and is a recommended way to use it in NestJS is the class-validator package.

Here’s how to use it.

Kubernetes basics: Objects

Tue, 12 Apr 2022 09:00:00 -0100

Kubernetes objects describe the desired state of the cluster.

When an object is created, then Kubernetes will start it’s work that the desired state is fulfilled.

kubectl

Kubernetes objects get created either via the Kubernetes REST-API, where you describe via JSON the desired state. Or - and this is the way to go - via the CLI with kubectl.

In this case the command kubectl apply with the flag -f provides a YAML file with the specification.

Get the most out of Logstash

Thu, 07 Apr 2022 09:00:00 -0100

A good pipeline structure in Logstash gets you the most out of it!

Here are three tips for best practices in Logstash and thinks I would have known when I started to work with it.

1. No long-running operations

When you deploy Logstash you start it with either a default configuration or with your own settings.

However you will probably be limited in workers and the batch size.

This means that when you have some longer-running pipelines you will be limited in the size of the input as your Logstash instance gets stuck in job processing. Or in the worst case your instance will break!

The concepts of logstash pipelines

Thu, 07 Apr 2022 08:00:00 -0100

Either you want to work with data in your ELK-stack (Elasticsearch-Logstash-Kibana) or collect, parse and transform data from a variety of sources: Logstash is a good tool to choose.

In this article I will describe some of the basic concepts of Logstash, which shall be the foundation for further work.

Concepts of Logstash

Logstash can be used to ingest data from one or more sources, transform it and send it to one dedicated output. Originally Logstash was used to collect logs from applications, but now it can be used for any input sources and data transformation by using a variety of plugins.

Looking forward to Kotlin and Wasm

Tue, 05 Apr 2022 08:00:00 -0100

Since 2018 I’m looking after the progress of WebAssembly as I think it is a quite interesting technology and can be the technology of the future.

On the official Wasm page you can see which languages do support the compilation to Wasm.

However one very interesting thing for me is the support of Kotlin.

The current state of Kotlin and Wasm

With the introduction of the new K2 compiler Kotlin also announced that there will be better and faster support for the compilation to Wasm.

Active/passive disaster recovery. Part 2: Design

Wed, 30 Mar 2022 10:00:00 -0100

This is the second of two posts in a series about disaster recovery.

Part 1: Concepts

Part 2: Example design (this)

Now that we have defined the words and described some theoretical concepts of disaster recovery, let’s examine two different designs for an implementation.

Requirements

Let’s imagine an application which has the following requirements:

You have two endpoints to which you can send data: X and Y.
Services A and B are running on different (geographical/virtual) places.
Service A shall connect to X through cable C.
Service B shall connect to Y through cable D.

Which looks like a desperate try to flex with my alphabet knowledge is displayed in the following picture:

Active/passive disaster recovery. Part 1: Concepts

Wed, 30 Mar 2022 09:00:00 -0100

This is the first of two posts in a series about disaster recovery.

Part 1: Concepts (this)

Part 2: Example design

Time-sensitive applications often need to run nearly 100% of the time. Reasons are business requirements, or money and life critical applications.

E.g. In the financial world an outage of 1 minute can mean the loss of a huge amount of data and money, so it is a high priority to prevent this applications from outages.

How and when to write good logs

Tue, 29 Mar 2022 00:00:00 +0000

The greatest navigators logged their activities on the sea so good, that years after the logbooks were found you could track day by day the route of their trip. One great example of that is the USS Jeannette which story has been written down by Hampton Side.

When you are a developer, you should also take care of your logs. Even when you don’t like the sea!

In the last few years I have faced some situations where logs saved me from too much work or could have saved me some time on searching for root causes of failures.

Things to consider when building time-sensitive applications for realtime distribution

Fri, 25 Mar 2022 14:00:00 -0100

Distributing data in realtime has some exceptional challenges which you need to keep in mind when developing an application. In this article I want to have a look at an example I worked on and which things are needed to be considered during the development.

Realtime dissemination: Index value data

The application is in the field of disseminating index value data in realtime to a vendor outside of the system.

The two topologies of event driven architectures

Mon, 21 Mar 2022 16:00:00 -0100

In a request-based model the system makes actions according to a request which comes usually by a user.

An event-driven architecture reacts to a situation and makes actions regarding to this event.

An example for an event is a price update at the stock exchange, which can trigger different actions like a buy, calculation, selling etc.

The two topologies

You can split the event-driven architecture in two topologies: The mediator topology and the broker topology.

Designing the realtime distribution component of an application

Wed, 16 Mar 2022 15:40:00 -0100

I worked once on a problem where the requirement was to consume one internal feed and send it to an server outside.

We called the problem realtime distribution, because the data has been served by an internal websocket and changed every ~0.5 - 1 second for ~400 different sources.

So an application which should distribute the data needed to subscribe up to 400 or even more socket channels and send the data out to the real world.

On responsiveness and performance in event-driven services

Mon, 14 Mar 2022 14:00:00 +0000

… or: why it is better to create jobs instead letting the user wait.

One unique characteristic (or also a nice win) in event-driven architectures is that it gives us the capability for asynchronous communication.

You can send an event and just don’t care what happens with it (fire-and-forget) or send a request and wait for the reply. In the latter one event-driven architectures help a lot to increase the responsiveness of an application.

Implementing a STOMP client in a Spring Boot application

Sun, 13 Mar 2022 19:00:00 -0100

STOMP is a good and easy protocol to communicate in realtime via WebSockets.

If you want to implement such a client in your Spring application, you can use Springs simp package, which provides all you need to start quickly.

Requirements

This article focuses on the STOMP client, so you need a server you can subscribe to and consume messages from. (See also: A simple STOMP server & producer application)

Also, you need the spring-boot-starter-websocket library as a dependency. E.g. in Gradle:

Output IntelliJ IDEA logs to a local file

Tue, 08 Mar 2022 16:00:00 -0100

If you want to store logs of a Gradle run to a file, just add the filepath (including the name) via the UI.

For this you need to follow these options:

RUN -> Edit configurations -> Application -> Save console output to file...

This file is overwritten on every rerun.

Message ordering with Java Semaphores

Sun, 06 Mar 2022 22:00:00 -0100

Semaphores are useful to limit the access of concurrent threads to a resource.

This can be: A class instance, a variable or a method.

You can use it to assert that in critical parts of your code no parallel requests are happening.

Example use-case: Ordered messages

I used Semaphores in the financial world to assure, that time-sensitive messages had been send to an external resource in a specific order.

Every message had an order number which was counted up on every send.

Helm hands-on: Overriding values

Fri, 04 Mar 2022 17:30:00 -0100

As soon as you got Helm up and running and understand the basics, you can start using it.

Let’s do a small hands-on example.

Pre-requisites

A Kubernetes cluster
Docker installed
Helm installed

Hello, World!

We’ll use the cloudecho helm package.

This is a small API running on Port 8080, which prints a Hello, World! on every request.

To use it, we make use of the helm repo add command.

helm repo add cloudecho https://cloudecho.github.io/charts/
helm repo update

We can install it to our cluster with the following command:

Introduction to Helm

Fri, 04 Mar 2022 17:00:00 -0100

Managing YAML-files for Kubernetes can be sometimes really complicated: You have multiple files which describe for Kubernetes how to deploy the application. You have for example a Deployment, a Service, a ConfigMap and a Secret. All that files describe one desired state of your application.

Managing all of these files and keeping an overview of all them can get a little bit hard.

Furthermore you can’t reuse these deployment files for another deployment without copying them and changing what you need for this other deployment.

Validate input parameters in NestJS applications with ValidationPipes

Thu, 03 Mar 2022 19:00:00 -0100

Used NestJS version: 8.4.0

To validate user inputs like parameters or the request body in a REST call, you can use the built-in pipes of NestJS.

NestJS offers much more pipes in the @nestjs/common package. Head over to the documentation if you want to check them out.

Assure that the parameter is an integer

If you want to assure that a given route parameter is an integer, you need to bind the ParseIntPipe to the @Param decorator as follows:

Spring @Scheduled annotation - fixedDelay vs. fixedRate

Sun, 27 Feb 2022 08:00:00 -0100

Once I had some fun to debug a scheduled method which executes a request every 1 second.

I got told, that it works fine, but the request seems to get missed now and then.

We have been using Spring Boots @Scheduled(fixedDelay = 1000) annotation:

2022-01-24 11:13:47,974  INFO 160456 --- [   scheduling-1] c.m.n.controller.schedule.Scheduler   : Method executed!
2022-01-24 11:13:48,976  INFO 160456 --- [   scheduling-1] c.m.n.controller.schedule.Scheduler   : Method executed!
2022-01-24 11:13:49,991  INFO 160456 --- [   scheduling-1] c.m.n.controller.schedule.Scheduler   : Method executed!
2022-01-24 11:13:51,013  INFO 160456 --- [   scheduling-1] c.m.n.controller.schedule.Scheduler   : Method executed!
2022-01-24 11:13:52,016  INFO 160456 --- [   scheduling-1] c.m.n.controller.schedule.Scheduler   : Method executed!
2022-01-24 11:13:53,024  INFO 160456 --- [   scheduling-1] c.m.n.controller.schedule.Scheduler   : Method executed!

You can see that the milliseconds counter rises. That is due the correct behavior of fixedDelay: It executes the method every second after the last execution got finished.

Introduction into the microkernel architecture style

Fri, 25 Feb 2022 06:00:00 -0100

Product-based applications which are monolithic and installed on the customer side can use the microkernel architecture to make customization possible.

The microkernel architecture already exists for a long time and contains of two components:

The core system
Plug-in components

The image below shows the topology:

Core System

The core system is the minimal functionality which is needed to run the system properly. In this case plug-in components can be added or removed to customize the system and extend the application however it is needed.

Typescript decorators with examples

Thu, 24 Feb 2022 00:00:00 +0000

Decorators in Typescript help us to add annotations and a meta-programming syntax for class declarations and member.

You can add decorators to class declarations, method declarations, property declarations and parameters. Frameworks like NestJS and Angular are using decorators.

Let’s have a short look at decorators and how to use them.

*Currently decorators are an experimental feature. So if any of this code samples don’t work, things may have changed.

Project setup

If you want to try the following examples, start with initializing a new Typescript project in a directory:

The benefits and trade-offs of a Service-based architecture

Fri, 18 Feb 2022 00:00:00 +0000

Service based architectures have separately deployed services with an UI and one monolithic database.

The latter one is probably the biggest difference to microservices. But that’s not the only point where this style differs from microservices: You don’t have some well-known problems like e.g. orchestration as you are allowed to implement coarse-grained services!

The services in this style are also called domain services.

If you take a look at the picture below, you’ll probably think that you have already used this style in one of your applications.

Spring Boot and Kubernetes Configmaps

Thu, 17 Feb 2022 00:00:00 +0000

This document was last revised on 2022-09-24 and updated for the usage with Spring Boot 3.

Check the Repository for an executable example.

Deploying your Spring Boot applications in a Kubernetes environment will bring you many benefits like for example the usage of Configmaps.

What are Configmaps

Configmaps are API objects which store data in key-value pairs. This data can be consumed by your application as environment variables or CLI arguments.

The four dimensions of software architecture

Mon, 14 Feb 2022 00:00:00 +0000

At the beginning phase of a new software architecture there are four dimensions of software architecture at which you should look and communicate with the stakeholders.

Structure

This describes the type of architecture the system is implemented in. E.g. microservice, layered or microkernel.

Architecture characteristics ("-utilities").

These define the success criteria of a system.

The architecture characteristics contain:

Availability
Reliability
Testability
Scalability
Security
Agility
Fault Tolerance
Elasticity
Recoverability
Performance
Deployability
Learnability

Architecture decisions

These define the rules about how the system should be created. For example an architect could decide to make the persistence layer of a layered structure only available by the service layer to make the underlying storage easy replaceable.

Introduction into the pipeline architecture style

Sun, 13 Feb 2022 00:00:00 +0000

The pipeline architecture appeared for the first time when developers started splitting the functionality into parts.

If you’re using the Unix terminal, you have probably written something like the following snippet:

$ cat error.log | grep 'error'

That is exactly where the pipeline architecture plays a role!

Pipes and filters

As you can see in the picture below, the pipeline architecture consists pipes and filters.

Pipes are the communication channel between filters and communicate unidirectional by accepting an input from one source and directing the output to another.

Implementing clients when you have a PDF which describes the server behavior

Fri, 04 Feb 2022 00:00:00 +0000

Technical documentation services like readthedocs.io help a lot to create documentations which are easy to read and understand for the users of an API.

But in the enterprise world you’ll not always get such an API documentation link which also has code snippets or examples you can use in your application.

When consuming a third party service or sending data to it, you will sometimes get a PDF which describes how this services works and which messages it expects. No SDK or code snippets are provided.

Definition of and difference between modules and components

Mon, 31 Jan 2022 00:00:00 +0000

If you search for my title, you’ll find a lot of discussions about the differences of modules and components.

By reading literature about software architecture I also tried to get a definition of it. In my opinion it is really important to have a good overview what this terms mean to communicate ideas without any problems.

So let me share with you what I found out about them.

Modules

Modules are a set of parts or independent units. They can be used to create a more complex structure.

Do you know the protocols you're working with?

Sat, 29 Jan 2022 00:00:00 +0000

I never worked directly with the TCP protocol. As everyone with a CS degree I knew the 3-way handshake, it’s place in the OSI-layers and had an idea of the segment structure.

But then came the unexpected time where I needed to build up a service which communicates via TCP to another service and sends data to it.

For a successful implementation I needed to develop an application which follows a protocol over TCP.

Review: Programming Typescript - Making your JavaScript applications scale (Boris Cherny)

Sun, 23 Jan 2022 00:00:00 +0000

Although I wanted to start with it, I didn’t have the time to start reading technical literature until last years November. But then I wanted to refresh my Typescript skills and here we are.

I didn’t do much research to find some good books. As I know that the books from O’Reilly have good visualizations and are easy to read and understand I favoured them.

So the reviews led me to Boris Cherny’s Programming Typescript - Making your JavaScript applications scale.

Debugging with Gradle: See what happens during gradle builds

Mon, 17 Jan 2022 19:09:00 -0100

Sometimes the normal gradlew clean build doesn’t really help in the understanding why a gradle build fails.

In my case this issue once occured when a build on a Jenkins server failed, but not on my local machine (classic).

So there are two things which can be really helpful when debugging failed gradle builds.

Being very verbose

The following command will print you information during the gradle build, which can help you during debugging.

Experiences as a Mentor in a remote environment

Sat, 15 Jan 2022 00:00:00 +0000

In times of COVID-19 where a huge part of a team works mostly from home it may be a little bit hard to get into a new team and project.

Knowledge may not be transferred fast enough or not communicated good.

This in turn can lead to frustration for new team members and to higher costs for the company when a task which could be solved fast through good communication takes longer than needed. Also sometimes it could happen that something which already is implemented gets implemented twice, because who no communication happened.