Blogs

Handling version updates of Single Page Applications while rendering client side

Dennis Gijzen - May 20, 2024

Version updates for SPAs that are client side require a small bit of configuring. When not handled well the user experience lessens and might, in some minor cases, be a degradation to security. Though not hard to tackle there are some things to consider.

Rubber Duck Debugging with LLMs

Adolfo Benedetti - Apr 2, 2024

Using large language models (LLMs) for rubber duck debugging, a technique for clarifying code by explaining it to someone (or something). It highlights prompt engineering techniques to make LLMs effective debugging companions.

Experiences with Astro + Lit + Tailwind

Maarten Verbaarschot - Feb 6, 2024

With a tech stack consisting of three relatively young frameworks, surely things are about to get excited. In this article I will share some background, decisions, successes and challenges from a recent project.

Your Keycloak configuration setup could use a 'KISS'

Christiaan Schop - Dec 22, 2023

Keycloak and other Identity Access Management (IAM) tools are important for organizational security and application functionality. Tools that sometimes have to cope with cautious management processes. To gain more control over these processes, a different configuration approach is discussed for Keycloak. Simplifying the integration of maintenance and testing of our solutions.

Error budgeting your Spring Boot application with Actuator and Prometheus

Oleksandr Shynkariuk - Oct 30, 2023

In this article we explore how Error Budgeting with Service Level Indicators (SLIs) and Service Level Objectives (SLOs) help organizations to achieve and maintain seamless and satisfactory user experience. We will define SLIs and SLOs on a Spring PetClinic sample application and will use them to set up an alert in case Error Budget is consumed

Houtbewerken vs software development

Jesse van Leeuwen - Oct 16, 2023

Als ervaren software developer en beginnend meubelmaker heb ik gekeken naar de parallellen tussen houtbewerking en software development. Welke verschillen en welke overeenkomsten zijn er en welke lessen uit het houtbewerken pas ik toe op software development?

Understanding RxJS through the lens of the Observer Pattern

Dennis Gijzen - Mar 21, 2023

Both the classic Observer Pattern and the library RxJS use reactive programming. Both, the Observer pattern and the library, can deal with asynchronous code. Though somewhat similar there are differences that sets them apart. Most notably, when using RxJS compared to the Observer Pattern, is that we stop moving around the reference to the origin and instead refer to the data stream instead. Another difference would be that RxJS is by nature lazy and only subscribing to an Observable in RxJS makes the library (re)do all the steps nessecary to get the value(s) for the subscriber. By reflecting on the classic Observer pattern, a new understanding of RxJS can be grasped that deepens your knowledge and thereby helps to become better in using the library RxJS.

A set of noteworthy uses of MockK (that might come in handy)

Christiaan Schop - Mar 6, 2023

Doing a job with the right tools can make your job easier, results in higher quality and makes room for creativity. In this article we convince you that MockK is such a tool for Kotlin unit testing.

Faster NestJS REST APIs with Automated Parallelization of Business Logic

Maarten Verbaarschot - Jan 11, 2023

While inspecting the performance of our internally developed REST APIs for an e-commerce project, my team noticed that the performance of certain endpoints was not as good as we wanted, with an average of 6 seconds per call. We felt that an average of 1 second per call would be good to strive for. We came up with the idea to develop a proof-of-concept, to validate how much faster our slowest endpoint would get and if it would be close enough to our ambition of 1 second per call on average.

Configuring the ELK stack to persist your observability data from Jaeger

Adolfo Benedetti - Dec 12, 2022

Observability is a crucial aspect of modern software systems, as it allows engineers to monitor and diagnose issues in real-time. Jaeger and Elasticsearch are two powerful tools that can be used for observability, but they operate in different domains and have different data formats. Interoperability between Jaeger and Elasticsearch would allow engineers to integrate and analyze data from both systems in a single platform, providing a more comprehensive view of their systems and enabling more effective troubleshooting and analysis. This would be particularly useful for large, distributed systems where multiple teams are working on different components. By bringing together data from Jaeger and Elasticsearch, the connector would enable a more holistic approach to observability, enabling engineers to gain deeper insights and make more informed decisions.

Quit using your mouse - use IntelliJ shortcuts!

Thierry Gerritse - Aug 19, 2022

Are you done wasting time using your mouse for everything when developing? Try using IntelliJ's shortcuts to help you out! In this article we will have a look at some very useful shortcuts to help you improve your productivity when coding.

Spice up your tests using Faker

Oleksandr Shynkariuk - Jun 20, 2022

Having your test data as close as possible to production data is a key to having high quality tests. However, it is rarely possible to use production data for testing purposes. Kotlin Faker library helps with generating randomized data for different domains (addresses, contact details, numbers etc.) that look real. In this article we will explore Kotlin Faker and see what data can we generate for a real-world use case.

Customizing Angular builds with TypeScript AST transformers

Daan Scheerens - Feb 6, 2022

Despite the advantages of TypeScript AST transformers, there is no official support for them in the Angular CLI. Fortunately, there is way to make use of them without having to get rid of the CLI. Using custom builders, it is possible to get access to the webpack configuration used by the Angular CLI. This in turn provides the opening needed to add your own AST transformers into the mix.

Applying markup to translations in Angular applications (the right way)

Daan Scheerens - Jan 11, 2021

Multi-language support in Angular application can be achieved with the help of libraries such as Angular i18n, NGX Translate or Transloco. Unfortunately, these all fail to address a commonly needed feature: translated text that contains markup. Translation splitting and innerHTML binding are often used as workaround. But these approaches are far from ideal. A better approach, supporting a context specific markup syntax is outlined in this article.

RxJS subscription management: when to unsubscribe (and when not)

Daan Scheerens - Mar 5, 2020

When working with RxJS observables you will be faced with the concept of subscriptions. Although they are quite useful, they are often used incorrectly, or worse: simply ignored. A detailed explanation of their function and how to handle them in the right way is given in this article. It explains when you must unsubscribe, when it is okay not to unsubscribe and when it is wrong to unsubscribe. You will also find tips for easily keeping track of subscriptions.

Explicit and type-safe Angular module configuration

Daan Scheerens - Jan 3, 2020

Angular's architecture and build system makes it easy to create reusable modules. Reusability largely depends on the available configuration options. Since configuration is also part of the public API surface of the module, it is important to set this up in a simple and safe to use manner. In this article you will learn how to create configuration interfaces for your Angular modules that are both explicit and type-safe. The offered solution also supports more advanced usage scenarios that require dynamically constructed configurations via dependency injection.