Geertjan Wielenga https://foojay.io/today/author/geertjan-wielenga/ a place for friends of OpenJDK Thu, 21 May 2026 17:49:44 +0000 en-US hourly 1 https://wordpress.org/?v=6.9.4 https://foojay.io/wp-content/uploads/2020/04/Favicon-3-2-150x150.png Geertjan Wielenga https://foojay.io/today/author/geertjan-wielenga/ 32 32 From Zero (Really Zero) to OpenTelemetry https://foojay.io/today/from-zero-really-zero-to-opentelemetry/ https://foojay.io/today/from-zero-really-zero-to-opentelemetry/#respond Tue, 19 May 2026 13:36:11 +0000 https://foojay.io/?p=123879 Table of Contents The Super Awesome PromptWhy This Prompt WorksAfter The Agent FinishesFollow Up Prompts You'll Likely Want Here's a super awesome prompt (e.g., for Claude Code) that you can use with https://github.com/dash0hq/agent-skills, the free collection of skills for AI ...

The post From Zero (Really Zero) to OpenTelemetry appeared first on foojay.

]]>
Table of Contents
The Super Awesome PromptWhy This Prompt Works

Here's a super awesome prompt (e.g., for Claude Code) that you can use with https://github.com/dash0hq/agent-skills, the free collection of skills for AI coding agents to make applications observable with OpenTelemetry, such as with Dash0.

And the end result is this, a view into the traces of your application (without anything at all at the start of the process).

The Super Awesome Prompt

Take a careful look below: before doing this prompt, not only do we not have an application that is instrumented with OpenTelemetry yet. Not only do we not have the agent we need to do the instrumentation yet.

The application itself doesn't even exist yet.

So, here's the prompt that gets you from really zero to OpenTelemetry:

Create a minimal Spring Boot app from scratch in this directory with two endpoints: GET /hello returning a greeting, and GET /work that sleeps 50–200ms and returns a JSON payload. Use Maven and Java 21.

Then instrument it with OpenTelemetry to send traces, metrics, and logs to Dash0 using the otel-instrumentation skill.

Configuration:
Endpoint: <placeholder for your endpoint> (gRPC, so set OTEL_EXPORTER_OTLP_PROTOCOL=grpc)
Auth header: Authorization=Bearer <placeholder for your token>
Dataset: default (via Dash0-Dataset header)
Service name: dash0-java-demo
Service version and namespace as appropriate resource attributes

Use the OpenTelemetry Java agent (-javaagent:opentelemetry-javaagent.jar) — download it into the project. Don't hardcode the token in source; put env vars in a run.sh script that's gitignored, and document everything in a README. Follow OpenTelemetry semantic conventions for any custom spans or attributes you add.

When done, show me the exact commands to run the app and generate some traffic.

(All you need to run this prompt is to get your endpoint and token from your Dash0 Settings dialog, and put them in the placeholders above.)

Why This Prompt Works

A few things in there are deliberate:

  • "using the otel-instrumentation skill" — naming it explicitly nudges the agent to load it. Skills are supposed to auto-trigger on description match, but being explicit removes ambiguity, especially in tools where skill triggering is less aggressive than in Claude Code.
  • Concrete config values — agents do much better with copy-pasteable specifics than "set up Dash0." You'd otherwise spend two turns answering "what's your endpoint?"
  • gRPC protocol callout — port 4317 needs OTEL_EXPORTER_OTLP_PROTOCOL=grpc; without it, the agent might wire up the default HTTP protocol and silently fail. Worth pinning.
  • run.sh + gitignore — keeps your token out of source control. The agent will do this if asked; less reliably if not.
  • "show me the commands to run" — forces it to surface the verification path, not just dump files.

After The Agent Finishes

You should end up with, roughly pom.xml, src/main/java/.../Application.java plus a controller, opentelemetry-javaagent.jar, run.sh, .gitignore, README.md.

Then run it (also fine to do in your AI prompt):

./run.sh
# in another terminal, generate traffic:
for i in {1..50}; do curl -s localhost:8080/hello; curl -s localhost:8080/work; done

Then in Dash0 go to the Trace Explorer — filter by service.name = dash0-java-demo, you should see GET /hello and GET /work spans within 10–30 seconds.

Next, go to Integrations → Java → Install all dashboards if you haven't yet, then open JVM Metrics for the heap/GC/thread charts.

Follow Up Prompts You'll Likely Want

Once data is flowing, these are the natural next asks (each triggers a different skill):

  • "Add a custom span around the work logic in /work with a work.difficulty attribute that follows semantic conventions." → triggers otel-semantic-conventions for naming guidance.
  • "My span names look wrong — they're showing the full URL instead of the route. Fix that." → common Spring Boot gotcha, the instrumentation skill covers it.
  • "Set up an OpenTelemetry Collector in front of the app instead of exporting directly to Dash0." → triggers otel-collector.

That's pretty cool, get it here: https://github.com/dash0hq/agent-skills

The post From Zero (Really Zero) to OpenTelemetry appeared first on foojay.

]]> https://foojay.io/today/from-zero-really-zero-to-opentelemetry/feed/ 0 Foojay Podcast #94: More Than a Blog: How Foojay Connects, Sustains, and Evolves the Java Community https://foojay.io/today/foojay-podcast-94-more-than-a-blog-how-foojay-connects-sustains-and-evolves-the-java-community/ https://foojay.io/today/foojay-podcast-94-more-than-a-blog-how-foojay-connects-sustains-and-evolves-the-java-community/#respond Mon, 04 May 2026 06:26:00 +0000 https://foojay.io/?p=123570 Table of Contents YouTubePodcast AppsContent Foojay.io, the website for the Friends of OpenJDK, is turning six years old. To celebrate, Frank Delporte headed to JCON in Cologne, Germany, and sat down with twelve members of the Java community to talk ...

The post Foojay Podcast #94: More Than a Blog: How Foojay Connects, Sustains, and Evolves the Java Community appeared first on foojay.

]]>
Table of Contents
YouTubePodcast AppsContent

Foojay.io, the website for the Friends of OpenJDK, is turning six years old. To celebrate, Frank Delporte headed to JCON in Cologne, Germany, and sat down with twelve members of the Java community to talk about what Foojay means to them, what they learn from each other, and how the community is evolving.

This episode covers a lot of ground. Sharat Chandar reflects on 25 years in the Java community and why the people are what keep the language alive. Markus Westergren and Iryna Dohndorf both focus on a theme that comes up again and again: developer sustainability. Not just green software, but how you stay healthy, grounded, and relevant when AI is changing everything around you. Markus and his wife researched how developers are reacting to AI, from ignoring it completely to transforming everything they do. Iryna talks about building resilience and robustness as skills, not afterthoughts.

René Schwietzke dives deep into JIT compilation and his work on the 1 billion row challenge, writing fast pure Java code without reaching for unsafe methods. Gerrit Grunwald explains the Disco API, the tool behind SDKMAN, Gradle, and more, which tracks every OpenJDK distribution available, including ones you have probably never heard of from Asia. Catherine Edelveis walks through why choosing the right OpenJDK distribution matters and how reducing Docker image sizes improves both security and performance. Jago de Vreede built a JavaFX UI for SDKMAN and talks about what he keeps learning from the community.

Annelore Egger mentors people who think they do not know enough to speak at conferences. Spoiler: they do. Buhake Sindi brings Jakarta EE into the AI agent world with LangChain4J CDI and a talk on agent-to-agent protocols. François Martin just published a fresh Foojay article on flaky tests and shares what writing and mentoring have taught him about open source. Dominika Tasarz-Sochacka, Frank's new Foojay colleague, shares her vision for growing the community and making it even more welcoming. And Geertjan Wielenga, who started Foojay six years ago, joins remotely from under a lighthouse in Ireland to look back and look forward.

Foojay is more than a blog. It is a Mastodon server, a Slack community, the Disco API, a book on sustainability, a podcast, and now an education catalog. Six years in, it is still growing, still community-driven, and still very much a place where anyone who works with Java is welcome.

YouTube

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Content

00:00 Introduction

02:16 Sharat Chandar

05:37 Markus Westergren

09:46 Iryna Dohndorf

13:59 René Schwietzke

18:28 Gerrit Grunwald

27:45 Catherine Edelveis

31:16 Jago de Vreede

35:05 Annelore Egger

38:03 Buhake Sindi

44:03 François Martin

48:18 Dominika Tasarz-Sochacka

51:18 Geertjan Wielenga

58:15 Conclusion

The post Foojay Podcast #94: More Than a Blog: How Foojay Connects, Sustains, and Evolves the Java Community appeared first on foojay.

]]> https://foojay.io/today/foojay-podcast-94-more-than-a-blog-how-foojay-connects-sustains-and-evolves-the-java-community/feed/ 0 From Zero to Full Observability with Dash0 https://foojay.io/today/from-zero-to-full-observability-with-dash0/ https://foojay.io/today/from-zero-to-full-observability-with-dash0/#respond Sat, 04 Apr 2026 06:35:47 +0000 https://foojay.io/?p=123311 Table of Contents Before: A Service with No Observability Part 1: Build the Application Part 2: Containerize and Publish Part 3: Deploy to Kubernetes Part 4: Generate Traffic (the Before State) After: Adding Observability with the Dash0 Operator Part 5: ...

The post From Zero to Full Observability with Dash0 appeared first on foojay.

]]>
Table of Contents
Before: A Service with No ObservabilityAfter: Adding Observability with the Dash0 Operator

This guide walks through the complete process of deploying a minimal Spring Boot service to Kubernetes and adding full observability using the Dash0 Kubernetes Operator — without making any changes to the application code.

Dash0 is an OpenTelemetry-native observability platform that collects and correlates traces, metrics, and logs, and provides infrastructure monitoring across Kubernetes resources — pods, nodes, namespaces, deployments, daemonsets, statefulsets, jobs, and cronjobs — as well as cloud infrastructure such as AWS. Its Kubernetes operator can automatically instrument workloads at the pod level, with no changes required to application code or container images.

The setup is divided into two distinct phases. The first phase establishes the "before" state: a service running in Kubernetes with no instrumentation, generating traffic that is completely invisible to any observability tool. The second phase adds the Dash0 operator to the cluster, which automatically instruments the workload and begins sending traces, metrics, and logs to Dash0 — again, with no changes to the application itself.

The entire workflow runs without a local Docker installation. The Docker image is built and pushed via GitHub Actions, and the Kubernetes cluster runs inside a GitHub Codespace.

Before: A Service with No Observability

Part 1: Build the Application

The starting point is a minimal Spring Boot REST API with no observability configured at all. No OpenTelemetry, no Micrometer, no logging frameworks — just the web starter and a controller with two endpoints. This is the "before" state: a service that is running but completely invisible.

1. Create the pom.xml. Create pom.xml with one dependency:

<dependencies>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
</dependencies>

One dependency, no telemetry — this is intentional. The absence of any OpenTelemetry or metrics libraries is the purpose of the "before" state.

2. Create the main application class. Create src/main/java/com/example/demo/DemoApplication.java:

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

This is the standard Spring Boot entry point — nothing beyond the minimum needed to start the application.

3. Create the controller. Create src/main/java/com/example/demo/OrderController.java:

package com.example.demo;

import org.springframework.web.bind.annotation.*;
import java.util.List;

@RestController
public class OrderController {

    @GetMapping("/orders")
    public List<String> getOrders() {
        return List.of("order-1", "order-2", "order-3");
    }

    @PostMapping("/orders")
    public String createOrder(@RequestBody String order) {
        return "Created: " + order;
    }
}

Two endpoints with no logging, no instrumentation, and no tracing — when this service is running, you have no visibility into what it is doing.

4. Build the app

mvn package -DskipTests

This packages the application into a single executable JAR in the target/ directory, which gets copied into the Docker image in the next step.

Part 2: Containerize and Publish

To run the app in Kubernetes it needs to be packaged as a container image. Rather than building and pushing the Docker image locally, we use GitHub Actions to do it in the cloud. This avoids any need for a local Docker installation.

1. Create a Dockerfile. This Dockerfile uses Azul Zulu 25 as the base image.

FROM azul-zulu:25-jre
COPY target/order-service.jar app.jar
ENTRYPOINT ["java", "-jar", "/app.jar"]

2. Create the GitHub Actions workflow. Create .github/workflows/build.yml. The workflow builds the Maven project, logs in to Docker Hub using repository secrets, and pushes the image. It triggers automatically on every push to main.

name: Build and Push Docker Image

on:
  push:
    branches:
      - main

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Set up JDK 21
        uses: actions/setup-java@v4
        with:
          java-version: '25'
          distribution: 'zulu'

      - name: Build with Maven
        run: mvn package -DskipTests

      - name: Log in to Docker Hub
        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}

      - name: Build and push Docker image
        uses: docker/build-push-action@v5
        with:
          context: .
          push: true
          tags: ${{ secrets.DOCKER_USERNAME }}/order-service:latest

3. Add Docker Hub secrets to GitHub. Go to the GitHub repo Settings → Secrets and variables → Actions and add:

  • DOCKER_USERNAME — your Docker Hub username
  • DOCKER_PASSWORD — your Docker Hub password or access token

Push the workflow file and GitHub Actions will build and push the image to Docker Hub automatically.

Further Reading:

Part 3: Deploy to Kubernetes

With the image on Docker Hub, we can deploy the app to Kubernetes. We use GitHub Codespaces as the environment, which gives a full Linux terminal in the browser without requiring any local tooling. From there we install kind, which spins up a cluster inside the Codespace.

1. Open a Codespace. Go to the GitHub repo, click Code → Codespaces → Create codespace on main.

2. Install kind and create a cluster

curl -Lo ./kind https://kind.sigs.k8s.io/dl/latest/kind-linux-amd64
chmod +x ./kind
sudo mv ./kind /usr/local/bin/kind
kind create cluster

3. Create the Kubernetes manifest. The manifest defines a Deployment with one replica and a Service that exposes it on port 80. The image reference points directly to the Docker Hub image pushed in the previous step.

Create deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: order-service
spec:
  replicas: 1
  selector:
    matchLabels:
      app: order-service
  template:
    metadata:
      labels:
        app: order-service
    spec:
      containers:
        - name: order-service
          image: your-name/order-service:latest
          ports:
            - containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: order-service
spec:
  selector:
    app: order-service
  ports:
    - port: 80
      targetPort: 8080

4. Deploy the app. Apply the manifest and update the image reference to point to the correct Docker Hub image:

kubectl apply -f deployment.yaml
kubectl set image deployment/order-service order-service=your-name/order-service:latest
kubectl get pods

Wait until the pod shows Running.

Further Reading:

Part 4: Generate Traffic (the Before State)

Because we are inside a Codespace rather than running locally, the service is not directly accessible on localhost. We use kubectl port-forward to bridge the gap. This is the before state — the service is running and receiving traffic, but nothing appears in Dash0. No traces, no metrics, no logs.

1. Start the port-forward (terminal 1)

kubectl port-forward svc/order-service 8080:80

2. Start the traffic loop (terminal 2). Open a second terminal and run:

while true; do curl http://localhost:8080/orders; sleep 1; done

After: Adding Observability with the Dash0 Operator

Part 5: Install the Dash0 Operator

Now we add observability — without touching the application code, the pom.xml, or the Docker image. The Dash0 operator is installed into the cluster using Helm. It runs in its own namespace and is responsible for injecting instrumentation into workloads and forwarding telemetry to Dash0.

Run the install command on a single line to avoid shell parsing errors. Replace <your-region> with the region from your Dash0 ingress endpoint, and <your-auth-token> with an auth token from your Dash0 organisation. Both can be found in Dash0 under Settings.

1. Add the Helm repo and install the operator (terminal 3)

helm repo add dash0-operator https://dash0hq.github.io/dash0-operator
helm repo update dash0-operator
helm install dash0-operator dash0-operator/dash0-operator --namespace dash0-system --create-namespace --set operator.dash0Export.endpoint=ingress.<your-region>.dash0.com:4317 --set operator.dash0Export.token=<your-auth-token>

2. Verify the operator is running

kubectl get pods -n dash0-system

Wait until the operator pod shows Running.

Further Reading:

Part 6: Configure the Operator

Installing the Helm chart alone is not sufficient. The operator also needs a Dash0OperatorConfiguration resource to know where to send telemetry, and a Dash0Monitoring resource to know which namespace to instrument. Without both of these, no data will flow to Dash0.

1. Create the operator configuration resource

cat <<EOF | kubectl apply -f -
apiVersion: operator.dash0.com/v1alpha1
kind: Dash0OperatorConfiguration
metadata:
  name: dash0-operator-configuration
spec:
  export:
    dash0:
      endpoint: ingress.<your-region>.dash0.com:4317
      authorization:
        token: <your-auth-token>
EOF

2. Enable monitoring for the namespace. This is the resource that switches on instrumentation for all workloads in the default namespace. The export configuration must be included directly in the resource.

cat <<EOF | kubectl apply -f -
apiVersion: operator.dash0.com/v1alpha1
kind: Dash0Monitoring
metadata:
  name: dash0-monitoring
  namespace: default
spec:
  export:
    dash0:
      endpoint: ingress.<your-region>.dash0.com:4317
      authorization:
        token: <your-auth-token>
EOF

Further Reading:

Part 7: Restart and Verify

The operator injects instrumentation at pod startup via an init container. Because the pod was already running before the monitoring resource was created, it needs to be restarted so the operator can instrument it.

1. Restart the deployment

kubectl rollout restart deployment/order-service
kubectl get pods

Wait until the new pod shows Running.

2. Restart the port-forward (terminal 1). Kill the existing port-forward with Ctrl+C and restart it:

kubectl port-forward svc/order-service 8080:80

The curl loop in terminal 2 will resume automatically.

3. Open Dash0. Go to app.dash0.com. With the instrumented pod running and traffic flowing, telemetry will begin appearing within a minute or two. No changes were made to the application code, the pom.xml, or the Docker image. The only things added were the Dash0 operator and two Kubernetes manifests.

Check the following:

Monitoring → Services — order-service with live request rate, error rate, and latency

Telemetry → Tracing — individual traces for each /orders request

Telemetry → Logging — structured logs

Monitoring → Resources — pod and node resource usage

Further Reading:

The post From Zero to Full Observability with Dash0 appeared first on foojay.

]]> https://foojay.io/today/from-zero-to-full-observability-with-dash0/feed/ 0 Announcing: Sustainability for Java Developers — A New Collaborative Guide from the Foojay.io Community https://foojay.io/today/announcing-sustainability-for-java-developers-a-new-collaborative-guide-from-the-foojay-io-community/ https://foojay.io/today/announcing-sustainability-for-java-developers-a-new-collaborative-guide-from-the-foojay-io-community/#respond Mon, 02 Feb 2026 11:04:54 +0000 https://foojay.io/?p=122568 Java developers from around the world are writing a book about a question that's becoming impossible to ignore: how do we write software that's good for both our projects and the planet? Sustainability for Java Developers: Towards an Understanding of ...

The post Announcing: Sustainability for Java Developers — A New Collaborative Guide from the Foojay.io Community appeared first on foojay.

]]> Java developers from around the world are writing a book about a question that's becoming impossible to ignore: how do we write software that's good for both our projects and the planet?

Sustainability for Java Developers: Towards an Understanding of Sustainable Java Software Development is now freely available on Leanpub, bringing together Java Champions, architects, and technical writers to look at sustainability from every angle.

The book covers everything from the environmental footprint of our data centers to the ethics of open source supply chains, from efficient data formats to the often-overlooked topic of career longevity.

The current chapters (because the book continues to grow and everyone is invited to participate) are:

  • Chapter 1: Fair Trade Software — Maarten Mulders and Geertjan Wielenga
  • Chapter 2: Stopping the Data Madness — Frank Delporte
  • Chapter 3: Impact of Architecture — Simon Martinelli and Jan Ouwens
  • Chapter 4: Career and Wellbeing — Markus Westergren
  • Chapter 5: Sustaining Success: Java's Evergreen Appeal in a Rapidly Changing Tech Landscape — A N M Bazlur Rahman
  • Chapter 6: Simple Things You Can Do Right Now — Jan Ouwens and Ko Turk
  • Chapter 7: Java as a Scripting Language: Sustainable Code from Day One — A N M Bazlur Rahman

You'll find practical advice you can use today—like configuring build caching or using Java 25's scripting features—alongside deeper discussions about mentorship, community, and why sustainable practices actually make business sense.

The project has grown out of the Foojay (Friends of OpenJDK) community, where members from different companies and countries found they shared the same concerns about sustainability.

Because it's published on Leanpub, the book will keep evolving with reader feedback—and others are welcome to join in with their own content.

You can get your copy now at leanpub.com/sustainabilityforjavadevelopers.

The post Announcing: Sustainability for Java Developers — A New Collaborative Guide from the Foojay.io Community appeared first on foojay.

]]> https://foojay.io/today/announcing-sustainability-for-java-developers-a-new-collaborative-guide-from-the-foojay-io-community/feed/ 0 Webinar: “Moving Applications From JDK 21 to JDK 25: What You Need to Know” https://foojay.io/today/webinar-moving-applications-from-jdk-21-to-jdk-25-what-you-need-to-know/ https://foojay.io/today/webinar-moving-applications-from-jdk-21-to-jdk-25-what-you-need-to-know/#respond Mon, 26 Jan 2026 14:14:32 +0000 https://foojay.io/?p=122481 Table of Contents Why Upgrade?Upcoming Webinar: Your Migration Guide JDK 25 has arrived as the latest long-term support (LTS) release for Java, bringing performance improvements and enhanced stability for modern applications. If your organization is running JDK 21, now is ...

The post Webinar: “Moving Applications From JDK 21 to JDK 25: What You Need to Know” appeared first on foojay.

]]>
Table of Contents
Why Upgrade?Upcoming Webinar: Your Migration Guide

JDK 25 has arrived as the latest long-term support (LTS) release for Java, bringing performance improvements and enhanced stability for modern applications. If your organization is running JDK 21, now is the time to start planning your migration path.

Why Upgrade?

Each new LTS release represents years of refinements, optimizations, and new capabilities. JDK 25 builds on the foundation of JDK 21 while delivering the reliability that enterprise applications demand. But understanding what's changed—and what might break—is essential for a smooth transition.

Upcoming Webinar: Your Migration Guide

Azul is hosting a live session, led by Java Champion Simon Ritter, covering everything you need to know about moving from JDK 21 to JDK 25. The webinar will cover key differences between the two releases, new features and compatibility considerations, and best practices for a seamless migration.

Attendees will also see a live demo of an example application migration, along with alternative approaches for upgrading to Azul's Zulu build of JDK 25.

Session Times:

  • NAM: January 27th at 10:00 AM PT / 1:00 PM ET
  • EMEA: January 27th at 12:00 PM UTC
  • APAC: January 28th at 12:00 PM SGT

Whether you're just starting to evaluate JDK 25 or ready to begin your upgrade, this session will provide practical guidance to help you move forward with confidence.

Register for the webinar to secure your spot.

The post Webinar: “Moving Applications From JDK 21 to JDK 25: What You Need to Know” appeared first on foojay.

]]> https://foojay.io/today/webinar-moving-applications-from-jdk-21-to-jdk-25-what-you-need-to-know/feed/ 0 Super Early Bird Tickets: Voxxed Days Amsterdam https://foojay.io/today/super-early-bird-tickets-voxxed-days-amsterdam/ https://foojay.io/today/super-early-bird-tickets-voxxed-days-amsterdam/#respond Mon, 06 Oct 2025 12:37:44 +0000 https://foojay.io/?p=121388 Table of Contents Speaker Line-up Tickets & Participation After this year’s success, the Voxxed Amsterdam team is proud to announce that next year will be even bigger, with more speakers, breakouts, sponsors, and attendees. We warmly invite you to join and ...

The post Super Early Bird Tickets: Voxxed Days Amsterdam appeared first on foojay.

]]>
Table of Contents

After this year’s success, the Voxxed Amsterdam team is proud to announce that next year will be even bigger, with more speakers, breakouts, sponsors, and attendees. We warmly invite you to join and meet us at the JUG Square on April 1–2, 2026 in Amsterdam.

Date: April 1–2, 2026
Location: Pathé Amsterdam (North)
Details & tickets: amsterdam.voxxeddays.com

Speaker Line-up

These industry leaders will be sharing their unique insights at the conference:

  • Alina Yurenko – Developer Advocate for GraalVM / Open Source
  • James Ward – Developer Advocate (former Kotlin Product Lead)
  • Victor Rentea – Clean Coder, Java Champion, Trainer & Technical Coach
  • Holly Cummins – Principal Software Engineer Quarkus
  • Josh Long – Spring Developer Advocate & Java Champion
  • Jeroen Egelmeers – Prompt Engineering Advocate, GenAI Whisperer, Author
  • Venkat Subramaniam – Programmer, Author, Speaker, Professor

Tickets & Participation

Tickets for Voxxed Amsterdam are sold in batches. The first batch of Super Early Bird tickets will go on sale on October 8, 2026 at 09:30 CET. Please note: availability is limited (first come, first served).

📣 What’s coming up next – Get Involved!

  • Call for Papers (CFP): Opening October 8 at Devoxx Belgium. Submit your talk and share your knowledge with the community! Apply here => https://vdams26.cfp.dev/#/login
  • Community Reviewers: Help shape the conference program by reviewing talks and ensuring high-quality content. Apply here => https://tinyurl.com/vdams26

For Companies: Planning to buy 10+ tickets? Share this link with your manager and register via => https://tinyurl.com/Tickets-VDA-2026

The post Super Early Bird Tickets: Voxxed Days Amsterdam appeared first on foojay.

]]> https://foojay.io/today/super-early-bird-tickets-voxxed-days-amsterdam/feed/ 0 Take the State of Java 2025 Survey https://foojay.io/today/take-the-state-of-java-2025-survey/ https://foojay.io/today/take-the-state-of-java-2025-survey/#respond Mon, 06 Oct 2025 12:23:17 +0000 https://foojay.io/?p=121351 Do you want to know which Java JDK distribution is used where for what and when? The time has come again to take the State of Java Survey and share insights while gaining Java ecosystem knowledge. All those participating will ...

The post Take the State of Java 2025 Survey appeared first on foojay.

]]> Do you want to know which Java JDK distribution is used where for what and when? The time has come again to take the State of Java Survey and share insights while gaining Java ecosystem knowledge.

All those participating will get the complete research, which can be of great benefit in your technology choices in the Java ecosystem.

Click the image below to get started:

Or simply click this link:

https://survey.alchemer.com/s3/8466906/Azul-State-of-Java-Survey

The post Take the State of Java 2025 Survey appeared first on foojay.

]]> https://foojay.io/today/take-the-state-of-java-2025-survey/feed/ 0 Ai4Devs Amsterdam: Successful Inaugural Developer-Focused AI Conference https://foojay.io/today/ai4devs-amsterdam-successful-inaugural-developer-focused-ai-conference/ https://foojay.io/today/ai4devs-amsterdam-successful-inaugural-developer-focused-ai-conference/#respond Fri, 03 Oct 2025 09:37:43 +0000 https://foojay.io/?p=121373 Table of Contents 50% Live Coding The inaugural AI4Devs conference in Amsterdam, held recently Friday 19 September, a collaboration between Java Champion Jonathan Vila, local developer agency IO Digital (in particular Joost Kaan, Arno Koehler, and Michel Blankenstein), and the Friends of OpenJDK ...

The post Ai4Devs Amsterdam: Successful Inaugural Developer-Focused AI Conference appeared first on foojay.

]]>
Table of Contents
50% Live Coding

The inaugural AI4Devs conference in Amsterdam, held recently Friday 19 September, a collaboration between Java Champion Jonathan Vila, local developer agency IO Digital (in particular Joost Kaan, Arno Koehler, and Michel Blankenstein), and the Friends of OpenJDK (Foojay.io), proved to be a resounding success, bringing together approximately 200 developers at Amsterdam's iO Digital Campus.

ING, Azul, Qodo, and ContentStack

Co-sponsored and co-organized with ING and Azul, together with Qodo and ContentStack, the event featured standout keynote sessions from Josh Long, of SpringBoot fame, and Pratik Patel, from Azul, who delivered insights on AI in the context of Spring and on increasing the speed of Java-based applications, especially in the context of AI-oriented applications.

However, AiDevs had as much love for frontend as for backend developers, with multiple parallel tracks, dedicated in particular to Java, JavaScript, and Python, together with a dedicated workshop track that ran throughout the day.

50% Live Coding

The conference fulfilled its mission to "share practical, usable knowledge with real use cases and code," targeting developers working with AI technologies at every level. True to its promise of being code-first, the event delivered talks with 50% live coding demonstrations across the full range of technologies.

The full-day event featured in-depth technical sessions, real-world AI implementation examples, hands-on workshops, and extensive networking opportunities. Attendees enjoyed comprehensive catering including lunch, refreshments, and a closing networking reception.

Strong Developer-Centric Foundation

With its laser-focused, developer-centric approach and intimate setting, AI4Devs Amsterdam successfully established itself as a premier destination for practical AI knowledge.

The inaugural event sets a strong foundation for future editions, demonstrating clear demand for technical, code-heavy AI conferences in the European market and beyond.

And the speaker dinner was one to be remembered!

The post Ai4Devs Amsterdam: Successful Inaugural Developer-Focused AI Conference appeared first on foojay.

]]> https://foojay.io/today/ai4devs-amsterdam-successful-inaugural-developer-focused-ai-conference/feed/ 0 CodeRabbit Tutorial for Java Developers https://foojay.io/today/coderabbit-tutorial-for-java-developers/ https://foojay.io/today/coderabbit-tutorial-for-java-developers/#respond Mon, 28 Jul 2025 12:43:19 +0000 https://foojay.io/?p=116972 Table of Contents Getting Started Prerequisites Setup Process Core Features for Java Development 1. Code Quality Analysis 2. Security Vulnerability Detection 3. Performance Optimization Suggestions 4. Design Pattern Recognition Working with CodeRabbit Reviews Understanding Review Comments Responding to Reviews Java-Specific ...

The post CodeRabbit Tutorial for Java Developers appeared first on foojay.

]]>

Table of Contents
Getting Started

Core Features for Java Development

Working with CodeRabbit Reviews

Java-Specific Configuration

Advanced Features

Best Practices

Common Java Patterns CodeRabbit Recognizes

Troubleshooting Common Issues

Integration with Development Tools

Measuring Success

ConclusionNext Steps


CodeRabbit is an AI-powered code review tool that integrates seamlessly with your Git workflow to provide intelligent, automated code reviews.

For Java developers, CodeRabbit offers specialized analysis that understands Java syntax, best practices, and common patterns.

Getting Started

Prerequisites

  • A GitHub, GitLab, Azure DevOps, or Bitbucket repository.
  • Java project with standard structure (Maven or Gradle).
  • Admin access to your repository.

Setup Process

  1. Install CodeRabbit
    • Visit CodeRabbit.ai.
    • Sign up using your credentials, while noting that CodeRabbit is free for OSS, supports GitHub, GitLab, Azure DevOps, and Bitbucket.
    • Grant necessary permissions to your repositories.
  2. Repository Configuration
    • Select the Java repositories you want CodeRabbit to review.
    • CodeRabbit automatically detects Java projects and configures appropriate rules.
  3. Initial Setup Verification
    • Create a test pull request with a simple Java change.
    • Verify CodeRabbit comments appear within minutes.

Core Features for Java Development

1. Code Quality Analysis

CodeRabbit analyzes your Java code for:

Style and Formatting

// CodeRabbit will suggest improvements for:
public class DemoApplication{  // Missing space before {
    private String userName;
    
    public void setUserName(String userName){  // Parameter naming
        this.userName = userName;
    }
}

For example, when you ask CodeRabbit to check the style above, you'll get a response comparable to this:

Best Practices

  • Proper exception handling
  • Resource management (try-with-resources)
  • Null safety checks
  • Performance optimizations

2. Security Vulnerability Detection

CodeRabbit identifies common Java security issues:

// CodeRabbit will flag potential security risks:
public void unsafeMethod(String userInput) {
    // SQL injection vulnerability
    String query = "SELECT * FROM users WHERE name = '" + userInput + "'";
    
    // Potential XSS vulnerability
    response.getWriter().println(userInput);
}

The above is analyzed in several ways, including this, by CodeRabbit:

3. Performance Optimization Suggestions

// CodeRabbit suggests improvements:
// Original code
List<String> items = new ArrayList<>();
for (User user : users) {
    items.add(user.getName());
}

// CodeRabbit might suggest:
List<String> items = users.stream()
    .map(User::getName)
    .collect(Collectors.toList());

4. Design Pattern Recognition

CodeRabbit understands common Java patterns and suggests improvements:

// Suggests Singleton pattern improvements
public class DatabaseConnection {
    private static DatabaseConnection instance;
    
    // CodeRabbit might suggest thread-safe implementation
    public static synchronized DatabaseConnection getInstance() {
        if (instance == null) {
            instance = new DatabaseConnection();
        }
        return instance;
    }
}

Working with CodeRabbit Reviews

Understanding Review Comments

CodeRabbit provides three types of feedback:

  1. Suggestions: Improvements for code quality
  2. Issues: Potential bugs or problems
  3. Nitpicks: Minor style or convention issues

Responding to Reviews

Accepting Suggestions

  • Click "Apply suggestion" for auto-fixable issues
  • CodeRabbit can automatically commit simple fixes

Discussing Feedback

  • Reply to comments to provide context
  • Use @coderabbitai to ask follow-up questions in the code review comments
  • Example: @coderabbitai Why is this approach better for performance?

Resolving Comments

  • Address the feedback in your code
  • CodeRabbit automatically detects resolved issues in subsequent commits

Java-Specific Configuration

Custom Rules Setup

Create a .coderabbit.yaml file in your repository root:

reviews:
  auto_review:
    enabled: true
    
path_filters:
  include:
    - "src/**/*.java"
    - "pom.xml"
  exclude:
    - "target/**"

rules:
  - security_issues
  - bugs
  - code_quality
  - best_practices

Maven/Gradle Integration

CodeRabbit automatically understands your build configuration:

  • Analyzes pom.xml or build.gradle for dependencies
  • Suggests dependency updates
  • Identifies unused dependencies
  • Checks for security vulnerabilities in dependencies

Advanced Features

1. Custom Prompts

Ask CodeRabbit specific questions about your Java code:

@coderabbitai Can you suggest a more efficient way to implement this caching mechanism?

2. Architectural Reviews

CodeRabbit can analyze larger structural changes:

@coderabbitai Please review the overall architecture of this new service layer

3. Testing Suggestions

CodeRabbit helps improve your test coverage:

@Test
public void testUserCreation() {
    User user = new User("John");
    assertEquals("John", user.getName());
}

// CodeRabbit might suggest:
// - Additional edge case tests
// - Mock object usage
// - Test naming improvements

Best Practices

1. Preparing Your Code for Review

Before Creating a PR:

  • Run local tests and static analysis
  • Follow your team's coding standards
  • Write meaningful commit messages
  • Keep PRs focused and reasonably sized

2. Maximizing CodeRabbit's Effectiveness

Provide Context:

  • Write descriptive PR descriptions
  • Include relevant issue numbers
  • Explain complex business logic in comments

Iterative Improvement:

  • Address CodeRabbit feedback promptly
  • Use follow-up commits for fixes
  • Learn from repeated suggestions

3. Team Collaboration

Code Review Workflow:

  1. Developer creates PR
  2. CodeRabbit provides an initial review
  3. Team members add a human perspective
  4. Address all feedback before merging

Common Java Patterns CodeRabbit Recognizes

1. Spring Framework

// CodeRabbit understands Spring annotations and suggests improvements
@RestController
@RequestMapping("/api/users")
public class UserController {
    
    @Autowired
    private UserService userService;  // Might suggest constructor injection
    
    @GetMapping("/{id}")
    public ResponseEntity<User> getUser(@PathVariable Long id) {
        // CodeRabbit checks for proper error handling
        return ResponseEntity.ok(userService.findById(id));
    }
}

2. JPA/Hibernate

// CodeRabbit provides database-related suggestions
@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false)
    private String email;  // Might suggest unique constraint
    
    // CodeRabbit checks for proper equals/hashCode implementation
}

3. Stream API Usage

// CodeRabbit optimizes stream operations
List<String> result = users.stream()
    .filter(user -> user.getAge() > 18)
    .map(User::getName)
    .collect(Collectors.toList());  // Might suggest toUnmodifiableList()

Troubleshooting Common Issues

1. Review Not Triggering

  • Check repository permissions
  • Verify CodeRabbit is installed on the repository
  • Ensure PR meets minimum criteria (not draft, has changes)

2. False Positives

  • Use @coderabbitai ignore to dismiss incorrect suggestions
  • Provide feedback to improve future reviews
  • Add explanatory comments for complex logic

3. Performance Issues

  • Large PRs may take longer to review
  • Consider splitting large changes into smaller PRs
  • Use path filters to exclude generated files

Integration with Development Tools

IDE Integration

  • CodeRabbit works with any IDE through Git
  • Comments appear directly in your Git provider's interface
  • No additional IDE plugins required

CI/CD Integration

  • CodeRabbit reviews happen automatically on PR creation
  • Can be configured to block merges until issues are resolved
  • Integrates with status checks

Measuring Success

Key Metrics to Track

  • Reduction in post-merge bugs
  • Faster code review cycles
  • Improved code quality scores
  • Team learning and knowledge sharing

Continuous Improvement

  • Regularly review CodeRabbit's suggestions
  • Update the configuration based on team needs
  • Collect team feedback on review quality

Conclusion

CodeRabbit significantly enhances the Java development workflow by providing instant, intelligent code reviews. By understanding its capabilities and following these best practices, your team can enhance code quality, identify issues early, and expedite development cycles.

Remember that CodeRabbit is a tool to augment, not replace, human code review. The combination of AI-powered analysis and human expertise creates the most effective code review process.

Next Steps

  1. Set up CodeRabbit on a small Java project
  2. Experiment with different configuration options
  3. Gradually roll out to larger projects
  4. Collect team feedback and iterate on your process
  5. Explore advanced features as your team becomes comfortable with the basics

For more detailed documentation and updates, visit the CodeRabbit documentation.

The post CodeRabbit Tutorial for Java Developers appeared first on foojay.

]]> https://foojay.io/today/coderabbit-tutorial-for-java-developers/feed/ 0 Foojay Podcast #76: DevBcn Report, Part 1 – Learn from the Community https://foojay.io/today/foojay-podcast-76/ https://foojay.io/today/foojay-podcast-76/#respond Mon, 21 Jul 2025 06:41:00 +0000 https://foojay.io/?p=116880 Table of Contents VideoPodcast AppsContent In early July, the DevBcn conference in Barcelona featured a diverse lineup of speakers, covering topics across multiple technology domains. Geertjan Wielenga took the camera and microphone with him to Spain. Together with Nacho Cougil ...

The post Foojay Podcast #76: DevBcn Report, Part 1 – Learn from the Community appeared first on foojay.

]]>
Table of Contents
VideoPodcast AppsContent

In early July, the DevBcn conference in Barcelona featured a diverse lineup of speakers, covering topics across multiple technology domains. Geertjan Wielenga took the camera and microphone with him to Spain. Together with Nacho Cougil and Jonathan Vila, two of the organizers, he spoke with many visitors about what they like most in Java, how AI influences their work, and what is important to them in the work they do.

We have more than 20 people who are passionate about the Java community and are eager to share their knowledge with you.

Video

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Content

00:00 Introduction
00:45 Nacho Cougil and Jakub Marchwicki talk about the history of the DevBcn conference.
https://www.linkedin.com/in/icougil
https://www.linkedin.com/in/kubamarchwicki
02:45 Bert Jan Schrijver is excited about the people in the Java community.
https://www.linkedin.com/in/bjschrijver/
03:06 Ricardo Romero Benítez has a Spanish YouTube challenge about Java and is surprised by the experience of junior developers.
https://www.linkedin.com/in/ricardo-romero-ben%C3%ADtez-b4a4048a/
https://www.youtube.com/@programando_en_java
05:43 Christoph Neumann discusses closure and a database created using it.
https://www.linkedin.com/in/christoph-neumann-6089438/
08:03 Victor Rentea gives Java workshops about architecture, performance, maintainable code, etc.
https://www.linkedin.com/in/victor-rentea-trainer/
09:46 Justin Reock measures developer productivity and talks about improving the development experience.
https://www.linkedin.com/in/justinreock
17:44 Will Fleury accelerates coding by integrating AI in IDEs and compares different solutions.
https://www.linkedin.com/in/willfleury
23:38 Kamesh Sampath handles big amounts of data for AI and other processing.
https://www.linkedin.com/in/kameshsampath
26:19 Cedric Clyburn shares his experience with Linux and Kubernetes and is fascinated by open-source AI.
https://www.linkedin.com/in/cedricclyburn
28:33 Brian Vermeer helps to make Java applications and AI tools secure.
https://www.linkedin.com/in/brianvermeer
31:53 Andrey Sitnik promotes local-first privacy versus the user-data-selling approach.
https://www.linkedin.com/in/sinik
35:59 Isabel Garrido Cardenas about cognitive load when working with a lot of microservices and the right way of testing with AI.
https://www.linkedin.com/in/isabelgarridocardenas
38:59 Isabella Sohlman is a student, joining the conference to learn how she can grow her career and to meet people from the Java community.
https://www.linkedin.com/in/isabellasohlman
40:13 Ruben Cordeiro shares his experience with volunteering at the conference and what he learned from the talks.
https://www.linkedin.com/in/rubencordeiro
42:36 Horacio Gonzalez about simple to use cloud services by developers for developers.
https://www.linkedin.com/in/horaciogonzalez
44:46 Jonatan Sempere about communication and network APIs to prevent fraud for banking.
https://www.linkedin.com/in/jsempere95
47:36 Luis Majano and Cris Escobar talk about BoxLang, a new dynamic JVM language.
https://www.linkedin.com/in/lmajano
https://www.linkedin.com/in/cristobalescobarh
https://www.boxlang.io
59:42 Miguel Xoel García Balsa about observability and the difference with monitoring.
https://www.linkedin.com/in/miguelxoel
01:03:32 Silvia Bellmunt shares her experience with the Java community, the DevBcn conference, and data science.
https://www.linkedin.com/in/silvia-bellmunt-36220aa3
01:06:15 Rijo Sam talks about framework- agnostic development, using plain Java as much as possible.
https://www.linkedin.com/in/rijosam19
01:09:37 Nacho Cougil and Jonathan Vila invite you to the DevBcn conference next year.
https://www.linkedin.com/in/icougil
https://www.linkedin.com/in/jonathanvila
01:11:33 Outro

The post Foojay Podcast #76: DevBcn Report, Part 1 – Learn from the Community appeared first on foojay.

]]> https://foojay.io/today/foojay-podcast-76/feed/ 0