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:

• Spotify
• Apple Podcasts
• And most others...

Content

00:00 Introduction

02:16 Sharat Chandar

• https://www.linkedin.com/in/sharatchander/
• Java community and history
• What you can learn from conferences and articles

05:37 Markus Westergren

• https://www.linkedin.com/in/markuswestergren/
• https://foojay.io/sustainability-for-java-developers/
• https://foojay.io/today/join-slack-com-t-foojay-signup/
• Book "Sustainability for Java Developers"
• How to "sustain yourself" in this strange-AI-changing-world
• Everyone in the Java community is approachable and wants to help you

09:46 Iryna Dohndorf

• https://www.linkedin.com/in/iryna-dohndorf/
• https://foojay.io/today/author/iryna-dohndorf/
• Mentoring about sustainability as a developer + groundness + robustness skills
• High performance without crushing your soul

13:59 René Schwietzke

• https://www.linkedin.com/in/reneschwietzke/
• https://foojay.io/today/the-curious-case-of-different-runtimes-with-different-training-data-jit/
• Diving deep into the runtime, JITWatch
• About the broad mix of topics handled on Foojay
• Foojay helps connect the Java community with Mastodon
• Writing the best performing pure, safe Java code for the 1B row challenge

18:28 Gerrit Grunwald

• https://www.linkedin.com/in/gerritgrunwald/
• https://foojay.io/today/author/gerrit-grunwald/
• https://foojay.io/today/disco-api-helping-you-to-find-any-openjdk-distribution/
• https://sdkman.io/
• The Disco API, the source with all the available OpenJDK distributions, is used by SDKMAN, Gradle, and many other tools
• About the many distributions that are available, even ones that are mainly (and only) used in Asia
• About bringing opensource projects to Commonhaus to ensure their future

27:45 Catherine Edelveis

• https://foojay.io/today/author/catherine-edelveis/
• https://www.youtube.com/watch?v=Ytdo8OGEYFI
• https://foojay.io/today/which-java-runtime-should-you-use-in-production-comparing-openjdk-distributions/
• Reducing Docker sizes improves security and performance
• Many distributors provide builds of OpenJDK

31:16 Jago de Vreede

• https://foojay.io/today/author/jago-de-vreede/
• About the Java community and the place of Foojay in it. What is good, what are we missing?
• SDKMAN, creating an UI for it, and using the many OpenJDK distributions

35:05 Annelore Egger

• https://www.linkedin.com/in/anneloredev/
• https://foojay.io/?s=egger
• Java community, conference volunteering, mentoring
• How to become a conference speaker
• Learn by teaching

38:03 Buhake Sindi

• https://www.linkedin.com/in/buhake-sindi/
• https://foojay.io/today/author/buhake-sindi/
• https://github.com/langchain4j/langchain4j-cdi
• Jakarta EE, LangChain4J CDI, Agent to Agent
• Impact of AI on developer life and sustainability
• Get in touch with your "Java Rockstars"!

44:03 François Martin

• https://www.linkedin.com/in/fran%C3%A7oismartin/
• https://foojay.io/today/author/francois-martin/
• https://foojay.io/today/eliminating-flaky-tests-to-end-world-hunger/
• https://foojay.io/today/five-ways-to-use-gradle-enterprise-to-identify-and-manage-flaky-tests/
• Learn from mentoring, for example, how to earn from opensource
• Foojay author, just published an article about Flaky tests
• Learn from writing and reading

48:18 Dominika Tasarz-Sochacka

• https://www.linkedin.com/in/dominikatasarz/
• https://foojay.io/today/author/dominika-tasarz/
• https://foojay.io/today/join-slack-com-t-foojay-signup/
• https://foojay.io/today/how-to-submit-your-next-article-on-foojay-io/
• The future of Foojay, how can we get the community even more involved
• What you can learn from the community

51:18 Geertjan Wielenga

• https://www.linkedin.com/in/geertjanwielenga/
• https://education.foojay.social/
• Java communities are everywhere
• How Foojay started and grew
• How can contributing to the community influence your career
• Can Foojay connect to universities and other educational initiatives

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.

Docker Init was introduced in Docker Desktop 4.27, before LLMs became the default answer to everything. It’s a "smart" interactive wizard that analyzes your project and generates:

• A Dockerfile (multi-stage, production-ready)

• A compose.yaml file

• A .dockerignore file

• A README.Docker.md with build and run instructions

What makes it valuable is that it’s deterministic—not a probabilistic guess. It produces the same correct output every time, following Docker’s own best practices.

Technical Requirements

• Docker Desktop 4.27 or later

Create a New Project

I’m using a Spring Boot project. Because it’s early Spring now and I haven’t touched one in a while—so let’s go.

Head to https://start.spring.io/ and create a project with:

• Project: Maven

• Language: Java

• Spring Boot: 4.0.5 (or whatever the latest stable is)

• Packaging: Jar

• Java: 26

I used these coordinates, but pick your own:

• Group: io.dockersecurity

• Artifact: hello-wowlrd

• Package Name: io.dockersecurity.hello-wowlrd

Download, unzip, and step into the directory:

cd hello-wowlrd

Run Docker Init

As my British friend say, "It’s Docker, innit?"

docker init

The interactive wizard detects your Java project automatically. Accept "Java", confirm the source directory and Java version, and enter the port:

? What application platform does your project use? Java
? What's the relative directory (with a leading .) for your app? ./src
? What version of Java do you want to use? 26
? What port does your server listen on? 8080

Docker Init generates four files. The one that matters most is the Dockerfile:

# syntax=docker/dockerfile:1

################################################################################
# Stage 1: resolve and download dependencies
FROM eclipse-temurin:26-jdk-jammy as deps

WORKDIR /build

COPY --chmod=0755 mvnw mvnw
COPY .mvn/ .mvn/

RUN --mount=type=bind,source=pom.xml,target=pom.xml \
    --mount=type=cache,target=/root/.m2 ./mvnw dependency:go-offline -DskipTests

################################################################################
# Stage 2: build the application
FROM deps as package

WORKDIR /build

COPY ./src src/
RUN --mount=type=bind,source=pom.xml,target=pom.xml \
    --mount=type=cache,target=/root/.m2 \
    ./mvnw package -DskipTests && \
    mv target/$(./mvnw help:evaluate -Dexpression=project.artifactId -q -DforceStdout)-$(./mvnw help:evaluate -Dexpression=project.version -q -DforceStdout).jar target/app.jar

################################################################################
# Stage 3: extract Spring Boot layers
FROM package as extract

WORKDIR /build

RUN java -Djarmode=layertools -jar target/app.jar extract --destination target/extracted

################################################################################
# Stage 4: minimal runtime image
FROM eclipse-temurin:26-jre-jammy AS final

ARG UID=10001
RUN adduser \
    --disabled-password \
    --gecos "" \
    --home "/nonexistent" \
    --shell "/sbin/nologin" \
    --no-create-home \
    --uid "${UID}" \
    appuser
USER appuser

COPY --from=extract build/target/extracted/dependencies/ ./
COPY --from=extract build/target/extracted/spring-boot-loader/ ./
COPY --from=extract build/target/extracted/snapshot-dependencies/ ./
COPY --from=extract build/target/extracted/application/ ./

EXPOSE 8080

ENTRYPOINT [ "java", "org.springframework.boot.loader.launch.JarLauncher" ]

This is already a proper multi-stage build: separate stages for dependency resolution, compilation, layer extraction, and a minimal runtime image with a non-root user. Gord would approve.

A Note on Java 26 Base Images

The generated Dockerfile references eclipse-temurin:26-jdk-jammy and eclipse-temurin:26-jre-jammy. Since Java 26 was just released, these Eclipse Temurin images may not be fully available on Docker Hub yet.

Swap them out for SAP Machine images instead—SAP’s free OpenJDK distribution ships Java 26 on Ubuntu 24.04 (Noble Numbat):

• sapmachine:26-jdk-ubuntu-noble

• sapmachine:26-jre-ubuntu-noble

Find them on Docker Hub: https://hub.docker.com/_/sapmachine. Just replace eclipse-temurin with sapmachine in both FROM lines.

Build and Run

docker compose up --build

The generated compose.yaml is minimal:

services:
  server:
    build:
      context: .
    ports:
      - 8080:8080

The application starts, and immediately stops with exit code 0. That’s expected: there’s no HTTP endpoint to keep it alive.

Add a Controller

Create src/main/java/io/dockersecurity/hellowowlrd/HelloController.java:

package io.dockersecurity.hellowowlrd;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @GetMapping("/")
    public String hello() {
        return "Hello, Docker Security!";
    }
}

Add the Spring Web dependency to pom.xml:

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

Build and run again:

docker compose up --build

Verify:

curl http://localhost:8080
# Hello, Docker Security!

More Links

Docker Init supports more than Java. If you want to try it with other languages, Docker’s official guides are the place to start: https://docs.docker.com/guides/.

I co-authored the C++ guide—Docker thanked me for it at the top of the page, which means I wrote those words and then thanked myself on their behalf. Worth a read:

• https://docs.docker.com/guides/cpp/

Conclusion

Java 26 just shipped and Docker Init handles it cleanly out of the box—multi-stage build, layer extraction, non-root user, bind mounts for caching. You get a production-ready Dockerfile in under a minute. When Eclipse Temurin catches up, swap the base images back. Until then, SAP Machine has you covered.

If you want to learn about more Docker Commandos (or commands) head to: https://dockersecurity.io/commandos.

The post Dockerizing a Java 26 Project with Docker Init appeared first on foojay.

A few weeks ago, Igor De Souza shared Bringing Java Closer to Education: A Community-Driven Initiative here on Foojay. It's something we started together to gather Java educational resources in one place, making it easier for mentors, educators, and learners to discover what's out there.

But let's be honest: a GitHub README, while perfectly functional, is not exactly the most inviting front door for educators who aren't already deep in the coding ecosystem. That's now fixed...

Inspired by a Great Idea from James Ward

If you haven't visited ai4jvm.com yet, go have a look. James Ward, Java Champion and Developer Advocate, built a beautifully clean, community-curated website listing Java AI frameworks, tools, key people, and learning resources. It's an excellent reference and a great example of what a well-structured catalog site can look like.

James agreed to let us reuse his workflow. It's a setup that takes a structured SPEC.md document and turns it into a proper, browsable website. A huge thank you to him for being so open about sharing that approach!

Meet education.foojay.social

The result is now live at education.foojay.social! If you're a coding club mentor or a teacher looking for Java resources to point students to, this is where to start.

What's already in the catalog? A mix of things:

• Tutorials and videos by Jetbrains and others
• Resources shared by Devoxx4Kids
• Pi4J and JBang examples for getting Java running on a Raspberry Pi
• Books like "Raising Young Coders"

The Catalog Is Only as Good as the Community Makes It

The whole point of this initiative is that it's not owned by any single person or organization. The GitHub repository at github.com/foojayio/java-education-catalog is the source of truth, and the website is generated directly from it.

That means contributing is as simple as opening a pull request to update SPEC.md with a new resource. Found a great Java tutorial series on YouTube? A book you'd recommend to beginners? A creative project idea that works well in a classroom or coding club? Add it.

If you've been creating Java educational content and it's currently sitting on the internet with little visibility, this is exactly where it should be listed. Let's make sure your content gets found more easily.

What's Next

The goal remains the same as when this initiative started: make Java more visible and accessible in educational environments, from CoderDojo clubs to university courses to self-learners picking up their first programming language. A well-maintained, community-driven catalog site gets us closer to that.

Go visit education.foojay.social, explore what's there, and then come back to the GitHub repository and add something. Every contribution matters, and this one really is as easy as editing a text file.

The post The Java in Education Catalog Now Has a Beautiful Home appeared first on foojay.

Azul recently announced that Azul Zulu Builds of OpenJDK are now available as Docker Official images on Docker Hub. That means you can pull TCK‑verified, fully compliant OpenJDK builds directly from the same Official Images library you already trust for your base OS and databases.

You can browse and pull the images here:
https://hub.docker.com/_/azul-zulu

Why should you care about official images?

With the official Docker images you get:

• Verified cryptographic signing using Azul’s GPG key, so you can validate what your CI pulls.
• Automatic rebuilds whenever upstream base images are patched, so CVEs are addressed without you manually rebuilding everything.
• Fully open‑source licensing (GPL v2 with Classpath Exception plus relevant OpenJDK licenses).
• Images built and maintained to Docker’s security and maintenance standards, rather than ad‑hoc community images.

This is especially useful if you are:

• Standardizing Java base images across multiple services.

• Locking down a software supply chain (SBOMs, signing, provenance).

• Reducing the noise from ad‑hoc “java:latest” images in different teams.

Which versions and variants can you use?

The Azul Zulu Official Images cover multiple Java releases, including the key LTS versions many teams already rely on:

• Java 8
• Java 11
• Java 17
• Java 21
• Java 25

Each version comes with:

• -jdk, -jre, and -headless variants per major version.
• -debian and -debian13 suffix tags so you can pin the base image.

Example tags include:

• azul-zulu:17-jdk-debian
• azul-zulu:21-jre-headless-debian13

This is just the start - more tags and base images are planned. As new Java releases and additional base images are introduced, they are expected to show up under the same Official Images namespace so you can keep a consistent pattern across services.

Where to start?

Getting the images into your workflow should be straightforward if you already use Docker for Java.

Basic steps:

1. Go to the Official Images page: https://hub.docker.com/_/azul-zulu.

2. Pick the Java version and variant that matches your service (e.g. 17-jdk-debian13).

3. Pull it locally:

docker pull azul-zulu:17-jdk-debian13

4. Use it in your Dockerfile:

FROM azul-zulu:17-jdk-debian13

WORKDIR /app
COPY target/app.jar app.jar
CMD ["java", "-jar", "app.jar"]

5. Wire it into your CI/CD templates so all new services share the same trusted base.

For more details, Dockerfiles and tag information, check the GitHub repo.

What’s next and how to stay involved?

This is just the beginning, here's what's coming next:

• Additional Java releases (including future STS and LTS versions) under the same Official Images namespace.

• More base images over time, so you can choose the footprint and OS family that fits your stack.

• Continued automatic rebuilds and security updates to keep your containers current with minimal noise.

Azul Zulu OpenJDK Official Images are designed to make running Java in containers as straightforward and trustworthy as possible. By standardizing on these images, you get a consistent, signed and actively maintained base that fits naturally into modern CI/CD workflows.

Download from Docker Hub

The post Official Azul Zulu OpenJDK Images Now Available on Docker Hub! appeared first on foojay.

Happy 30th Anniversary to Pokémon! 🎉

February 27, 2026 marks exactly 30 years since the original Pokémon Red and Green launched in Japan on February 27, 1996. From catching your first Pokémon in Pallet Town to becoming Champion in the Indigo League, the franchise has spent three decades teaching millions of players about strategy, friendship, exploration, and constant improvement, evolving creatures, teams, and even entire generations of games.

Pokémon is literally all about evolution and that same spirit of evolution perfectly matches what’s happening in Java right now.

For a long time, people said Java was “too verbose”, too much boilerplate, too many lines just to do simple things. Writing a basic class, a main method, getters/setters, and handling nulls felt like carrying around a heavy backpack full of unnecessary items.

But Java 25 (released September 2025) is like a Pokémon finally hitting level 100 and evolving into its most powerful form. The language has shed tons of boilerplate, gained concise new syntax, and become much friendlier for beginners and quick prototyping, all while keeping its legendary strength for big enterprise systems.

Here’s how Java 25 turns the “verbose” criticism into a thing of the past, just like how Pokémon keeps reinventing itself every generation.

Java 25 – Compact Source Files and Instance Main Methods (JEP 512)

https://openjdk.org/jeps/512

The static methods that were initially available in java.io.IO (such as println, etc.) have now been relocated to java.lang.IO. Since java.lang is automatically imported by default, this shift makes them easier to use overall.

These functions now rely on System.out and System.in instead of the Console API. That said, in compact source files, the IO class's static methods aren't brought in automatically anymore, so you'll need to qualify calls with the class name explicitly.

Compact source files gain automatic entry to every public class and interface in the java.base module (essentially performing an import module java.base;).

Java 25 – Flexible Constructor Bodies (JEP 513)

https://openjdk.org/jeps/513

A key element here is constructor chaining: when a class inherits from a superclass, Java makes sure the superclass constructor executes prior to any logic in the subclass constructor. This step-by-step process ensures objects are assembled progressively from the base of the inheritance tree upward.

The enhancement addresses limitations by permitting specific statements to come before super() or this() invocations, which results in more flexible and clearer constructors.

Keep in mind this isn't a complete rundown, I highly recommend checking out the links and experimenting with some samples yourself to fully appreciate the advantages.

30 Years of Pokémon. Decades of Java Evolution.

Just like how Pokémon keeps evolving its games to stay fresh and fun for 30 years, Java keeps evolving so that you can have fun coding right away, whether you're building a Pokédex app, a tiny game, or controlling LEDs on a Raspberry Pi.

The old “Java is verbose” days are over.

The new generation is here, and it’s ready to catch every idea, build every project, and win every battle.

So the next time someone says: “Java is too verbose.”, you can answer: That was first-generation Java. We’re in Generation 25 now.

Which Java 25 feature would you use first to build your dream Pokédex or Pokémon battle simulator?

Drop it in the comments — let’s evolve our code together!
Gotta code 'em all!

LinksLinks

https://dev.to/igoriot/stop-saying-java-is-verbose-127i

The post Gotta Code ‘Em All: How Java Evolved Beyond Verbosity – Celebrating 30 Years of Pokémon appeared first on foojay.

In this short, practical talk DIY Technical Marketing, Real World Tips For Building A Successful Developer Brand, delivered at Jfokus 2026 conference, Payara Community Manager Dominika Tasarz-Sochacka explores why personal branding matters for developers and how even small, intentional actions can make a real difference over time.

Drawing on real world examples from years of working with Java developers, the session focuses on three core ideas:

• understanding the value of personal branding in the tech industry
• identifying what makes you unique and how to communicate it clearly
• taking simple first steps to build visibility without turning it into a full time job

This talk is designed to be approachable and realistic, especially for developers who want to focus on building great software while still investing in their long term career growth.

The post Watch the Recording: DIY Technical Marketing for Java Developers appeared first on foojay.

Over the past decades, Java has proven itself to be one of the most reliable, versatile, and widely used programming languages in the world. From enterprise systems to mobile applications and embedded devices, Java continues to evolve and adapt. Yet, one important area still holds enormous untapped potential: education.

This initiative was born from a simple but powerful idea: to aggregate Java-related educational content in a way that helps newcomers get started, supports educators, and encourages new Java initiatives focused on learning. By making Java more accessible and visible in educational environments, we strengthen not only the language itself, but the entire ecosystem around it.

The role of this GitHub repository

The "Java Education Catalog" Foojay GitHub repository represents the starting point of that initiative. The idea emerged from conversations within the Code Club Slack, where educators and community members discussed the lack of visible, accessible Java resources for educational contexts. From those discussions came a simple but meaningful realization: there is already valuable Java educational content available, but it is fragmented and hard to discover.

The repository intentionally starts small and evolves openly, serving as an initial hub to gather, organize, and curate Java-related educational materials in one accessible place. Rather than presenting a finished or centrally defined curriculum, it embraces a community-driven approach—collecting learning paths, project ideas, and practical examples, especially those aligned with Raspberry Pi and physical computing.

As the initiative grows through real usage and contributions, this shared space aims to lower the barrier to entry, reduce duplicated effort, and provide a clear starting point for mentors and learners interested in Java in education, while also helping demonstrate real impact over time.

Why Java in Education Matters

Java offers a unique combination of readability, strong typing, a vast ecosystem, and long-term stability. These characteristics make it an excellent language for teaching core programming concepts such as object-oriented design, concurrency, and software architecture, skills that naturally scale from beginner projects to real-world systems.

However, many educational programs today focus primarily on languages perceived as “simpler” or more fashionable, often overlooking Java’s long-term educational value. This initiative aims to change that by curating learning paths, tutorials, examples, and community-driven resources that lower the barrier to entry and highlight Java’s strengths for learners of all ages.

A Major Milestone: Java in CoderDojo

One of the key milestones of this initiative is to see Java become a natural and visible option within the CoderDojo ecosystem.

CoderDojo, now part of the Raspberry Pi Foundation and merged into Code Club, is one of the most influential global movements for teaching young people how to code. It has empowered millions of learners worldwide through free, community-led programming clubs and high-quality educational experiences.

Having Java strongly represented within CoderDojo would be a game changer:

• It would introduce Java to a new generation of learners early in their journey

• It would give mentors structured, high-quality Java content they can confidently teach

• It would position Java alongside other core technologies commonly used in educational contexts

It is important to clarify that CoderDojo and Code Club are community-led programmes and do not operate with a centrally mandated or officially prescribed curriculum for specific programming languages. There is no formal mechanism through which a language is “officially represented.” Instead, learning materials, project ideas, and educational pathways are created by the community and shared organically. A good example is the CoderDojo Belgium Google Drive which has a big collection of learning materials for different languages, electronics, robots, etc.

This model creates a valuable opportunity. If Java educational content is well designed, accessible, and appropriate for young learners and mentors, it can naturally gain traction within the CoderDojo ecosystem through real usage and community adoption.

Community Content vs. Official Raspberry Pi Foundation Material

It is also important to distinguish between community-created content and the educational resources officially developed by the Raspberry Pi Foundation within the Code Club Paths. Materials commonly associated with Raspberry Pi education, such as Python or Scratch, are developed or commissioned internally by the Foundation’s education charity, based on specific learning goals, age ranges, and strategic priorities.

There is currently no open submission pipeline for new programming languages to become part of this official curriculum. For this reason, the most effective path for Java today is not formal inclusion, but the creation of high-quality, independently published educational resources that can be shared through community channels and adopted organically by mentors and learners.

Strong community adoption can, over time, help demonstrate impact, shift perceptions, and open doors for deeper collaboration in the future.

Impact on Raspberry Pi, Pi4J, and the Java Ecosystem

This initiative has the potential to unlock significant growth for Java on Raspberry Pi. With Java more visible and accessible in educational contexts, we would naturally see:

• Increased adoption of Java on Raspberry Pi devices
• Stronger visibility and usage of projects like Pi4J, which bridges Java and Raspberry Pi hardware
• More educational libraries, examples, and tooling focused on embedded and physical computing with Java

In the long term, this creates a powerful positive feedback loop: more learners lead to more contributors, more projects, and a healthier, more innovative Java ecosystem.

The Challenge with the Raspberry Pi Foundation

At present, the Raspberry Pi Foundation has not fully embraced Java as an official programming option within its educational programs. There appears to be a degree of hesitation when it comes to adopting or promoting Java alongside other supported languages.

This initiative exists precisely to help change that perception, not through confrontation, but through demonstration. By showcasing real educational content, strong community engagement, and practical results, the goal is to highlight Java’s value in learning environments and help build a compelling case for its inclusion in the broader educational ecosystem.

Connecting Existing Content Creators

Another important aspect of this initiative is recognizing that many people are already creating high-quality Java educational content around the world. Educators, developers, mentors, and enthusiasts are writing tutorials, recording videos, building sample projects, and sharing their knowledge independently.

This initiative helps connect these efforts by creating a stronger network where ideas, materials, and experiences can be shared. By bringing contributors together, we increase visibility, reduce duplicated effort, and significantly accelerate progress—allowing the community to achieve far greater impact together than any individual effort alone.

A Call to the Community

This initiative is not about a single organization or platform. It is about the community, educators, developers, mentors, and content creators, coming together to make Java more approachable and more present in education.

By aggregating content, sharing best practices, and supporting milestones like Java adoption in CoderDojo, we can ensure that Java remains not only relevant, but inspiring for future generations of developers.

If you believe in the power of education and in Java as a tool for learning, this is an open invitation: join the conversation, contribute content, and help shape the future of Java in education.

Together, we can grow Java where it matters most — at the beginning.

Recently, I had the pleasure of discussing this initiative in an interview on the Foojay Podcast You can listen to the episode #85 "Code, Community, and Opportunity: Making Tech Accessible for Everyone" here.

Links

https://github.com/foojayio/java-education-catalog

https://www.pi4j.com/

https://javapro.io/2026/01/15/java-25-jep-512-jbang-notebooks-graallpy-and-raspberry-pi-for-interactive-learning/

The post Bringing Java Closer to Education: A Community-Driven Initiative appeared first on foojay.

Working with enterprise Java databases can sometimes feel like swimming upstream. Jakarta EE 11’s Jakarta Data helps developers glide through data operations effortlessly, cutting complexity and keeping projects flowing smoothly.

In this blog post, we look at what Jakarta Data brings to the table and how it can transform everyday Java development tasks.

Jakarta EE is evolving, and one of the most talked-about additions in the latest release (Jakarta EE 11) is Jakarta Data, a framework designed to simplify how developers interact with databases. By reducing boilerplate and offering a more intuitive approach, Jakarta Data promises to make enterprise Java development cleaner, faster and more maintainable.

The Problem: Data Access in Enterprise Java

Traditionally, data access required a lot of boilerplate code, complex design patterns and careful maintenance. Historically, enterprise Java developers have been on the hook for setting up numerous classes just to talk to a database. CRUD operations required the Data Access Object (DAO) pattern, with multiple classes, plus JPA Criteria API scripting for complex queries.

This extra work meant hundreds of lines of boilerplate and maintenance headaches.​Even more, this combination can introduce latency, bugs and scalability issues. Jakarta Data addresses this head-on.

Annotation-Driven Persistence with Jakarta Data

At its core, Jakarta Data simplifies database operations by standardizing repository patterns. Instead of navigating multiple layers and classes, developers now only need to define a single interface.

Jakarta Data solves this with a clean, single-interface approach built atop Jakarta CDI. Developers define their repositories using new annotations, and Jakarta Data handles the heavy lifting at runtime. The result is:

• Dramatically reduced boilerplate
• Enhanced code clarity and maintainability
• Flexible, efficient generation and implementation of CRUD repositories
• A special highlight: Jakarta Data introduces its own, purpose-built query language, JDQL (Jakarta Data Query Language), as well as native support for pagination, features previously requiring custom logic or verbose JPA scripting.

By introducing a unified repository abstraction using familiar annotations, Jakarta Data standardizes and streamlines how developers write code for data operations. Jakarta Data is particularly effective for applications with one-to-one table relationships, which covers a large portion of enterprise workloads, but also supports advanced scenarios, such as many-to-many relationships, multi-database interactions, or complex entity mappings, may require additional configuration.

How Payara Implemented Jakarta Data

At Payara, we took a modular, independent approach to implementing Jakarta Data, ensuring our solution was fully compatible with Jakarta EE 11. The team modularized requirements and maintained close collaboration to ensure rapid, robust support. This approach enabled Payara Platform Community 7 Beta to achieve fast Jakarta EE 11 certification.​ In effect, Payara is the first vendor to be compliant across all three Jakarta EE 11 profiles: Core, Platform and Web.

Payara’s implementation doesn’t stop with baseline Jakarta Data support. The team is actively working on enhancements, including merging of JDQL interpretation and query name creation parsers, promising even more efficient, developer-friendly experiences in upcoming releases.

Where Does This Leave Enterprise Java Developers?

Jakarta Data marks a key shift in enterprise Java. With Jakarta EE 11 and Payara Platform Community 7 Beta, building robust, modern, data-driven applications just got dramatically easier.

Ready to go deeper? Download Payara Platform Community 7 to explore, contribute feedback and take full advantage of Jakarta Data for your projects.

The post Jakarta Data Makes Persistence a Breeze appeared first on foojay.

After years of experimenting with Raspberry Pi boards, Java, JavaFX, and Pi4J to control electronics, I wanted to explore whether my knowledge and experience could be applied to similar boards from other providers. There are many alternatives available these days, based on ARM, Intel processors, and RISC-V architectures.

I reached out to several suppliers to see if I could get evaluation copies, and I'm happy to share that I received my first box from DFRobot containing the LattePanda IOTA.

Unboxing the LattePanda IOTA

The box contained multiple smaller boxes, but the most important one was the LattePanda IOTA board itself, based on an Intel Twin Lake N150 quad-core processor (up to 3.6GHz). It has a clear warning on the packaging: "Do not operate without a heatsink". This thing will definitely get hot if you ignore that warning I guess

The board is a bit bigger than a Raspberry Pi and appears very well-made. It has:

• A GPIO header (similar to Raspberry Pi, though the pin numbering is different)
• Network connection
• Connections for storage options and other expansions
• Three USB ports
• A full-size HDMI connector (more convenient than the mini or micro HDMI on Raspberry Pi)

In the same box, I also received:

1. M2 expansion board: for extra storage
2. Active cooler: essential to prevent overheating
3. UPS hat: for battery backup functionality
4. Power over Ethernet shield: handy, will test later
5. 4G LTE module with SIM card support

The cooling fan has a nice logo and excellent build quality. The PoE shield connects directly to a new network connector on the board, unlike Raspberry Pi expansion boards that use the Pi's existing network connection.

Assembly

Following the documentation, I applied thermal paste to the processor, attached the cooling fan, and connected the M2 expansion board.

Setting Up The Board

First Boot: Windows Pre-installed

After finding the power button, the LattePanda logo appeared on screen, and... Windows started booting. Windows was pre-installed, though I'm not sure if this is default or just for evaluation units. Either way, I immediately noticed 100% CPU usage, the exact reason I left Windows long ago, as I never understood that it's an ongoing problem with Windows... Memory usage was also pretty high.

This thing definitely works with Windows, but I don't use Windows myself. Time to turn this into a Linux device.

Installing Ubuntu

I put the latest Ubuntu system on a USB stick to boot from it, restarted the device, and kept pressing the delete button to enter the BIOS. The system recognized the USB drive immediately. After selecting it and choosing "Save and exit", it booted into Ubuntu installation mode. A few configuration steps later, I had a nice combination: LattePanda running Ubuntu.

Setting Up Java Development

As expected, Java isn't pre-installed in Ubuntu, but several installation options were suggested. However, there's an easier way to prepare a Linux embedded board like this or a Raspberry Pi for Java development: the Pi4J OS repository.

This repository contains scripts to set up boards for Java development, making it easy to have everything prepared and ready to start. There are two scripts available:

1. One for Raspberry Pi
2. One for non-Raspberry Pi boards

Using the second option, curl downloads and executes the script for non-Raspberry Pi boards with the following command:

curl -sL https://raw.githubusercontent.com/Pi4J/pi4j-os/main/script/prepare-for-java-non-rpi.sh | bash

This performs:

• System update
• Installation of extra dependencies for Java and I2C
• SDKMAN installation
• Java installation
• Maven installation
• JBang installation

I also installed Visual Studio Code, the preferred Java editor for this kind of board because it's lightweight and has excellent extensions for Java and JavaFX applications. These are the recommended extensions for Java development:

• Extension Pack for Java: Installs many tools for Java development
• JBang: To execute JBang code directly from VS Code

Testing Java, JavaFX, and Pi4J

I cloned the Pi4J JBang examples project and opened it in Visual Studio Code, to execute code in an easy way.

HelloWorld with JBang

The simple "Hello World" example ran perfectly. There's also an extended example using the Jackson library for JSON parsing, demonstrating how JBang can create single-file applications with dependencies, without needing a full Maven or Gradle project.

JavaFX Test

Since I installed the Java version from Azul with JavaFX included, I could also run a JavaFX demo application. It uses Pi4J to detect the board type, though this only contains methods to detect Raspberry Pi board versions at this moment, so it didn't recognize the LattePanda.

But the application ran smoothly! It showed we're running on a Linux 64-bit system with Java 25. The board wasn't recognized yet as expected, maybe we can in the future add detection tools in the Pi4J library to show the brand or manufacturer information.

Without any extra work, we have a JavaFX application running very smoothly on this board!

Pi4J Test

Now for the fun part: let's see what happens when we run something Pi4J-specific. I tried a project that uses an RGB-LED and changes colors. It compiled, but gave errors about user groups not being configured correctly. This was expected, I've never tried Pi4J on a non-Raspberry Pi single-board-computer before, so I wasn't expecting it to work on the first attempt.

This is something I'll dive into further and post follow-up videos about what can be achieved with the Pi4J library on boards like this.

Performance Check

With htop, I checked the CPU usage. Compared to Windows using 100% CPU, we have here in an idle state almost nothing. There's a lot of room for applications we can run on this board. Great!!!

Conclusion

This was the first quick test, and it only took me about an hour to unbox everything, assemble it, and record this. Very promising results:

• Java runs perfectly
• JavaFX runs very smoothly
• Pi4J not working yet, but that was expected

The next step will be to determine which configuration changes are needed, either at the system level or within Pi4J itself. I'm very happy with this first result. The LattePanda IOTA is a very good-looking board, well-made, and comes with a good fan. You don't hear it running during normal usage. It only ramps up when you start demanding applications.

Promising results! I'm looking forward to experimenting more with this and similar boards to see what's possible with Java(FX) and Pi4J on alternative hardware platforms.

Stay tuned for follow-up videos and blog posts!

The post First Experiments with Java on the LattePanda IOTA: An Alternative to Raspberry Pi? appeared first on foojay.

What if the future of Java depends on who we invite to learn it today?

In this Foojay Podcast, we're diving into something that affects all of us in the Java community: How can we inspire the next generation of developers, and how do we make the developer world more inclusive?

In this episode, you'll hear four incredible guests who are actively working to make tech more accessible and inclusive. First, Daniel De Luca talks about Devoxx for Kids and how they support underprivileged students in IT education. Then Kenny Schwegler shares his insights on how we can actively promote diversity and inclusion in tech. Cassandra Chin, the youngest Java Champion and author, talks about inspiring young coders through hands-on projects and making technology fun. And finally, Igor De Souza discusses his mission to bring Java into Raspberry Pi education and bring more Java into coding clubs worldwide.

These conversations share one message: Talent is everywhere, but opportunity isn't. And we have the power to change that!

YouTube

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

• Spotify
• Apple Podcasts
• And most others...

Content

01:19 Daniel De Luca

• https://www.linkedin.com/in/danieldeluca/
• Founder Devoxx4Kids
• Activities of Devoxx4Kids
• How to inspire children of all ages to get interested in technology

14:24 Kenny Schwegler

• https://www.linkedin.com/in/kenny-baas/
• How to build inclusive, diverse teams
• How the IT industry became male-focused because of IBM marketing
• Books:
  • https://www.manning.com/books/collaborative-software-design
  • https://learningsystemsthinking.com/

26:07 Cassandra Chin

• https://www.linkedin.com/in/cassandra-chin-developer/
• Inspiring children and parents into technology
• Fun projects to introduce engineering to children
• Book:
  • https://www.amazon.nl/Raising-Young-Coders-Teaching-Programming/dp/B0DVBQZ483
  • 20% Discount code on the Springer website "APAUT"
    • https://link.springer.com/book/10.1007/979-8-8688-1393-1

32:45 Igor De Souza

• https://www.linkedin.com/in/igfasouza/
• Java in code clubs like CoderDojo
• Java in space
• Collecting Java tutorials and courses for children
• Java Catalog on Foojay GitHub
  • https://github.com/foojayio/java-education-catalog
• Pi4J library
  • https://www.pi4j.com/
• HelloWorld magazine:
  • https://downloads.ctfassets.net/oshmmv7kdjgm/6jGvFLH86Ems5AJR84Krsk/3888c571ddc1543c9cdb01ce5eff616d/HelloWorld28.pdf

55:27 Conclusions

The post Foojay Podcast #85: Code, Community, and Opportunity: Making Tech Accessible for Everyone appeared first on foojay.