Photo by Nuno Silva

Using jlink, one can easily create a custom Java runtime image that will only contain the modules required to run a given application. jlink also comes with some additonal plugins, some of which will help to additionaly reduce the size of the produced custom runtime image — namely the compress and the strip-debug plugins.

As its name implies, the strip-debug plugin will remove debugging information out of the output runtime image. With JDK13, this plugin was only stripping Java debug attributes from classes of the output image. …

I rarely post personal related stuff but I owe some updates.

TL;DR Everything is now fine! There’s nothing more important than family! There are amazing humans in the Java community and I have great colleagues! Thank you all!

While waiting in th ER…

Despite being detailless, my last tweet made it clear that things weren’t good. At that time, I wish I could have said that I had a health issue but unfortunately, it wasn’t me, it was my daughter! We’re (unfortunately) used to that but this time, it was a bit different.

On my way to the airport where…

There is a danger to containerizing legacy Java applications as-is, with their legacy JVM, as the ergonomics of those older JVMs will be fooled when running inside Docker containers.

Containers have become the de facto runtime packaging mechanism. They provide many benefits: a certain level of isolation, improved resource utilization, the ability to deploy applications across different environments, and more. Containers also help reduce the coupling between an application and the underlying platform as that application can be packaged into a portable container. This technique is sometimes used to modernize legacy applications. …

This post explains how Fn users can use GraalVM and the benefits GraalVM and its Ahead-of-Time (AOT) compiler bring to Serverless Java functions.


Fn Project is an open-source, container-native, polyglot FaaS (Function as a Service) platform.

Fn is open-source, one can run Fn on-premises and/or in the cloud; running Fn on a laptop is also convenient for experimentation and development.

Fn is container-native as it leverages Docker. In a nutshell, serverless functions are automatically wrapped into Docker container images (but advanced users can also provide their own Dockerfile!). …

Photo by Markus Spiske

Fn is a cloud agnostic, container native, serverless platform and as such, Fn leverages Docker extensively. In a nutshell, Fn will expose any piece of code as a Serverless function by turning it into a Docker image. All the heavy lifting of making the Docker image, invoking it properly with the right input, etc. is handled by Fn. As an Fn user/function developer, you don’t need to understand Docker and all its underpinning as Fn abstracts Docker away. Leveraging Docker also means that Fn can benefit from Docker’s rich ecosystem and tools.

Dive is a simple tool that allows you…

Right before my vacation, I had a short exchange with Guillaume Laforge, the Apache Groovy project PMC Chair, about running Groovy functions on Fn.

The bad news is that my vacations are behind me and that I didn’t have the time to prototype Groovy support thanks to my too-long-list-of-things-to-absolutely-do-before-going-away! Now I am back and the good news is that I was able, in a few hours, to add Groovy functions to Fn thanks to the new init-image approach!

As explained here, all we need is to provide a Docker image that will generate the required files for the…

“We shape our tools and afterwards our tools shape us.”
— Marshall McLuhan

As a Java veteran, I was a little disturbed when I first tried to build Fn. The confusion was mainly due to my Java background as things are quite different in Go!

In short, I faced 3 hurdles, the first one was tied to the fact that that Go has its own way of organizing a project (see here) which is unsurprisingly different than the typical Java project structure.

The second hurdle was how to properly clone the upstream project repository while preserving the imposed project organization…

As we saw in this post, it is really simple to write and deploy Serverless Kotlin functions using Fn. The Kotlin support is, in Fn, largely based on the Java support and more specifically on the Java FDK.

Photo credit : Romain Guy

The initial Fn Kotlin support was a bit different than it is today as it was using the kotlinc compiler in a Docker (build) image. That approach has been recently replaced (from CLI 0.4.129) in favor of Maven using the regular Java FDK images. The only real difference between Java and Kotlin is now how the runnable artifacts (JARs) are being built…

Kotlin is one of the fastest growing programming languages; it is used in the Android ecosystem and also is gaining traction in the enterprise world. So why not use Kotlin in the FaaS and Serverless space too?

Kotlin & Fn — A perfect combo?

Given its polyglot nature, Fn makes it very easy to write Kotlin based functions (“functions” as in FaaS).

Boostrap a Kotlin Function

To develop a Kotlin function, simply bootstrap it using the usual way with the Fn CLI (v0.4.129+), fn init —-runtime kotlin myfunc. This will create the required files to quickly get started. And obviously, all those files have a Kotlin flavor.

src/main/kotlin/HelloFunction.kt is a…

David Delabassee

@Java DevRel at @Oracle. Previously @FnProject @JakartaEE & @Java_EE. See also

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store