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.

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.

I'll be honest - my first encounter with Java in 1999 wasn't love at first sight. It was during a university distributed systems course, and coming from a background in assembler and C, Java felt bloated, slow, and frankly untrustworthy. That "automatic memory handling" seemed like dangerous magic I couldn't control. After years of meticulously tracking every allocated memory block, the idea that the runtime would handle memory management felt like giving up control to forces I didn't understand.

For the first eight years of my career, I stubbornly stuck with C, convinced that Java was just a passing trend for developers who couldn't handle "real" programming.

I was wrong. And I'm glad I was.

Fast forward to today, after 25+ years in software development, and Java has become not just the foundation of my career, but a language I genuinely recommend to developers in 2025. Here's the story of how Java changed my mind, and why I believe it's still one of the most valuable languages you can learn today.

The Transformation: From Skeptic to Advocate

My real introduction to Java came in the mid-2000s when I joined a consultancy firm building software for cell phones. The iPhone and the first Android devices had just been released, and suddenly we didn't need to build low-level protocols and applications in C anymore. The platforms provided everything we needed so that we could focus on building actual applications instead of wrestling with memory management and implementing our own collections.

People told me that Java 1.6 had improved dramatically since the version 1.0 I'd dismissed years earlier. Curious and honestly eager to try something new after years of manual memory management, I decided to take the SCJP 6 certification.

It felt like discovering a completely new language. Yes, some concepts were familiar, but Java had matured in ways I hadn't expected. It was more polished, more thoughtful, and surprisingly… trustworthy.

The Power of Continuous Evolution

I was truly impressed with how the language evolved with developers' needs. Each release brought improvements that seemed to understand the pain points we actually faced in day-to-day development.

Brain-Friendly Programming

One of my first major Java projects involved migrating a large enterprise application from Java 1.4 to Java 7. The team needed Java expertise because while they'd updated the JRE, the codebase wasn't using any features added since Java 1.4, including generics.

I spent months helping add type information to collections throughout the system. We changed untyped Arrays to typed Lists, added types to Maps, and gradually eliminated the cognitive overhead of tracking what each collection contained. Here's a simple example of what we were transforming:

// Before generics - mental overhead
List users = getUserList();
for (Iterator iterator = users.iterator(); iterator.hasNext(); ) {
    User user = (User) iterator.next();  // Hope this doesn't throw ClassCastException!
    // Process user
}
 
// After generics - intent is clear
List<User> users = getUserList();
for (User user : users) {  // Our brain can focus on the business logic
    // Process user
}

The real impact of generics went beyond type safety. Every time we encountered a List in the old codebase, we had to hunt through the code to figure out what it contained. With generics, the intent was immediately obvious. It helped us decrease the mental burden working with the code.

This pattern has continued through Java's evolution. Features like records, pattern matching, and enhanced switch expressions all follow the same principle: make code that aligns with how developers naturally think about problems.

Modern Java: Even More Brain-Friendly

Today's Java continues this trend. Consider how modern features reduce cognitive load:

// Traditional approach - High cognitive load
public class UserStatus {
    private final String status;
    private final String message;
    private final LocalDateTime timestamp;
     
    // Constructor, getters, equals, hashCode, toString...
    // (40+ lines of boilerplate)
}
 
// Modern approach - Zero cognitive overhead
public record UserStatus(
    String status, 
    String message, 
    LocalDateTime timestamp
) {}
 
// Pattern matching with sealed interfaces
public sealed interface LoginResult {
    record Success(User user, String token) implements LoginResult {}
    record Failure(String reason) implements LoginResult {}
    record MfaRequired(String temporaryToken) implements LoginResult {}
}
 
// Data-driven flow control
String message = switch (loginResult) {
    case Success(var user, var token) -> 
        "Welcome back, " + user.name();
    case Failure(var reason) -> 
        "Login failed: " + reason;
    case MfaRequired(var token) -> 
        "Please enter your MFA code";
};

This code aligns perfectly with how our brains naturally categorize and handle different cases. The compiler ensures we've handled every possibility, reducing the mental overhead of "what if" scenarios.

Backwards Compatibility That Actually Works

Here's something remarkable: that enterprise application I helped migrate from Java 1.4 to Java 7? It's now running on Java 21. The same codebase, with incremental improvements over nearly two decades, benefiting from performance improvements, security updates, and new language features, all without major rewrites.

This backward compatibility isn't just a technical achievement; it's a career investment. The Java skills you learn today won't become obsolete in five years. They'll be refined, enhanced, and made more powerful, but they'll still be relevant.

Oracle and the Java community have maintained this commitment to compatibility through:

• Careful deprecation cycles that give developers time to adapt
• Module system design that doesn't break existing code
• Preview features that let developers experiment without commitment
• LTS (Long Term Support) releases that provide stability for enterprise environments

This means when you invest time learning Java, you're not just learning a language, you're investing in a platform that will support your career growth for decades.

Choice Without Chaos

One of Java's hidden strengths is the healthy competition within its ecosystem. Unlike languages with single implementations or dominant vendors, Java offers choices at every level:

JDK Distributions:

• Oracle JDK for enterprise support
• Azul Zulu for general enterprise use and performance-critical systems
• Red Hat OpenJDK for enterprise Linux environments
• Amazon Corretto for AWS integration

Frameworks:

• Spring Boot for rapid development
• Quarkus for cloud-native applications
• Jakarta EE for enterprise standards

Build Tools:

• Maven for convention-based builds
• Gradle for flexible, scriptable builds

This competition drives innovation while maintaining ecosystem stability. You can choose the tools that best fit your project's needs without worrying about vendor lock-in or technological dead ends.

Real-World Impact

In my current role, we've been able to optimize our technology stack based on specific requirements:

• Using Quarkus for container based microservices that need fast startup times.
• Leveraging Spring Boot for complex business applications.
• Switching between JDK distributions based on deployment targets.

This flexibility has allowed us to adopt new technologies incrementally rather than requiring complete rewrites.

A Community That Grows With You

The Java community is genuinely special. It's welcoming to newcomers while respecting experience, innovative while maintaining stability, and global while feeling personal.

From Local to Global

My journey in the Java community started small:

• Attending local Java User Group (JUG) meetings as a nervous observer
• Gradually participating in discussions
• Eventually presenting at conferences like Devoxx Belgium

The community supported every step of this growth. When I reached out to experienced speakers for advice, they responded with encouragement and practical tips. When I submitted my first conference proposal, community members provided feedback and guidance.

This isn't unique to my experience. The Java community has a culture of mentorship and knowledge sharing that spans from local meetups to international conferences. Whether you're debugging your first NullPointerException or architecting enterprise systems, there's always someone willing to help you grow.

Knowledge Sharing That Matters

What sets the Java community apart is the quality of knowledge sharing. It's not just about showing off the latest features, it's about solving real problems and sharing lessons learned from actual projects.

Community resources that have shaped my career:

• Foojay.io for staying current with Java developments
• Local JUGs for networking and learning from peers
• Open source projects for seeing best practices in action
• Conferences for deep dives into advanced topics

The community doesn't just consume knowledge, it creates it. Java developers regularly contribute to:

• Open source libraries and frameworks
• Technical blogs and documentation
• Conference presentations and workshops
• Mentoring programs and code reviews

Java in 2025: Why It Still Matters

As we look toward 2025, several trends make Java even more relevant:

The AI Revolution Needs Solid Foundations

While everyone talks about AI and machine learning, someone still needs to build the reliable, scalable systems that support these innovations. Java's strengths in enterprise development, microservices, and high-performance computing make it essential infrastructure for AI applications.

Cloud-Native by Design

Modern Java frameworks like Quarkus is designed for cloud-native development from the ground up. Features like:

• Fast startup times with GraalVM native images
• Efficient memory usage for containerized environments
• Built-in observability and monitoring capabilities
• Seamless integration with Kubernetes and service meshes

These make Java a natural choice for modern cloud applications.

Java's emphasis on maintainable, readable code aligns perfectly with the growing need for sustainable software development practices. As systems become more complex and long-lived, the ability to write code that humans can understand and maintain becomes increasingly valuable.

Virtual Threads and Project Loom

Java 21's virtual threads revolutionize concurrent programming by making it simple to write highly scalable applications. Instead of complex reactive programming patterns, you can write straightforward code that handles millions of concurrent operations.

// 10,000 concurrent HTTP calls with simple blocking code
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    IntStream.range(0, 10_000)
        .forEach(i -> executor.submit(() -> {
            var response = httpClient.send(buildRequest(i), HttpResponse.BodyHandlers.ofString());
            System.out.println("Response " + i + ": " + response.statusCode());
        }));
} // Auto-waits for completion

Getting Started with Java in 2025

If you're convinced that Java is worth learning, here's how to begin:

1. Start with Modern Java

Don't learn Java 8 patterns, start with Java 17 or 21. Modern Java is more concise, more expressive, and more enjoyable to write.

2. Focus on Fundamentals

• Object-oriented programming principles
• Collections framework
• Exception handling
• Basic concurrency concepts

3. Build Real Projects

• Start with a simple REST API using Spring Boot
• Build a command-line tool
• Contribute to an open source project
• Create something you'll actually use

4. Join the Community

• Find your local JUG on Meetup.com
• Join online communities like Foojay
• Follow Java Champions on social media
• Attend virtual conferences

5. Embrace the Ecosystem

• Learn Maven or Gradle for build management
• Understand testing with JUnit and Mockito
• Explore frameworks like Spring Boot
• Practice with modern IDEs like IntelliJ IDEA or VS Code

The Goal: Code That Serves a Purpose

Remember, the goal isn't to make code as simple as possible, but to ensure that its complexity serves a purpose. Java in 2025 helps us write code that humans can understand and maintain, and that's a skill that never goes out of style.

Every line of code should justify its cognitive cost. Java's evolution has consistently moved toward reducing unnecessary complexity while providing powerful tools for solving real problems.

Conclusion: A Language That Grows With You

My journey from Java skeptic to advocate taught me that the best technologies aren't necessarily the flashiest or newest, they're the ones that grow with you over time. Java has been my companion through:

• Learning object-oriented programming
• Building enterprise applications
• Navigating the transition to cloud computing
• Exploring microservices and distributed systems
• Mentoring other developers
• Speaking at international conferences

In 2025, Java offers something rare in the tech world: stability without stagnation, innovation without disruption, and a community that values both technical excellence and human growth.

Whether you're starting your programming journey or looking to add a robust, reliable language to your toolkit, Java remains one of the best investments you can make in your technical future.

The best time to plant a tree was 20 years ago. The second best time is now. The same is true for learning Java.

Action Items:

[ ] Download the latest JDK and try building a simple "Hello, World" application
[ ] Find and join your local Java User Group
[ ] Follow three Java community leaders you find inspiring
[ ] Set up a learning plan for the next three months

The post Why Java is Still Worth Learning in 2025: A Developer’s 25-Year Journey appeared first on foojay.

On May 13th and 14th, Foojay attended the JCON conference in Köln, Germany, where we did over 30 live-stream interviews. In this episode, we present to you the first set of these interviews, in which we focus on celebrating 30 years of Java, how you can grow your career, become a public speaker and writer, make your code more green, a bit of AI (of course...), and how the connections between open-source contributors can be visualized.

Video

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

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

Content

00:00 Introduction

00:37 Richard Fichtner: About JCON

• https://www.linkedin.com/in/richardfichtner/
• https://jcon.one/

03:27 Bruno Souza: Building your career

• https://www.linkedin.com/in/brjavaman/
• https://careermasterplan.dev

17:09 Markus Westergren: Mentoring and growing to become a senior engineer

• https://www.linkedin.com/in/markuswestergren/

21:56 Brian Vermeer: Public speaking, NLJUG, the importance of writing

• https://www.linkedin.com/in/brianvermeer/

30:08 Aicha Laafia: Green coding

• https://www.linkedin.com/in/aicha-laafia-0266a6126/

36:33 Baruch Sadogursky: History of Java, job changes because of AI

• https://www.linkedin.com/in/jbaruch/

44:40 Dmitry Yanter: Connections in open-source projects

• https://www.linkedin.com/in/dmitry-yanter/

53:12 Conclusion

The post Foojay Podcast #72: JCON Report, Part 1 – Grow your career, public speaking, 30 years of Java, greener coding,… appeared first on foojay.