Kotlin on foojay.io - Friends of OpenJDK

Getting Started with Exposed: Kotlin ORM Made Simple

Mon, 06 Jul 2026 03:39:00 +0000

Introduction

For quite some time, I have been a huge fan of and fascinated by JetBrains products, tools, and libraries because of their masterful craftsmanship in product creation and their pristine focus on building high-quality developer tools.

Even more excitingly, JetBrains Java Annotated Monthly newsletters have featured most of the technical articles I wrote for Foojay on topics such as Java, Spring, Spring Boot 4, and OpenRewrite.

Recently, one Kotlin Domain-Specific Language (DSL) library caught my attention. I immediately tried converting my existing Spring Boot 4 application from Java to Kotlin using Exposed, an ORM framework for Kotlin. Kotlin SQL Libary

You’re invited to IntelliJ IDEA Conf 2026!

Mon, 29 Jun 2026 18:35:08 +0000

We are excited to invite you to IntelliJ IDEA Conf 2026, a free virtual event on September 8-9, 2026.

IntelliJ IDEA Conf is a celebration of the developer community, bringing together professionals who strive for excellence in software development. Join us for this free, live online conference and learn from industry leaders and experts on September 8-9, 2026.

You’ll be able to learn about a broad range of topics relevant to modern Java and Kotlin development, including language evolution, enterprise Java, Spring-based applications, build tooling, containerized workflows, JVM performance, and data access technologies. For more details, see the agenda below.

Command completion (..) in IntelliJ IDEA

Tue, 20 Jan 2026 07:31:35 +0000

How many shortcuts can you remember? Three? Five? More? I try to learn as many as I can and still forget some of them…

What if you could unlock IntelliJ IDEA features, without having to remember shortcuts? You can still use shortcuts if you want. But you don’t haveto.

Command completion (..) is a new feature in IntelliJ IDEA that lets you discover and execute IDE actions right from your editor.

Preparing for Spring Boot 4 and Spring Framework 7: What’s New?

Mon, 11 Aug 2025 14:42:40 +0000

I’m a passionate Spring Framework and Spring Boot enthusiast, and I always look forward to exploring and experimenting with the latest features and improvements they introduce. With Spring Boot 4 and Spring Boot Framework 7 right around the corner, now’s the perfect time to dive into the key enhancements that will shape the future of modern Java and enterprise application development.

In this blog post, we will discuss some key features enhanced as part of Spring Framework 7 and Spring Boot 4.

Pattern-matching across different languages

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

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

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

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

Java’s pattern matching

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

Kotlin adoption inside ING, five years later

Wed, 02 Jul 2025 06:21:47 +0000

TL;DR: Five years after its introduction Kotlin adoption inside ING keeps growing year after year, with a current adoption rate of just over 11%. We were also featured as one of the user stories for the KotlinConf 2025 Keynote.

Five years ago, Hielke and I wrote one of the first blogs of this account about being the first team to put Kotlin on production at ING . The article generated some interest and to this day it is still present as one of the Kotlin website case studies .

Authoring an OpenRewrite Recipe

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

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

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

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

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

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

Imagine an organization with the following practices:

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

A new engineer manager arrives and asks for the following:

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

It sounds reasonable.

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

Review of Junie, a coding agent by JetBrains – Revie

Wed, 26 Feb 2025 01:38:47 +0000

Other languages: Español 한국어 Português 中文

Recently, I talked about Duplicate Finder on the Foojay Podcast hosted by Frank Delporte . We briefly touched upon implementing support for other formats, and Frank asked if I’m planning on adding AsciiDoc, as it could be useful for his technical writing at Azul.

We agreed to think about adding the support soon. At the same time I got access to Junie , a newly announced coding agent by JetBrains, which is currently in early access. After a while, a thought came to me that this is a great opportunity to try it in action.

Duplicate finder – Tests

Wed, 18 Dec 2024 16:00:44 +0000

Other languages: Español 한국어 Português 中文

This post is about the development of the duplicate finder tool. For downloads and instructions on how to use it, see the Download page

It’s been a while since I published the intro to the duplicate finder project , so it looks like high time to provide some progress on that.

Before starting to write the program code, it makes sense to lay down the requirements first. A good way to do this is by writing tests. Not only will the tests help us develop faster, but they will also ensure that the code adheres to the specification.

How does it feel to test a compiler?

Thu, 08 Aug 2024 06:47:59 +0000

Hi, my name is Alex. I work as a QA engineer on the Kotlin/Native team. I’m often asked by friends and colleagues what it’s like to test a compiler, so I decided to write an article about it.

I’ll briefly talk about my path to compiler testing, the Kotlin/Native compiler, the specifics of the tasks, the tools I use, and the knowledge that helps me in my work.

I graduated with a bachelor’s and master’s degree in Software Engineering and then spent ten years in backend automation testing, including testing email backends (IMAP, POP3 protocols, email storage system, etc.), leading a testing team, and building test processes and test automation from scratch.

New video series "JavaFX In Action", Part 1

Tue, 16 Jul 2024 07:35:29 +0000

JavaFX is a powerful user interface framework, often overlooked in the world of desktop applications development. With this new series of video interviews, I want to take you behind-the-scenes of some applications built using JavaFX.

JavaFX combines the best features of a modern user interface toolkit with the unparalleled strength of the Java platform. This approach enables you to perform heavy “background tasks”, like processing large amounts of data, while still providing a responsive user interface.

Dynamic watermarking on the JVM

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

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

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

Foojay Podcast #54: Music and MIDI with Java and Kotlin

Mon, 24 Jun 2024 18:23:33 +0000

MIDI is a universal standard for communicating between musical instruments and computers.

Within OpenJDK, there is a whole Java package dedicated to MIDI communication and data handling. Is it up to date? Are there better approaches now? And what can we do with music, Java, and Kotlin?

Let’s find out…

Video

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

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

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

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

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

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

Video

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Book review: Frontend Development with JavaFX and Kotlin

Fri, 14 Jun 2024 09:06:53 +0000

For a personal pet project, I started experimenting with JavaFX and Kotlin to create a user interface with a lot of Java / Kotlin background processing. As I knew there is a book available on this specific topic, Apress was so kind to send me a review copy of Frontend Development with JavaFX and Kotlin: Build State-of-the-Art Kotlin GUI Applications by Peter Späth (152 pages, 48€ on paper, 35.5€ for ebook on Amazon.nl).

Hack a Java application with the debugger

Thu, 13 Jun 2024 04:58:03 +0000

Read in other languages: 中文 Español Português

Back in the day, computer games were different. Not only have graphics and mechanics evolved since, but there’s also one characteristic that doesn’t seem very common in games today: nearly all of them had cheat codes.

Cheat codes were sequences of keys that would give you something extraordinary, such as infinite ammo or the ability to walk through walls. The most common and powerful of them was ‘god mode’ – it made you invincible.

Java: Functional Programming f(x) – Part2

Mon, 03 Jun 2024 17:05:56 +0000

In the preceding article , we explored the significance of Functional Programming, Lambda Calculus, and other related concepts.

In this article, we delve deeper into the essential aspects of Functional Programming, such as…

1. Lambda Expressions 2. Method References 3. Functional Interfaces

And we will discuss about the relationship between each of the features.

JSR 335 has greatly facilitated programming in a multicore environment by introducing Lambda Expressions/closures/anonymous method, and related features.

Learn how to debug unresponsive Java/JVM applications, then reload the fix on the fly, using a hands-on example

Thu, 23 May 2024 07:14:31 +0000

Read in other languages: 中文 Español Português

There are a lot of debugger tutorials out there that teach you how to set line breakpoints, log values, or evaluate expressions. While this knowledge alone gives you a lot of tools for debugging your application, real-world scenarios may be somewhat trickier and require a more advanced approach.

In this article, we will learn how to locate code that causes a UI freeze without much prior knowledge of the project and fix faulty code on the fly.

Duplicate Finder for Documentation

Wed, 08 May 2024 22:08:04 +0000

Other languages: Español 한국어 Português 中文
This post is about the development of the duplicate finder tool. For downloads and instructions on how to use it, see the ‘Download’ page Download

Anyone who worked on technical documentation in a big team is certainly aware of the content duplication issue. Even with the best tools and practices at hand, duplication is fundamentally difficult to overcome.

Functional Programming: Revolutionizing Software Development

Thu, 25 Apr 2024 17:43:17 +0000

Mathematics serves as the driving force behind significant advancements in computer science from my perspective. We deeply root the fundamental principles that we utilize in our daily programming tasks and application development in mathematical concepts. I am constantly intrigued by the opportunity to incorporate mathematical ideas into the programming languages I work with as a student of Mathematics.

Many other programming paradigms, like functional programming, take inspiration from Mathematics to address challenges related to concurrency and parallelism. Computing shifts towards utilizing multiple cores and distributed systems, which makes this increasingly important.

Debug Without Breakpoints – Guide to IntelliJ IDEA's Pause

Mon, 22 Apr 2024 06:59:28 +0000

Read in other languages: 中文 Español Português

In a typical debugging scenario, you would set breakpoints to tell the debugger when to suspend your program. A breakpoint usually corresponds to the moment that marks the starting point of the further investigation.

However, in some situations you aren’t certain about where to set a breakpoint. Other times, you might prefer to suspend the program at a particular time rather than aiming at a specific line.

[Unit] Testing Supabase in Kotlin using Test Containers - PART 2

Wed, 13 Dec 2023 08:37:47 +0000

TL;DR : You can run a full Supabase instance inside Test Containers quite easily. See this repository .

In my last article , I was listing a few attempts I had done at running tests against my Kotlin Supabase application. The way the Supabase-Kt library is built makes it hard to mock, and I ended up building a minimal Docker Compose setup that was mimicking a Supabase instance.

In this second part, we’re gonna push the madness further and actually run a FULL SUPABASE instance locally, still using Test Containers .

Patterns For The Design Of Microservices – Part 3

Thu, 16 Nov 2023 04:35:02 +0000

In part1 , part2 , we discussed several design patterns that aid in the development of microservices.

This blog post will cover the subsequent design patterns.

Observability Patterns
Cross-cutting Concern Patterns

Microservice Architecture Patterns

Undoubtedly, the logging mechanism benefits troubleshooting issues that arise when executing operations or transactions on multiple deployed microservices.

We can further categorize the observability patterns into six distinct patterns.

Log Aggregation
Application Metrics
Audit Logging
Distrubuted Tracing
Exception Tracking
Health Check API

In the subsequent segment, we will discuss each topic separately.

[Unit] Testing Supabase in Kotlin using Test Containers

Wed, 15 Nov 2023 16:36:01 +0000

In this article, I’ll dive into several methods I’ve been looking into to unit test a Kotlin application using Supabase and why I finally decided to go for a Docker Compose / Test Containers solution.

TL;DR : The easiest way I found to test my database service is to mimick Supabase using Docker Compose and Test Containers. Here’s the code

In case you don’t know it, I’m a big fan of Supabase . I love that they’re a viable alternative to Firebase. I love that they’re built on top of Open-Source pieces. I love how innovative they are , and how much they give back to the community . And as you already know it, I love Kotlin as well.

OpenAPI Generator: From YAML to JetBrains HTTP Client

Fri, 10 Nov 2023 10:41:35 +0000

In this article, I’ll be implementing an OpenAPI generator from scratch so you can too! We’ll be creating a very simple generator for the Jetbrains HTTP Client.

This is the online version of the article with the same name I wrote for the Dutch Java Magazine.

In the previous edition of the magazine, we discussed how the JetBrains HTTP Client could be used to run HTTP Queries, automate them and even use them in your CI/CD pipelines. Just like Postman , but text based and can be part of your source code. Pretty cool.

Patterns For The Design of Microservices

Wed, 11 Oct 2023 06:11:03 +0000

Design patterns plays a pivotal role in designing and solving the commonly occurring problems in software application. It is guiding principle or template to the solve any designing problems.

It applies to the Microservices architectural style as well. These patterns provide a structured approach to designing and implementing Microservice architectures, ensuring scalability , maintainability , and reusability. By adhering to these design patterns, developers can proficiently tackle the common challenges encountered during Microservices development.

Foojay Podcast #27: Chicago JUG and KUG

Mon, 04 Sep 2023 09:24:32 +0000

Since December last year, the Foojay podcast virtually visited a Java User Group monthly.

This journey has already brought us to many places around the world.

And this time, we are in Chicago to learn from the Java and Kotlin user groups.

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Reactive Database Access on the JVM

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

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

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

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

FP in Kotlin: Defining a Pipe Operator

Fri, 02 Jun 2023 15:18:13 +0000

There’s no support for the pipe operator |> in Kotlin, so we have to come up with a custom and clean implementation for this function.

Defining a Pipe Operator

Next, one consistent and clean implementation is given for a pipe operator in Kotlin.

Finding a Suitable Symbol

First, I wanted to use the |> pipe symbol commonly used in functional languages, but > is not a supported character: Name contains illegal characters: >.

Replacing Postman with the Jetbrains HTTP Client

Thu, 13 Apr 2023 06:59:28 +0000

TL;DR: I’ve created the first version of an openapi-generator for the JetBrains HTTP Client, and together with the CLI runner it allows you to play against APIs without ever going out of your terminal and it can even run in your CI/CD pipeline. See repository here .

I work a lot with APIs, whether for an app I develop myself, or to interact with others. Most people I know tend to use Postman for this. But I personally don’t quite like the product any more , and it forces me to move out of my IntelliJ environment which really kills my productivity.

Coroutines on the RaspberryPi (Pi4J-Kotlin)

Sat, 01 Apr 2023 09:05:29 +0000

If you didn’t know already, Pi4J has had a Kotlin DSL for quite some time now.

And I’m here to announce the latest release v2.4.0 with a sack of additions and to tell you about all the good stuff that’s been added since the first release .

Coroutines {#h2-0-1-coroutines}

If the pi4j { ... } wasn’t good enough for ya, and you want to use coroutines instead of weaving fat threads on your precious precious Pi, you can now use the new pi4jAsync { ... } block—It can do everything pi4j { ... } does + you can run suspended functions within.

The Right Feature at the Right Place

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

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

It’s a reasonably common career move.

The problem in this situation is two-fold:

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

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

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

It’s a bad one in most cases.

Null Safety: Kotlin vs. Java

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

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

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

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

Gossips: An Event-Bus in a Chatty Neighbourhood

Thu, 24 Nov 2022 08:35:32 +0000

In this article, we’ll tackle a common issue: simple communication between system components. With a slightly controversial, themed, domain-driven design.

Though this post has nothing to do with Android, we need a context where an Event-Bus is needed. And boy oh boy is it needed in Android! And we’ll use this as an excuse to write an Event-Bus.

I chose an analogy for the entire thing: Gossips;\

It fits with the nature of the library, and the way it’ll be used. A global pub-sub component to enable cross-component communication.

Kotlin on the RaspberryPi (Pi4J-Kotlin)

Thu, 17 Nov 2022 13:37:18 +0000

Pi4J is considered the project that brought the JVM to the RaspberryPi.

It has been up for more than a decade allowing developers to write sophisticated, high-level, yet simple software on the RaspberryPi.

And we’re glad to make it even more simpler and powerful!

For quite some years now Kotlin has been a most welcome language in the JVM ecosystem and the modern development toolchain.

Many factors led to this great reality, most notable to me is Kotlin’s non-disruptive integration and seamless developer experience.

End-to-End Tracing with OpenTelemetry

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

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

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

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

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

However, monitoring is only the beginning of the journey.

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

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

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

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

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

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

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

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

Chopping the Monolith: The Demo

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

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

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

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

As Linus Torvalds once wrote:

Talk is cheap, show me the code!

Toying with Kotlin's Context Receivers

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

Kotlin added the idea of Context Receivers in version 1.6.20.

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

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

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

A simplified model sample

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

Diving into JVM Framework Monitoring and Profiling

Fri, 13 May 2022 06:36:05 +0000

Managing available resources on demand in a cloud environment can be a very challenging topic. It is worth the effort, since it may however utilise resources far more efficiently.

Companies or projects are therefore very keen to migrate to the Cloud providers, such as Azul, AWS, Google Cloud or others. For software engineers one truth still stands, also in the Cloud: It’s recommended to understand the behaviour and limitations of our deployed JVM application (or pods, the smallest deployable instance in Kubernetes).

Switch Statement and the Factory Pattern in Three JVM Languages

Wed, 06 Apr 2022 09:10:08 +0000

The goal of this article is to examine a program selection control mechanism.

A selection control mechanism allows a value, expression or variable type to influence the program flow execution. This concept is commonly used by developers.

A good example for this is a widely used design pattern. A design pattern that belongs to the family of creational patterns and is used for an object creation without exposing the entire logic.

Handling Null: Optional and Nullable Types

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

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

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

Running this snippet may result in something like the following:

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

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

Observability for JVM Frameworks with Grafana in Java and Kotlin

Wed, 30 Mar 2022 06:30:58 +0000

Grafana dashboard for all running frameworks

Introduction

In times of Cloud and distributed applications, it is becoming more and more important to be able to evaluate a functionality at runtime, an aspect which is referred to as observability .

A Cloud-based application is usually set up as a collection of different subsystems that may be located in one or more network zones or machines. These subsystems communicate with each other by passing messages (signals) and executing desired actions to each other. The whole collection then appears to the end user as a single coherent system.

Kover : Code Coverage plugin for Kotlin

Mon, 28 Feb 2022 21:34:12 +0000

TL;DR: Kover is a code coverage tool for Kotlin. It’s still in incubator phase but I took it for a spin and it is already very useful as part of local or CI workflows! In this article I go through the setup and some of my favourite goodies of the tool. You can see my experiment over here.

At the end of last year, the version 1.6.0 of Kotlin was officially released ! The release was packed with new language features, but also some very nice tooling and ecosystem goodies.

Avoiding Stringly-typed in Kotlin

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

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

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

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

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

Measuring Time and Durations in Kotlin

Fri, 25 Feb 2022 09:56:31 +0000

TL;DR : The DurationAPI is coming out of its experimental stage and offers a nice DSL to easily work with time durations. If offers the obvious but also nice extra goodies, such as coercions and ISO/String conversions and is notably used to calculate processing time . You can directly run the code I present below in the Kotlin playground !

In this article, we’ll be diving into one of the other news of the Kotlin 1.6 release : The DurationAPI coming out of Experimental and is available for all flavours of Kotlin (so JS as well 😊)! Let’s look quickly together what it has to offer!

Backpressure in Reactive Systems

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

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

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

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

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

Beautify Third-Party APIs with Kotlin

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

Scala has popularized the “Pimp my library” pattern:

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

– Pimp My Library Pattern in Scala

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

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

Native-image with Quarkus

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

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

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

Creating a new project

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

A dedicated quarkus CLI
A Web UI

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

Non-blocking with Spring WebFlux, Kotlin and Coroutines

Thu, 09 Dec 2021 14:03:28 +0000

When a HTTP request comes in, a ’normal’ web application would map the request to a specific thread from the thread pool. This assigned thread stays with the request until a response can be returned to the request socket. Along the way, we might need to fetch data from some web service or database, read or write to a file or do other I/O calls, during which the thread is blocked and has to wait until it gets a response. For applications with high request rates, the thread pool can at some point become exhausted and then no new requests can be handled anymore.

Native-image with Micronaut

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

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

Creating a new project

Micronaut offers two options to create a new project:

A web UI :

As for Spring Initializr, it provides several features:

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

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

Native-image with Spring Boot

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

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

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

Extending Third-Party APIs in Different Languages

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

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

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

Hazelcast + Kibana: Best Buddies for Exploring & Visualizing Data

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

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

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

Kotlin and FaaS: An Impossible Union?

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

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

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

Debugging Tutorial 1 – Introduction: Conditional Breakpoints & Set Value

Wed, 27 Oct 2021 08:03:53 +0000

In this series, I’ll walk you through the process of debugging applications and finding issues within them. As we debug, we’ll cover the techniques important for most developers. I will cover the following debuggers:

IntelliJ/IDEA – with Java/Kotlin
PyCharm – Python
VSCode – for JavaScript
WebStorm – for JavaScript

These should cover most use cases you’ll run into and some things will seem duplicate/redundant so you can just skip to the applicable section if you feel you “got the gist”.

Multiple Ways to Configure Spring

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

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

Many alternatives are available to configure your Spring app.

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

Core concepts

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

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

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

Introducing Jetpack Compose for Desktop

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

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

Getting your feet wet

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

Building Command Line Interfaces with Kotlin using picoCLI

Thu, 23 Sep 2021 07:05:12 +0000

TL;DR : We’ll dive into a few interesting bits about CLI applications and picoCLI. But you can directly see the code here , or view my related conference talk here .

As a developer, there is a large chance that you use Command Line Interfaces (CLIs) every day. From Git, to kubectl or Maven, they are everywhere. In this article, we’ll look into use cases where CLIs are a great idea. We’ll also dive into best practises, and discover one of the most used library for CLIs in the JVM world: picoCLI .

VS Code: SpringOne Updates, UX Improvements, Community Feedback

Mon, 20 Sep 2021 06:46:49 +0000

Hi everyone, welcome to the August edition of the Visual Studio Code Java update!

In this article, we are going to share some exciting updates from the SpringOne 2021 conference, as well as various user experience improvements.

When it comes to Java development, we always keep Spring developers in mind. In this year’s SpringOne conference , we shared an update on our Spring tooling support in Visual Studio Code, and showcased various Spring related features in two breakout sessions.

A Return to Annotation-Free Spring

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

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

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

Taking a Closer Look at Kotlin's Delegation

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

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

The delegation pattern

The delegation pattern is described in the book:

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