Foojay.io | Friends of OpenJDK and Java Programming
Foojay.io | Java and Programming Community
Neueste Episode
104 Episoden
Security Is Your Job: OWASP, AI and Safer Java Dependencies with Jim Manico (Foojay Podcast #105)
14.11.2026 | 48 Min.How safe is your Java application, and how safe are the dependencies it ships with? If you build software that handles sensitive data and you have no security process, OWASP's Jim Manico has a blunt word for it: negligent.
In this episode, Jim Manico, founder of Manicode Security, Java Champion and OWASP project leader, explains what OWASP is and which of its projects matter to Java developers. He brought the OWASP Java Encoder, Java HTML Sanitizer and JSON Sanitizer back to life with AI-assisted workflows, and tells us what he learned along the way.
Topics include:
When to use the OWASP Java Encoder versus the Java HTML Sanitizer
Why untrusted input must be checked on both the client and the server
How a few kilobytes of nested CSS can cause a denial-of-service
Why chained small vulnerabilities become a major one in the age of AI
Why Jim wants far fewer third-party libraries, and how to keep the rest up to date
What to do first when your team has no security process
Guest: Jim Manico
Founder of Manicode Security, Java Champion and OWASP project leader
Jim on LinkedIn
Links:
Full show notes with all links
OWASP Java Security Libraries: Please Update
OWASP Java Encoder
OWASP Java HTML Sanitizer
trim-reaper on GitHub
Timestamps:
00:00 Introduction of topic and guest
02:11 What is OWASP?
04:10 How AI influences the speed of OWASP changes. Who contributes.
06:30 Which OWASP projects you should know as a Java developer
07:30 How Jim uses AI to evolve his libraries
08:28 When to use OWASP Java Encoder and OWASP Java HTML Sanitizer
13:58 User input needs to be checked in all steps (UI and backend)
16:07 Man-in-the-middle attacks (eMuhdra)
17:17 How to keep your systems up-to-date + minimize your dependencies
22:34 How CSS can cause a denial-of-service problem
24:52 How multiple small security issues can be combined into a major issue
26:36 How to handle the growing number of discovered vulnerabilities
29:13 The era of coding is coming to an end but you can still be a master developer
32:45 How to automate upgrading with Maven, Gradle, and other tools
36:42 What Java developers can learn from recent security problems (like PHP and eMuhdra)
38:42 You must have a security process! Make your managers aware...
43:53 How to get involved in OWASP
46:08 What to remember from this podcast: security is your responsibility!- A record 53 CVEs in one Java update, followed by two emergency releases within days. Yes, a lot of issues are being found, but Java is still strong: a whole community and the commercial distributors are behind every fix.
In this episode, Simon Ritter, Deputy CTO at Azul, Java Champion and member of the OpenJDK Vulnerability Group, explains what happened over the past weeks and what it means for your applications. We cover how a vulnerability travels from a report to a patch, why AI is changing the number of fixes, and why you should be ready to update at any moment. If you want to understand how CVEs are handled behind the scenes and what the different types of security updates mean, this episode explains it.
Topics include:
What a CVE and a CVSS score really tell you, and why low scores can be chained into serious attacks
How vulnerabilities are kept secret and encrypted in the OpenJDK Vulnerability Group until a patch exists
Why the average of 7.6 CVEs per quarter jumped to 53, and the move toward monthly security updates
The eMudhra certificate problem and the two out-of-cycle releases that followed
The backporting workload behind every supported Java version, from 27 down to 6
CPU, PSU and CSPU explained, and what free versus paid OpenJDK builds mean for your patching
Guest: Simon Ritter
Deputy CTO at Azul and Java Champion
Simon on LinkedIn
Links:
Full show notes with all links
Free Java, Real Risk: Why Unsupported OpenJDK Is Now a Security Gamble
Azul Zulu October 2026 Quarterly Update and Out-of-Cycle Release
Timestamps:
00:00 Introduction of topic and guest
01:59 What is a CVE and how are they reported and handled?
08:45 How the Java security release cycle is changing and each have more CVEs
11:48 How AI impacts the discovery of CVEs
14:09 What was the eMudhra problem causing two out-of-cycle security updates?
21:49 The impact of creating an out-of-cycle update (and backports)
26:05 How safe will OpenJDK builds be in the future? And dependencies?
29:06 Free versus paid versions of OpenJDK builds
32:40 CPU vs PSU vs CSPU: the names used for different types of security updates (security only versus including patches)
35:52 What will happen with old Java versions like 6, 7, 8
37:05 Why would you pay for a supported OpenJDK build?
41:50 Conclusion: check your Java version and be ready to update at any moment! - Runtime reflection is a quiet tax on the JVM. It is flexible, it is everywhere, and it is easy to stop noticing it until you go looking for where your CPU is actually going. Two teams did exactly that, in completely different corners of the ecosystem, and arrived at the same answer: move the work to build time.
In this episode, Dmitry Moskalyuk explains the model layer behind his Foojay article on reflection-free serialization, where JSON, XML, YAML and TOML all end up as Avro. Shai Almog explains the build-time codegen pipeline of Codename One, which aims for no reflection, no service loader and no Class.forName. We compare the two and ask whether generated code is really something to avoid.
Topics include:
Where Jackson's reflection cost really lives, and what Blackbird does about it
Jackson versus kotlinx.serialization, and why a missing feature sent the team back to Jackson
Why a UI framework bans reflection, and how that differs from the backend
Is generated code bad? Lombok, Manifold and jOOQ
What Records and Project Leyden change for reflection
Build time cost versus runtime cost, and a single source of truth for your data model
Should you still use reflection in a new project?
Guests:
Dmitry Moskalyuk, Senior Backend Engineer
Dmitry on LinkedIn
Shai Almog, Author, DevRel and open source developer working on Codename One
Shai on LinkedIn
Links:
Dmitry's article on Foojay
Shai's article on Foojay
Jackson Blackbird
Apache Avro
Project Leyden
Full show notes with every link
Timestamps:
00:00 Introduction of topic and guests
01:50 About the new Foojay, contributing with GitHub pull requests
03:17 What is Apache Avro
04:26 What is Codename One
06:31 What is Blackbird in Jackson and compared to kotlinx mechanisms for different content parsers
10:01 Why Codename One focuses on "no reflection, no service loader, no Class.forName"
14:23 Is automatically generated code bad (Lombok, Manifold, JOOQ)?
17:47 Java evolutions that bring improvements into the system (Records, Project Leyden)
21:31 Is reflection changing through Java versions?
24:29 Build time cost versus runtime, Project Leyden
28:41 Use of reflection in UI versus backend
32:16 Benefit of your data model in a (Java) object, having one source of truth, good debugging
35:35 Should you worry about serialization in a small project
37:38 Serialization and security
38:57 Should I still use reflection/serialization in a new project?
43:22 Conclusion - Foojay.io quietly moved off WordPress and onto Hugo. No more CMS login, no database, no admin panel — just Markdown and AsciiDoc files, built and deployed straight from GitHub. So is a traditional CMS still the right way to run a content site in 2026, or has static tooling caught up?
In this episode, Andy Damevin and Holly Cummins from the Red Hat Quarkus team join to talk through it. Andy created code.quarkus.io and Roq, Quarkus's own Java-based static site framework; Holly led the migration of quarkus.io itself from Jekyll to Roq. We go through the real security numbers behind WordPress's plugin ecosystem, and put very different static site generators head to head: Hugo and Jekyll, the veterans, versus Roq, the newcomer.
Topics include:
Why WordPress core is usually fine, and the plugins are where the trouble is — over 10,000 plugin vulnerabilities found since 2025
What "recovery" means for a static site versus a CMS after a hack or defacement
Jekyll, Hugo, Roq and JBake compared, and why staying in Java matters (or doesn't)
How to extend Roq as a Java developer, from a small PR to writing your own plugin
What an actual WordPress-to-Roq migration looks like in practice
Where a CMS still earns its keep despite all of this
Guests:
Andy Damevin on LinkedIn - Principal Software Engineer at Red Hat, Quarkus core team, creator of code.quarkus.io and Roq
Holly Cummins on LinkedIn - Senior Principal Software Engineer, Red Hat Quarkus team, led the quarkus.io migration from Jekyll to Roq
Links:
Migrate from WordPress to Roq
Roq
Hugo
Full show notes
Timestamps:
00:00 Introduction of topic and guests
03:29 Why WordPress is not the best choice for most sites
04:36 Difference between CMS-driven websites and static websites
07:02 Jekyll versus Roq and other systems
11:04 How to extend Roq
12:59 Moving from WordPress to Roq
14:43 Pulling data with JBang or Roq from external sources into your publication process
16:09 Why should I use Roq instead of Jekyll or Hugo?
24:33 Static websites can be created with a small team and are much cheaper (or even free) to host
26:52 How many WordPress websites have a backup to recover after getting hacked? And the advantage of having your content sources on Git.
33:04 Is there still a use case for WordPress-like systems?
37:09 Conclusions Java 27 in Practice: Smaller Heaps, Smarter Defaults, and Valhalla on the Horizon (#101)
12.09.2026 | 57 Min.Episode 101 of the Foojay Podcast.
JDK 27 arrives on 15 September 2026 without finalising a single new piece of language syntax. It is still worth the upgrade: object headers shrink from 64 bits to 32, which the JEP measures at 22% less heap and 8% less CPU on SPECjbb2015, and G1 becomes the default garbage collector on every machine. Both changes live inside the JVM, so an application you compiled years ago picks them up with no code change at all.
Simon Ritter, Deputy CTO at Azul and Java Champion, takes us through all nine JEPs in the release, explains why a non-LTS version is still worth testing against, and makes the point that "long-term support" describes the binary you download rather than anything in OpenJDK itself. We also cover the move from quarterly to monthly security updates that started in August 2026, and then look ahead to March 2027, when Project Valhalla reaches its first preview after roughly twelve years of work.
Topics include:
Compact object headers by default, and what 22% less heap actually buys you in production
Post-quantum key exchange in TLS 1.3, and the harvest-now-decrypt-later attack it defends against
JFR redaction: keeping access tokens and passwords out of flight recordings you share
Structured concurrency in its seventh preview, and why an evolving API stays in preview
The Vector API's twelfth incubation, and what it is waiting for
Value Objects in Java 28: a new value keyword, 179,000 lines, 1,800 files, and why it will not be final in JDK 29
Whether a Simple JSON API in the JDK will survive its previews, or go the way of string templates
Guest: Simon Ritter
Deputy CTO at Azul, Java Champion
Simon on LinkedIn
Simon on Foojay
Links:
Full show notes, with every JEP linked
JDK 27
What CSPUs Mean for Your Release Pipeline
What to Know About Garbage Collection as a Java Developer!
Project Valhalla
Timestamps:
00:00 Introduction of the topic and guest
01:27 How long Simon has been doing Java
01:54 Why release 27 is important, even when not being a Long Term Support release
04:55 Quarterly and monthly security updates between new version releases
08:07 Which JVM versions are most used in companies
09:23 JEP 534: Compact Object Headers by Default
14:51 JEP 523: Make G1 the Default Garbage Collector in All Environments
18:59 JEP 527: Post-Quantum Hybrid Key Exchange for TLS 1.3
22:55 JEP 538: PEM Encodings of Cryptographic Objects (Third Preview)
25:35 JEP 536: JFR In-Process Data Redaction
28:02 JEP 531: Lazy Constants (Third Preview)
29:55 JEP 532: Primitive Types in Patterns, instanceof, and switch (Fifth Preview)
33:13 JEP 533: Structured Concurrency (Seventh Preview)
38:21 JEP 537: Vector API (Twelfth Incubator)
40:28 Looking forward to Java 28 and Project Valhalla
42:31 JEP 401: Value Objects and JEP 539: Strict Field Initialization
47:36 Can we expect this to be finalized in Java 29?
48:26 LTS releases every 1, 2, or 3 years?
49:55 JEP 541: Deprecate macOS/x64
51:53 JEP 540: Simple JSON API (Incubator)
55:30 Conclusion, what to remember from this release
Weitere Technologie Podcasts
Trending Technologie Podcasts
Über Foojay.io | Friends of OpenJDK and Java Programming
Foojay.io is your go-to programming community podcast, connecting developers with the latest in Java, OpenJDK, JVM, and open source tools. We bring together Java professionals worldwide to share insights, tools, and news in the vibrant Java programming ecosystem.
Podcast-WebsiteHöre Foojay.io | Friends of OpenJDK and Java Programming, Flugforensik - ein Absturz und seine Geschichte und viele andere Podcasts aus aller Welt mit der radio.de-App

Hol dir die kostenlose radio.de App
- Sender und Podcasts favorisieren
- Streamen via Wifi oder Bluetooth
- Unterstützt Carplay & Android Auto
- viele weitere App Funktionen




































