- Home
- OpenJDK Update Release Details
- Java Version Almanac
- OpenJDK Terminology
- Java 14
- Java 13
- Java 11
- Java 8
- Java 7
- JVM Command Line Arguments
- OpenJDK 19 Command Line Arguments
- OpenJDK 20 Command Line Arguments
- OpenJDK 21 Command Line Arguments
- OpenJDK 18 Command Line Arguments
- OpenJDK 17 Command Line Arguments
- OpenJDK 16 Command Line Arguments
- OpenJDK 15 Command Line Arguments
- OpenJDK 14 Command Line Arguments
- OpenJDK 13 Command Line Arguments
- OpenJDK 12 Command Line Arguments
- OpenJDK 11 Command Line Arguments
- OpenJDK 10 Command Line Arguments
- OpenJDK 9 Command Line Arguments
- OpenJDK 8 Command Line Arguments
- OpenJDK 7 Command Line Arguments
- OpenJDK 6 Command Line Arguments
- Java Calendar
- Java 20
- Java Events
- Java 16
- Java 17
- Advisory Board
- Java 19
- Contributors
- Download OpenJDK
- Java 15
- Java 18
- Foojay Today
- Managing Data Residency: The Demo
- Revolutionize JSON Parsing in Java with Manifold
- Your First Vaadin Spring Application in 2023
- JavaFinder: Keeping Track of Java Inventories
- Rolling Binary Trees: A Guide to Common Design Patterns in Java
- "Transitioning to Java": My First Book!
- Java Threads Reimagined: A Reflection on JConf Toronto 2023 and the Dawn of a New Era of Concurrency
- Foojay Developer Certification: Measure Skills!
- Decoding Success: An Industry Expert's Guide to Thriving in Software Development and Security
- State of Java Survey
- Announcing the Digma Beta: First Runtime Linter for Java Code
- Foojay Podcast #23: Java Profiling and Performance
- FinOps: Tim O'Brien at Walmart
- Mastering the Art of Controlling the JIT: Unlocking Reproducible Profiler Tests
- Enriching Kafka Applications with Contextual Data
- Using Pausers in Event Loops
- Write Once, Run Embedded in any IDE
- Reduce Java Application Startup and Warmup Times with CRaC
- Announcing "Java Unscripted: An Asynchronous Exploration of Excellence"
- Managing Data Residency: Concepts & Theory
- Discovering the Secrets to Success: An Exclusive Interview with Java Champion Michael P. Redlich
- Monitoring Event Loops for Blockages
- Logging Best Practices Revisited
- Foojay Podcast #22: When Profession and Fun Overlap
- FinOps: John Stuart at Azul
- A Dissection of Java JDBC to PostgreSQL Connections
- Analyzing Dependencies in IntelliJ IDEA
- Code Interoperability Mode for OpenCL Portability Across Various Programming Languages with TornadoVM
- Tuning Java Applications for Low Latency on Linux
- Unleashing the Power of Lightweight Concurrency: A Comprehensive Guide to Java Virtual Threads (Part 1)
- Unconventional Remote Process Control Without Libraries In Java: Presenting X-Pipe
- Interview with Paul Kocian aka @Orango_Mango
- Spring Boot Debugging with Aspect-Oriented Programming (AOP)
- Using Async-Profiler and Jattach Programmatically with AP-Loader
- The Unix Philosophy for Low Latency
- Hidden and Not-So-Hidden Gems In Java 20
- Timefold Forks OptaPlanner: Open Source Solver in Java
- Leverage the Richness of HTTP Status Codes
- Foojay Podcast #21: Brazil SouJava JUG and How to Grow your Developer Career
- JavaFX Links of April 2023
- The Basis of Virtual Threads: Continuations
- Java Developer vs. ChatGPT Part I: Writing a Spring Boot Microservice
- Creating Scalable OpenAI GPT Applications in Java
- Comparing Approaches to Durability in Low Latency Messaging Queues
- FEPCOS-J (1) – Description, Impressions of Usage, Current State
- Couldn't We Just Use AsyncGetCallTrace In A Separate Thread?
- Relearning Java Thread Primitives
- Foojay Podcast #20: Functional Programming, "The Good, the Bad, and the Ugly"
- Fearless Distroless
- Automatically Creating Microservices Architecture Diagrams
- JUG PH: Java User Group PH Revitalization Report 2023
- Not Your Grandfather’s Logs — A Java Library’s New Approach To Observability
- Foojay Podcast #19: How Working For Free For Fun Brought Me Fame and Fortune - Or At Least Some Of Each - In The End
- Boldness in Refactoring!
- Replacing Postman with the JetBrains HTTP Client
- Chronicle FIX: Much More Than a Quick Fix
- Getting Started With Jakarta EE 10 - Jakarta REST
- Hidden Beauties of Java Enums
- Introducing Bld: A New Pure Java Build System
- My First Firefox Extension
- Unlocking Java Secrets with Frank Delporte: Insights, Stories, and Tips for Success
- Time Zone and Currency Database in JDK
- Instrumenting Java Code to Find and Handle Unused Classes
- Chronicle FIX: Designed Not To Skip A Message Even If Your Data Centre Fails
- Cherry-Pick: Move a Commit to a Different Branch
- DevOps For Developers: Continuous Integration, GitHub Actions, and Sonar Cloud
- Unlocking the Secrets to a Successful Software Engineering Career: An Interview with Otavio Santana
- Foojay Podcast #18: Atlanta JUG and DevNexus
- Analyzing and Tuning Warm-up of the JVM with Azul Zulu Prime Builds of OpenJDK
- Coroutines on the RaspberryPi (Pi4J-Kotlin)
- JavaFX Links of March 2023
- My Evaluation of the Scaleway Cloud Provider
- Writing a Profiler in 240 Lines of Pure Java
- Competing for the Crown: A Friendly Debate on the Future of Java and Kotlin on Foojay.io Today
- Chronicle Wire: Object Marshalling
- Getting Started with OpenAPI Generators: Tips & Tricks
- Ingesting Time-Series Events from Kafka into QuestDB
- Navigating the Challenges of Modern Software Development: An Exclusive Interview with Shai Almog
- Using Bots to Keep Dependencies Updated
- Foojay Podcast #17: Execute Java Code with TornadoVM on CPUs, GPUs, and FPGAs
- Watch Area and Renderers
- Control your Arduino with Spring
- How to Build and Deploy a Real-time Cloud-based Logging System
- How to Create a Failover Client using the Hazelcast Viridian Serverless
- Java Security: Log4J, the SecurityManager, and Funding
- Mitigating Path Traversal Vulnerabilities in Java
- Predicting Secure Java Projects on Maven Central
- Event-Driven Order Processing Program
- 5 Great Reasons to use jOOQ
- Vaadin 24: Java 17, Jakarta EE 10, Servlet 6, Spring Boot 3
- Java on Visual Studio Code Update – February 2023
- It’s Java 20 Release Day! Here’s What’s New
- From Assembler to Chat-GPT: Steve Poole on the Shifting Landscape of Programming
- Foojay Podcast #16: Welcome to Java 20!
- Book Review: "API Design Patterns"
- How to Create SBOMs in Java with Maven and Gradle
- Book review: "Practical Design Patterns for Java Developers"
- Validating Java Profiling APIs
- The Speed Test: Comparing Map.of() and new HashMap<>() in Java
- Efficient Memory Mapping for Terabyte Sparse Files in Java
- How Gradle Works: Inside the Daemon
- From Law Degree to Java Champion: Geertjan Wielenga on the Success of Java and Navigating the Software Industry
- Getting Started with IntelliJ IDEA
- DevOps for Developers: Introduction & Version Control
- 9 Outdated Ideas About Java
- Streaming Real-Time Data on the Hazelcast Viridian Serverless
- How to Best Use Java Records as DTOs in Spring Boot 3
- Java Performance: Ahead-Of-Time versus Just-In-Time
- Authenticate with OpenID Connect and Apache APISIX
- Exhaustive JUnit5 Testing with Combinations, Permutations and Products
- Using Bookmarks in IntelliJ IDEA
- Making SBOMs, Threats, and Modelling Them a Piece of Cake!
- Java, Friends, and Cold Weather: My Adventure at ConFoo Conference
- Foojay Podcast #15: Japan JUG
- Migrating Applications to TornadoVM v0.15 (Part 2)
- Java Serialization Filtering: Prevent 0-day Security Vulnerabilities
- Is it Time to go Back to the Monolith?
- Event Driven Hello World Program
- Do You Trust Profilers? I Once Did Too.
- JavaFX Links of February 2023
- Make Your Security Policy Auditable
- The Right Feature at the Right Place
- 42 Practical Java Design Patterns: Builder and More
- SBOMs and Software Composition Analysis
- Journeys in Java, Level 9: Docker compose all the things
- Porting an Existing JavaFX App to iOS
- Should You Update Java or Upgrade and Which Version Should You Use?
- The Evolution of APIs: From RESTful to Event-Driven
- Is There a Best OS to Develop a Java Application on?
- How to Get Started with the Hazelcast Viridian Serverless
- Web App Startup in 3ms with RIFE2 and GraalVM
- An Introduction to Scoped Values in Java
- Java Sealed Classes in Action: Building Robust and Secure Applications
- Foojay Podcast #14: Debugging Tools and Skills for Fun and Profit
- What are you Missing by Debugging in VS Code?
- Moving Security into the JVM
- A Quick Look At Faces (JSF) 4.0 In Jakarta EE 10
- Still Time to Schedule Your Holiday for 2038
- Migrating Applications to TornadoVM v0.15 (Part 1)
- How Behaviour Driven Development Works Well with Event Driven Architectures
- SBOMs: First Steps in a New Journey for Developers
- Null Safety: Kotlin vs. Java
- Package Checker: Find & Fix Vulnerabilities with IntelliJ IDEA Ultimate
- Securing Admin Access to Apache APISIX
- Remote Debugging Dangers and Pitfalls
- Journeys in Java, Level 8: Add MongoDB to Spring Cloud Config
- How Gradle Works: Startup
- JFR Timestamps and System.nanoTime
- Which is the Fastest JVM: OpenJDK or GraalVM?
- Getting Started with RIFE2 Java Web Framework v1.0.0
- Announcing Real-time Stream Processing Unconference
- Foojay.io at FOSDEM 2023 Trip Report
- Foojay Podcast #13: Denver and Boulder JUG
- Using Firefox Profiler Beyond the Web
- Explained: Memory Allocation Pacing in Azul Zulu Prime builds of OpenJDK
- What Should I Know About Garbage Collection as a Java Developer?
- Memory Debugging - a Deep Level of Insight
- Debugging Threads and Asynchronous Code
- Firefox Profiler Beyond the Web
- Why Core-to-Core Latency Matters
- How to Run a Java Application with CRaC in a Docker Container
- Real-time Stream Processing with Hazelcast and StreamNative
- Optional in Java: A Swiss Army Knife for Handling Nulls and Improving Code Quality
- More Foojay.io FOSDEM Speaker Predictions for 2023
- Journeys in Java, Level 7: Externalize Microservice Configuration
- JavaFX Links of January 2023
- Quest for REST
- How Java Litters Beyond the Heap: Part 3, Solid-State Drives
- AsyncGetStackTrace: A better Stack Trace API for the JVM
- Modular Monolithic in Practice
- "The More You Say, the Less People Remember...
- Java Bytecode Simplified: Journey to the Wonderland (Part 3)
- Vaadin, OAuth2, and Keycloak
- Foojay Podcast #12: State and Future of the IDEs
- Foojay.io FOSDEM Speaker Predictions for 2023
- Friends of OpenJDK Schedule at FOSDEM 2023
- How Does Kafka Perform When You Need Low Latency?
- How to Release a Java Module with JReleaser to Maven Central with GitHub Actions
- JTest: Roll Out Your Own JUnit-Like Testing Framework
- Foojay Podcast #11: Looking Back to 2022 and Predictions for 2023
- Debugging Streams and Collections
- The Massive Hidden Power of Breakpoints
- Writing a Profiler from Scratch: The Profiling Loop
- Unsafe Deserialization Vulnerability in SnakeYaml (CVE-2022-1471)
- Why Your Choice of Java Virtual Machine (JVM) Matters More Than Ever
- How to Reduce Cloud Cost by 99% for EDA Kafka Applications
- Why Many Developers Don't Write or Give Talks and How to Overcome Challenges
- Managing Dependencies in IntelliJ IDEA
- 2022 in Retrospective
- New Section Added to Foojay.io: Java Quick Start
- Spring Boot - Annotation Reference - 01/b
- Building JavaFX with Gradle
- What’s New in Jakarta REST 3.1 in Jakarta EE 10?
- How to Leverage Method Chaining to Add Smart Message Routing
- Foojay Podcast #10: JUG World Tour: Dubai JUG
- A Short Primer on Java Debugging Internals
- Why Picnic Picked Java
- Spring Modulith: Have We Reached Modularity Maturity?
- Java on Visual Studio Code Update – December 2022
- JavaFX Links of December
- Debugging Program Control Flow
- A Faster Way to Build React + Spring Boot Apps Using Hilla 1.3
- Spring Boot - Annotation Reference - 01/a
- Writing a Profiler from Scratch: Introduction
- Challenges when Developing a GUI for FIX
- How Java Litters Beyond the Heap: Part 2, Distributed Databases
- Azul Provides the CRaC in AWS SnapStart Builds
- Two Million Java Developers on Visual Studio Code! November 2022 Update
- Foojay Podcast #9: The State of JavaFX Framework, Libraries, and Projects
- Foojay on Mastodon: An Update
- Preparing to Move Away from Twitter
- Debug Like a Senior Developer
- What Java Version Are You Running? Let's Take a Look Under the Hood of the JDK!
- Hilla 1.3: Build React + Spring Boot Apps Faster
- Vaadin 23.3 Improves Kubernetes Support, Adds Three New Components
- Why the Cool Kids Use Event Loops
- Compilation Avoidance with Gradle
- Why Did We Choose Jakarta Faces for the UI of the Eclipse Starter for Jakarta EE?
- OmniFish Jakarta EE Survey 2022
- SpringOne TLV World Tour Trip Report
- Web resource caching: Server-side
- Web resource caching: Client-side
- Visualizing Brain Computer Interface Data Using JavaFX
- JFR Event Collection
- Learn How to Develop Event-Driven Architectures
- Viewing Dependencies in IntelliJ IDEA
- Introducing Gradle Test Suites
- Foojay Podcast #8: JUG World Tour: Manchester
- Why I Don't do TDD
- What is An Application Server? In 3 Minutes!
- JavaFX Links of November
- Kafka vs. Chronicle for Microservices: Which is 750 Times Faster?
- How Java Litters Beyond the Heap: Part 1, Relational Databases
- A Poor Man's API
- Controlling a LED strip with Pi4J and JBang
- You’re Doing It Wrong — Recruiting a DevRel
- Gossips: An Event-Bus in a Chatty Neighbourhood
- Unusual Java: StackTrace Extends Throwable
- AP-Loader: A New Way to Use and Embed async-profiler
- Friends of OpenJDK at FOSDEM 2023
- Foojay Podcast #7: Security in Java, what do we need to know and how to keep our applications secure?
- Internal Security: Hardening Internal Systems
- Kotlin on the RaspberryPi (Pi4J-Kotlin)
- How Object Reuse Can Reduce Latency and Improve Performance
- Foojay Mastodon Service: Here It Is!
- Payara Launches Payara Cloud – Serverless Approach for Jakarta EE
- EJB Support in Piranha via CDI
- Java Mastodon Service: The Feedback
- Let's Start a Java Mastodon Community for Friends of OpenJDK!
- Java Profiling Overview
- API Mocking: Essential and Redundant
- The Future of EJB
- What is Jakarta RPC?
- Reducing Tail Latencies with Chronicle Queue Enterprise
- Java on Azure Tooling Update – October 2022
- Geo-routing with Apache APISIX
- Observability is Cultural
- Clean Shutdown of Spring Boot Applications
- Reviewing CVE-2022-42889: Arbitrary Code Execution Vulnerability in Apache Commons Text (Text4Shell)
- Creating Terabyte Sized Queues with Low-Latency
- Structured Error Messages for HTTP APIs
- Discuss the Problem, Not the Solution!
- JavaFX Links of October
- Renovate: Dependabot Alternative
- The Problem with Functional Programming
- Trip Report: Dubai JUG 2nd Meetup
- A Minor But Useful Refactoring Technique That Would Reduce Your Code Footprint (Part 2)
- Why the Fastest Way of Serializing a Java Field is not Serializing it at All
- Foojay Podcast #6: Welcome to Foojay!
- When Breakpoints Don't Break
- Exceptions in Java Lambdas
- How to Use Java DTOs to Stay Secure
- A Minor But Useful Refactoring Technique That Would Reduce Your Code Footprint (Part 1)
- Book review: "Learn JavaFX Game and App Development with FXGL 17"
- How to Build Low Latency Crypto Trading Systems using Java and Chronicle Services
- Java on Azure Tooling Update – September 2022
- Java on Azure Tooling Update – August 2022
- MicroProfile Config for Java SE
- High-Performance Java Serialisation to Different Formats
- Presenting with IntelliJ IDEA
- The Reason Java is Still Popular
- Best Practice: Comparative Evaluation of JDK Setups -- Azul Zulu Prime vs. OpenJDK
- Unified Event-Driven Architecture for the Cloud Native Enterprise
- Low Latency Microservices, A Retrospective
- Am I Testing the Right Way?
- The Maze of Python Dependency Management
- JavaFX Links of September
- Starting Docker Desktop with Spring Boot
- What Does a Modern JVM Look Like, And How Does It Work?
- Reclaiming Persistent Volumes in Kubernetes
- Chronicle Queue Storing 1TB in Virtual Memory on a 128GB Machine
- Apache APISIX Loves Rust! (And Me Too)
- OmniFish Announces Enterprise Support for Eclipse GlassFish, Jakarta EE 10, and a New Cloud‑Native Jakarta EE Runtime
- Great Time at JavaZone 2022
- Payara Launches Jakarta EE 10 Platform Compatible Product
- What is MicroProfile?
- A Better Way To Use Gradle With Github Actions
- Resolving Git Merge Conflicts in IntelliJ IDEA
- The 5 Most Pivotal and Innovative Additions to OpenJDK 19
- OpenJDK 19 Released!
- Foojay Podcast #5: OpenJDK Discussion Panel
- Introduction to Kubernetes Extensibility
- Did You Know You Can Create Mappers Without Creating Underlying Objects in Java?
- New Book: FXGL 17 -- Learn JavaFX Game and App Development
- Open Source Bait and Switch
- How the world caught up with Apache Cassandra
- Best Practices for Managing Java Dependencies
- Baeldung Series Part 2: Build a Dashboard With Cassandra, Astra and CQL – Mapping Event Data
- The Story of a Java 17 Native Memory Leak
- A Quick Glance at the Kubernetes Gateway API
- On Cosmetics vs. Intrinsics in Programming
- Serverless is the New Timeshare
- Multi-cluster Cassandra deployment with Google Kubernetes Engine (Pt. 2)
- Controlling your Server with a Reverse Shell Attack
- Use Pattern Matching to Simplify Java
- Running your Database on OpenShift and CodeReady Containers
- Learning by Auditing Kubernetes Manifests
- Migrating Monoliths to Microservices in Practice
- Can Java/Jakarta EE do Microservices?
- Java Thread Programming (Part 15)
- Pi4J V2.2.0 Released
- What the Heck Is Project Loom for Java?
- End-to-End Tracing with OpenTelemetry
- External Debugging Tools 3: JMXTerm
- Google Remote Procedure Call (gRPC) Example in Payara Server
- Using Git Interactive Rebase
- Cassandra Performance: Throughput, Responsiveness, Capacity, and Cost
- Confusing Java Strings
- Back to Basics: Accessing Kubernetes Pods
- Effectively Bridging the DevOps – R&D Gap without Sacrificing Reliability
- Exploring CVE-2022-33980: The Apache Commons Configuration RCE Vulnerability
- Faster Integration Tests with Reusable Testcontainers
- Java Bytecode Simplified: Journey to the Wonderland (Part 2)
- Backend-for-Frontend: The Demo
- When Disaster Strikes: Production Troubleshooting
- Building Secure CI/CD Pipelines with GitHub Actions for Your Java Application
- Deploy a Multi-Datacenter Apache Cassandra Cluster in Kubernetes (Pt. 1)
- Ignore Infrastructure: Concentrate on Code with Jakarta EE and Payara Cloud
- Creating a GraphQL API for Neo4j with Quarkus and SmallRye GraphQL
- External Debugging Tools 1: dtrace and strace
- Foojay Slack: bit.ly/join-foojay-slack
- What is a Java Uber-JAR and Why Is It Useful?
- Getting Started with Deep Learning in Java Using Deep Netts (Part 2)
- A Flavour of TornadoVM on Apple M1 Pro
- Write Your Own Service Discovery Client for Apache APISIX
- External Debugging Tools 2: git bisect
- Five Data Models for IoT: Managing the Latest IoT Events Based on a State in Apache Cassandra
- NoSQL Use Cases: When to Use a Non-Relational Database
- Stateless, Secretless Multi-cluster Monitoring in Azure Kubernetes Service with Thanos, Prometheus and Azure Managed Grafana
- How to Deploy a Vaadin Application to Google Cloud App Engine
- Discussing Backend For Front-end
- The Cost of Production Blindness
- Kubernetes and the Data Centre: Is Full Scale Migration Possible?
- General Build Distribution: A Game-Changer or a Gimmick?
- Released: OpenJDK 18.0.2, 17.0.4, 15.0.8, 13.0.12, 11.0.16, 8u342
- Why a Cloud-Native Database Must Run on K8s
- Remote and Distributed Build Patterns
- How to Secure Your Web Apps With An API Gateway
- Debugging Java Collections Framework Issues in Production
- Deserialization Exploits in Java: Why Should I Care?
- Journeys in Java, Level 6: Build a Neo4j Microservice
- Jakarta Concurrency: Present and Future
- The End of the Beginning for Apache Cassandra
- JDK 7: An Extended Hello and Farewell
- Taking VSCodium for a Spin
- Java on Azure Tooling Update – July 2022
- Debugging Gson, Moshi and Jackson JSON Frameworks in Production
- Available Now - gRPC for Apache Cassandra
- MicroStream - Part 5: Caching, Integrations and Clustering
- Getting Started with Deep Learning in Java Using Deep Netts
- Foojay Status Report: January – June 2022
- Understand Source Code – Deep into the Codebase, Locally and in Production
- MicroStream - Part 4: Serialisation Engine
- Top 7 Features in Jakarta EE 10
- Hard Things in Computer Science
- Spring Boot Performance Workshop with Vlad Mihalcea
- K8ssandra ramps up security features to match Kubernetes’ best practices
- MicroStream - Part 3: Storing Data
- Master-Detail with Hilla
- Java on Visual Studio Code - May Update
- Debugging jsoup Java Code in Production Using Lightrun
- Data Modeling in Cassandra and Astra DB
- Deep Learning in Java for Nuclear Physics using Deep Netts
- What I Miss in Java, the Perspective of a Kotlin Developer
- MicroStream - Part 2: Configure the Storage Manager
- Wordish with JavaFX - Part 5
- Java on Azure Tooling Update – June 2022
- Remote Debugging and Developer Observability
- Tombstones and Ghost Data Don’t Have to Be Scary!
- Building Project Panama's jextract tool by yourself
- Create Music Bingo Cards with iText
- My Summary of jPrime 2022
- Managing Distributed Applications in Kubernetes Using Cilium and Istio with Helm and Operator for Deployment
- How to Add an Event to the Foojay Event Calendar
- Wordish with JavaFX - Part 4
- Running Jekyll on a Mac
- MicroStream - Part 1: What is it?
- Debugging the Java Message Service (JMS) API using Lightrun
- How to Develop and Test an Automated CI/CD Workflow with Cassandra
- How DataStax Tracked Down a Linux Kernel Bug with Fallout
- Journeys in Java, Level 5: Building an Empire of Microservices
- What Can We Expect In OpenJDK 19?
- Optimizing Distributed Joins: The Case of Google Cloud Spanner and DataStax Astra DB
- Wordish with JavaFX - Part 3
- Embracing Java 17: Here’s What We Learned at Picnic
- Superfast Application Startup: Java on CRaC
- Memory Debugging and Watch Annotations
- Java Panama Polyglot (Rust) Part 4
- Book Review: "Monolith to Microservices" (Part 2)
- Wordish with JavaFX - Part 2
- Chopping the Monolith: The Demo
- Debugging Deadlocks and Race Conditions
- Why Developers Should Use Apache Pulsar
- Let's Compile Java Code in the Cloud!
- Book Review: "Monolith to Microservices" (Part 1)
- Wordish with JavaFX - Part 1
- Toying with Kotlin's Context Receivers
- Azure Toolkit for IntelliJ – April 2022 Update
- Diving into JVM Framework Monitoring and Profiling
- How to Publish a Java Maven Project to the Maven Central Repository
- How to do password hashing in Java applications the right way!
- Getting More Mileage Out of Kafka: OpenJDK vs. Azul Prime
- How to run the Java Incubator Module from the Command Line and IntelliJ IDEA
- Setting up and Working with Apache Tomcat in IntelliJ IDEA Ultimate
- Modernize Legacy Code In Production: Rebuild Your Airplane Midflight Without Crashing
- Conditional Builds on GitLab
- How to Enable Java Preview Features and Run Code from IntelliJ IDEA
- Spring Transaction Debugging in Production with Lightrun
- 5 More Reasons to Choose Apache Pulsar Over Apache Kafka
- Bring Streaming to Apache Cassandra with Apache Pulsar
- Easy Jakarta EE Integration Testing
- How To Submit Your Next Article On Foojay.io
- Securely Authenticate to Google Cloud from GitHub
- Debugging Collections, Streams and Watch Renderers
- Thinking About Massive Throughput? Meet Virtual Threads!
- Journeys in Java, Level 4: Building an Empire of Microservices
- Java Panama Polyglot (Python/Tensorflow) Part 3
- Chopping the Monolith
- Java on Visual Studio Code Update – April 2022
- Exception Breakpoint that Doesn't Suck and a Real Use Case for Method Breakpoints
- SQL vs. NoSQL: Pros & Cons
- Building a Fullstack IMDB Clone with a Java Backend using SparkJava and Neo4j
- Does Java 18 Finally Have A Better Alternative To JNI?
- How To Beautify Your GitHub Repo
- Introducing the OpenJDK "Coordinated Restore at Checkpoint" Project
- Java Panama Polyglot (Swift) Part 2
- Top 10 Java Language Features
- "Contrast Security Joins Foojay Advisory Board to Accelerate Java Developer Community Growth, Raise Security Perspective" — PR News
- How to Create APIs with the Java 18 jwebserver Ready for Docker
- Logging Best Practices: MDC, Ingestion, and Scale
- Migrating from Java EE to Jakarta EE with IntelliJ IDEA
- Quest to the OS: Java Native Memory
- Spring4Shell: Zero-Day RCE in Spring Framework Explained
- Java Panama Polyglot (C++) Part 1
- Examining the Switch Statement and the Factory Pattern in Three JVM Languages
- Three Mistakes Junior Software Developers Make Preventing Getting Hired On Amazing Projects
- How to Style a Vaadin Application
- Debugging JAXB Production Issues
- Handling Null: Optional and Nullable Types
- Hardware Acceleration For Java? TornadoVM Can Do It!
- Spring Remote Code Execution Vulnerability
- Quick Fire Java: Java After Log4j
- Observability for JVM Frameworks with Grafana in Java and Kotlin
- Increasing Event Streaming with Kafka and Azul
- Debugging Java Equals & Hashcode Performance in Production
- APISIX: An API Gateway the Apache Way
- Blink a LED on Raspberry Pi with Vaadin
- 5 Things You Probably Didn’t Know About Java Concurrency
- Full Stream Ahead: Astra Streaming, Powered by Apache Pulsar
- Debugging Race Conditions in Production
- What's New and Exciting in Java 18?
- Error Handling in Java and Across Different Languages
- All about Generics: Part 1
- Reaper 3.0 for Apache Cassandra is available
- Security Warning: Your Java Attack Surface Just Got Bigger
- The Basics Of Breakpoints You Might Not Know
- Interview with Tom Granot - Developer Observability, KoolKits and Reliability
- Visualization of the Message Flow between Business Functions with Vaadin and Neo4j
- 7 Reasons Why, After 26 Years, Java Still Makes Sense!
- Lessons learned from previous projects
- JDKMon 17.0.23 Released
- Have you upgraded to Cassandra 4.0?
- Detecting, Investigating and Verifying Fixes for Security Incidents and Zero Day Issues Using Lightrun
- Vaadin and jOOQ: Match Made in Heaven
- Hilla 1.0: A new Frontend Framework for SpringBoot
- Java Bytecode Simplified: Journey to the Wonderland (Part 1)
- Alternatives to DTO
- Journeys in Java, Level 3: Building an Empire of Microservices
- The Serverless Database You Really Want
- Why Pulsar Beats Kafka for a Scalable, Distributed Data Architecture
- Debugging Tutorial: Java Return Value, IntelliJ Jump to Line and more
- Java Thread Programming (Part 14)
- Kover: Code Coverage Plugin for Kotlin
- Avoiding Stringly-typed in Kotlin
- Introducing KoolKits: OSS Debugging Toolkits for Kubernetes
- Measuring Time and Duration in Kotlin
- Save Hours on your Setup of K8ssandra with the New Config Builder
- Project Panama for Newbies (Part 4)
- Use git bisect to Pinpoint a Bug
- Jakarta Concurrency: Present and Future
- Why we decided to build a K8ssandra Operator - Part 4
- Enter the Cloud Native Dojo: Blackbelt-Level Debugging
- Java on Visual Studio Code Update: February 2022
- Hand Ground Coffee: Command Line Tools for Java
- Controlling Electronics with JBang on the Raspberry Pi
- 7 Ways to Improve Your Code Reading Skills
- The Critical Role Streaming Plays in a Data Stack
- System Logger
- Foojay at FOSDEM 2022 on YouTube
- Journeys in Java, Level 2: Building an Empire of Microservices
- Playing practically with Stream API
- Cassandra Database Migration to Kubernetes with Zero Downtime
- Building Reactive Java Applications with Spring Framework
- Introducing 140 Second Ducklings: What is Debugging?
- Backpressure in Reactive Systems
- Debugging RAM: Detect/Fix Memory Leaks in Managed Languages - Heap Deep Dive (Part 2)
- Building Scalable Streaming Applications with DataStax Astra Streaming
- SQL vs. NoSQL: Pros & Cons
- Java Thread Programming (Part 13)
- Installing Java with SDKMAN on Raspberry Pi
- Deploying to Multiple Kubernetes Clusters with the K8ssandra Operator
- GoF Design Patterns Using Java - Part 02
- Video: SDKMAN Explained
- Backing up K8ssandra with MinIO
- Lights, Camera, Action: GitHub Actions with Java (Part 3)
- Friends of OpenJDK Schedule at FOSDEM 2022
- Create a CRUD UI in Pure Java
- Four Reasons Why Apache Pulsar is Essential to the Modern Data Stack
- Unboxing K8ssandra: The Data Layer For Your Kubernetes-Powered Applications
- Java Thread Programming (Part 12)
- The Flatten Maven plugin
- Journeys in Java, Level 1: Building an Empire of Microservices
- Treat Security as a Risk
- Java on Visual Studio Code Update – January 2022
- Java Thread Programming (Part 11)
- The State of Java in 2022
- Introduction to Maven Toolchains
- Statically Spilling Your (Spring) Beans
- Introducing the GKE Autopilot Cluster
- Taking Your Database Beyond a Single Kubernetes Cluster
- Polyglot Cloud Native Debugging: Beyond APM and Logging
- You're Running Untrusted Code!
- Kubernetes and Apache Cassandra: What Works (and What Doesn’t)
- Foojay Status Report: July – December 2021
- Template to Get Started with Pi4J and JavaFX on Raspberry Pi
- How to Put a Database in Kubernetes?
- Monitoring Spring Boot Applications (Part 1)
- Hype-Driven Development: Don't Be a Victim!
- Debugging RAM: Java Garbage Collection - Java Heap Deep Dive (Part 1)
- A Tentative Comparison of Fault Tolerance Libraries on the JVM
- Log4Shell Shows The Need for "Trustworthy Java"
- Hashcode and Equals: Debugging and Performance
- Requirements for Running K8ssandra for Development
- Why K8ssandra?
- MQTT on Raspberry Pi (Part 3): Sending sensor data from Raspberry Pi Pico to HiveMQ Cloud
- Simplify Migrating from Kafka to Pulsar with Kafka Connect Support
- JReleaser 0.10.0 Released!
- Different Approaches to Building Stateful Microservices in the Cloud Native World
- FXGL Game Engine 17 Released
- The State of Pattern Matching in Java 17
- New Survey Finds Data on Kubernetes Is No Longer a Pipe Dream
- The future of cloud-native databases begins with Apache Cassandra 4.0
- Santa Claus Issues YuleLog4J Advisory
- Java Modules in the Pi4J Project?
- Kubernetes Data Simplicity: Getting started with K8ssandra
- MQTT on Raspberry Pi (Part 2): Using MQTT and Raspberry Pi to Visualize Sensor Data on a TilesFX Dashboard
- Java Thread Programming (Part 10)
- Beautify Third-Party APIs with Kotlin
- Say Goodbye to Project Files in Visual Studio Code
- JDKMon 17.0.18 Released
- Java Logging: What To Log & What Not To Log?
- What is GitOps? What are its benefits?
- Build a Status Dashboard Using Spring Boot and Astra DB
- Build Web Apps in Pure Java with Vaadin Flow
- Log4Shell / Leak4J
- 7 Reasons to Choose Apache Pulsar over Apache Kafka
- MQTT on Raspberry Pi (Part 1): Send Sensor Data to HiveMQ Cloud with Java and Pi4J
- Fail-Fast: Best Strategy for Reliable Software?
- Java Thread Programming (Part 9)
- Log4j2 Isn’t Killing Java
- Native-image with Quarkus
- Log4Shell: Critical Log4j RCE Vulnerabilty - Update to Version 2.15.0
- JUnit 5 Display Names
- Fast JMS for Apache Pulsar: Modernize and Reduce Costs with Blazing Performance
- Adelphi: Apache Cassandra™ Testing Goes Cloud Native
- Build and Test Non-Blocking Web Applications with Spring WebFlux, Kotlin and Coroutines
- Multiple Spring Boot Applications in the Same Project
- JDKMon 17.0.17 Released
- Java Thread Programming (Part 8)
- Debugging the Technical Interview: Methods and Cheating
- Friends of OpenJDK at FOSDEM 2022
- JUnit 5 Testing Basics
- New Java 17 Features for Improved Security and Serialization
- Vaadin 22 Released with Quarkus Support and Stateless Fusion
- Why a Serverless Data API Might be Your Next Database
- Backing up K8ssandra with MinIO
- JReleaser 0.9.0 Released!
- Developer Productivity Masterclass: Interview With Leonid Blouvshtein
- Port Management in Local Kubernetes Clusters
- JUnit 5 Introduction
- Book Review: “Effortless Cloud-Native App Development Using Skaffold” (2)
- Developing an Enterprise-Level Apache Cassandra Sink Connector for Apache Pulsar
- K8ssandra: Production-Ready Platform for Running Apache Cassandra on Kubernetes
- Java Thread Programming (Part 7)
- Native-image with Micronaut
- Equals and Hashcode Implementation Considerations
- Understanding Apache Maven (Part 9): Versions in Maven
- Native-image with Spring Boot
- A List of Cache Providers
- SKP's Agile Cheatsheet : Part 03
- A Walk to Lazy Fetching With Hibernate and Spring Data JPA
- Java Thread Programming (Part 6)
- Production Horrors – Customer Miscommunication Leads to Ongoing Nightmare
- Lights, Camera, Action: GitHub Actions with Java (Part 2)
- 7 Reasons to Switch to OpenJDK 17 as a Jakarta EE Developer
- Working with Multiple Carets in IntelliJ IDEA
- Understanding Apache Maven (Part 8): Maven Plugins
- Visual Recognition for Chess with Deep Learning in Java on Android
- Streams Set Distinct Java Code Quiz
- Let’s Use Optional to Fix Method Contracts
- Book Review: "Why Programs Fail"
- Extending Third-Party APIs in Different Languages
- Understanding Apache Maven (Part 7): Configuring Apache Maven
- SKP's Agile Cheatsheet: Part 02
- Hazelcast + Kibana: Best Buddies for Exploring & Visualizing Data
- How Social Trends Help Me Fix Essential Vulnerabilities
- Production Horrors – Handling Disasters: Public Debrief
- JReleaser 0.8.0 Released!
- Kotlin and FaaS: An Impossible Union?
- Java Thread Programming (Part 5)
- VS Code Java September 2021 Update
- Understanding Apache Maven (Part 6): POM Reference
- SKP's Agile Cheatsheet: Part 01
- Lights, Camera, Action: GitHub Actions with Java (Part 1)
- Exception Chaos Java Code Quiz
- Debugging Tutorial 1 – Introduction: Conditional Breakpoints
- Choosing a Cache: Capabilities
- Java Thread Programming (Part 4)
- Discussion: State of Java 2021
- Announcing the 1.0 release of Language Support for Java on Visual Studio Code
- Git Archeology: Go Back & Forward in Time
- Understanding Apache Maven (Part 5): Dependencies in Maven
- Java Thread Programming (Part 3)
- PSA: The Risks of Remote JDWP Debugging
- Foojay Podcast #4: Why So Many JDKs?
- Reassessing TestNG vs. Junit
- Contributing to OpenJDK Mission Control
- Java: Where the Wild Code Isn't
- JavaFX Templates for Desktop Applications
- Book Review: "Effortless Cloud-Native App Development Using Skaffold"
- Faster Maven Builds (Part 2): Inside Docker
- Faster Maven Builds (Part 1)
- GlassFish & Payara Auto-Clustering: Running Jakarta EE Highly-Available Applications in the Cloud
- Getting Started with Jakarta EE 9: Jakarta EE 9.1
- Payara Platform October 2021 Survey
- Java Thread Programming (Part 2)
- The Costs of Hidden Logging
- JReleaser: Looking for Translation Contributions
- Understanding Apache Maven (Part 4): Maven Lifecycle
- Java Thread Programming (Part 1)
- Multiple Ways to Configure Spring
- Understanding Stack Traces and Debugging them Further
- Book Review: "Quarkus for Spring Developers"
- Understanding Apache Maven (Part 3): Maven Coordinates & POM Inheritance
- K8ssandra Performance Benchmarks on Cloud Managed Kubernetes
- JReleaser 0.7.0 Released!
- Arrays and Object Reference Java Challenge Code Quiz
- The Debugger Checklist (Part II)
- The State of JVM Desktop Frameworks: Jetpack Compose for Desktop
- Java 17 on the Raspberry Pi
- Compact Strings: Reclaim 25% of Java Heap Memory & Lower Your Cloud Bills
- Building Command Line Interfaces with Kotlin using picoCLI
- Thorntail Fat, Thin, and Skinny Approach for Running Microservice Java Applications
- The Debugger Checklist (Part I)
- VS Code Java August Updates: SpringOne Updates, UX Improvements, Community Feedback
- Annotation-free Spring
- Parallel Streams Java Code Quiz
- Getting Started with Java 17 and IntelliJ IDEA
- Project Panama for Newbies (Part 3)
- Timely Computation of Derived Values
- 8 Debugging Tips for IntelliJ IDEA Users You Never Knew Existed
- Daemon Thread Java Code Quiz
- Demystifying Memory Management in Modern Programming Languages
- Everyday Shortcuts in IntelliJ IDEA
- "Works with OpenJDK" Campaign
- Understanding Apache Maven (Part 2): POM Hierarchy and Effective POM
- Do Java/Jakarta EE Standards Matter?
- Function Calculation Java Challenge
- Foojay Podcast #3: Journey to Jakarta EE
- Pi4J V.2 Released!
- Tomcat and TomEE Clustering Automation
- Understanding Apache Maven (Part 1): The Basics
- Is the Java/Jakarta EE Deployment Model Out of Date?
- Looking For Free Docker Registries
- Better Error Handling for Your Spring Boot REST APIs
- Deep Learning in Java for Drug Discovery
- SolarWinds Hack And The Executive Order Of Cybersecurity: What Does This Mean For Us?
- Updating Data Files: Commits vs. Pull Requests?
- Is Java/Jakarta EE Cloud-Native?
- Project Panama for Newbies (Part 2)
- Stream Limit Filter Java Challenge
- VS Code Java July 2021 Update: New Testing Experience, Maven Improvements, and Product Roadmap Progress Update
- Book Review: "Help Your Boss Help You"
- Are Java/Jakarta EE Application Servers Heavy?
- Why You Should Upgrade to Maven Version 3.8.1 Today or Very Soon
- Schedule for Foojay Virtual OpenJDK 17+ JUG Tour
- Project Panama for Newbies (Part 1)
- JDK Mission Control 8.1.0 Released!
- New Book: "Practical Vaadin"
- No-Cost IBM Semeru Runtimes for Java
- SAST, DAST, IAST and RASP
- GitLab: Your Continuous Deployment One-Stop Shop
- JReleaser 0.6.0 Released!
- Are Java Security Updates Important?
- SKP's Definitive Primer: Failures, Pitfalls & Disadvantages of Microservices
- Getting Started with Snyk for Secure Java Development
- Is Java EE Outdated & Dead?
- Rust and the JVM
- Neo Stream Search Java Challenge
- Connect Stateful Workloads Across Kubernetes Clusters
- Foojay Podcast #2: Embedded Java
- Book Review: "Seriously Good Software"
- Virtual Foojay OpenJDK 17+ JUG Tour
- Jedi Lambda Join Java Challenge
- FXGL Game Engine 11.17 Release
- Get Your JDK As Easily As Possible!
- VSCode Java: Roadmap Update and New Features
- The Search for a Cloud-Native Database
- Best Practices for Data Pipeline Error Handling in Apache NiFi
- CVSS 101: First Steps with Common Vulnerability Scoring System
- A Case for Databases on Kubernetes from a Former Skeptic
- Learn JShell with JavaFX in 60 Seconds
- Foojay Podcast #1: Hello Foojay.io!
- The Lifecycle of a Security Vulnerability
- Do You Really Need Kubernetes?
- JDKMon: Your Friendly JDK Distribution Updater
- Soprano ofNullable stream Java Challenge
- Troubleshooting Java Processes Running on Your Machine
- JReleaser 0.5.0 Released!
- Why Kubernetes Is The Best Technology For Running A Cloud-Native Database
- Method Reference VS Lambda Java Challenge
- Java in Education: Combining Java with Raspberry Pi and the Pi4J Library
- Simplify Protocol Refactoring
- Optimizing Relational Database Access
- JMC 8.0.1 Released!
- Creating a JavaFX World Clock from Scratch (Part 6)
- How to Create Mobile Apps with JavaFX (Part 3)
- Debugging Java on the Command Line
- OpenJDK and the Future of Production Profiling
- Introduction to New AutoScale Feature Available in Payara Server
- Primitive Set Operations in Eclipse Collections — Part 2
- BlockHound: How It Works
- Apache Cassandra 4.0: Taming Tail Latencies with Java 16 ZGC
- New Book: "Taming Thymeleaf"
- JavaFX: June 2021 Community Update
- New JVM Ecosystem Report 2021 Has Arrived!
- How to Create Mobile Apps with JavaFX (Part 2)
- Game Development Basics with FXGL
- Jakarta EE Application Deployment to Kubernetes Cluster in Jelastic PaaS
- Concurrency in Java (and How it Compares with Other Modern Programming Languages)
- Hidden Dracula Polymorphism Java Challenge
- How to Create Mobile Apps with JavaFX (Part 1)
- Java Encryption and Hashing
- Foojay Status Report: January - June 2021
- Ken Fogel: "What Are You Leaving Behind?"
- Avoid Multithreading Bugs Using Immutable Java 16 Records
- JavaFX: Gluon Status Update, Dual Screen on Raspberry Pi Sample, IntelliJ New JavaFX Project Wizard
- New Java/JavaFX Library FXSkins Released
- JEP 411: What it Means for Java's Security Model and Why You Should Apply the Principle of Least Privilege
- Open Source Tools as an Opportunity for SMEs to Use AI?
- Book Review: "Java by Comparison"
- Asynchronous CompletableFuture San Francisco Adventure Java Challenge
- JReleaser 0.4.0 Released!
- Creating a Simple Spring Boot Application in IntelliJ IDEA
- Automatic WildFly Clustering in Managed Domain Mode and Scaling inside Containers
- Interviews with Robert Savage and Johan Vos on the State of Java on Raspberry Pi
- Hacking Third-Party APIs on the JVM
- Getting Started with Jakarta EE 9: Context And Dependency Injection (CDI)
- Jakarta EE 9.1 Released!
- FXGL Game Engine 11.16 Release
- Type Erasure Generics Java Challenge
- The Principle of Least Privilege and How JEP 411 Will Have a Negative Impact on Java Security
- Querying Your In-Memory-Data-Grid: Why and How?
- 🚀 Demystifying JVM Memory Management
- Creating a JavaFX World Clock from Scratch (Part 5)
- Controlling an LCD Display with Spring and Thymeleaf on the Raspberry Pi
- VS Code: Getting Better and Better for Java
- Map, Equals, Hashcode Java Challenge
- Sanitize All Input!
- Teeing: Hidden Gem in the Java API
- 7 Functional Programming Techniques in Java: A Primer
- Optional takeWhile dropWhile Java Challenge
- A Real-World Example of a Stream Collector
- Preventing YAML Parsing Vulnerabilities in Java
- Payara Services Wins Prestigious Queen’s Award!
- Elastic JVM: Configuring G1 GC for Automatic Vertical Memory Scaling
- Why Java Developers Continue to Rely on Jakarta EE
- Creating a Snake Game with JavaFX FXGL in Three Pair-Programming Sessions
- New Book: "Java Challengers"
- A Close Look at Kotlin's Delegation
- New to Java? Some Resources
- Fix Java Security Issues While Coding in IntelliJ IDEA
- Java Garbage Collection Types and Settings Customization via Jelastic PaaS
- Beginning JavaFX Applications with IntelliJ IDE
- GoF Design Patterns Using Java - Part 01
- An Example of Overengineering: Keep it WET
- JavaFX Running in Kiosk Mode on the Raspberry Pi
- Modern JavaFX Game Development with FXGL: Pong (Simple)
- 2021 Jakarta EE Developer Survey
- Getting Started with Jakarta EE 9: How to Create a REST API with Jakarta EE 9
- Hazelcast, from Embedded to Client-Server
- Namespace Shadowing (a.k.a. “Dependency Confusion”) Attack
- Building Microservices with Spring Boot Fat (Uber) Jar
- New Java Welcome Page for VS Code
- IntelliJ IDEA Changelists and Git Staging
- 8 Best Practices to Prevent SQL Injection Attacks
- Your own custom Spring Data repository
- Deep Dive Into Multi-Threading in Java
- Jenkins Cluster for Continuous Integration and Delivery (CI/CD) inside Jelastic PaaS
- Creating a JavaFX World Clock from Scratch (Part 4)
- Changing a Field's Type in Recent JDKs
- Getting Started with Jakarta EE 9: Hello World
- Java 16 and IntelliJ IDEA
- Creating a JavaFX World Clock from Scratch (Part 3)
- Java Ecosystem Survey 2021
- Java 16 Records: Data Carrier Classes
- Keeping Pace with Java Using Eclipse IDE
- A (Definitive?) Guide to LazyInitializationException
- Fabiane Bizinella Nardon Talks about Machine Learning and Disruptive Data Science
- Billion Events Per Second with Millisecond Latency: Streaming Analytics at Giga-Scale
- DevOps 101 Part III: Package Management
- Spring Boot and Java 16 Records
- Kicking Spring Native's Tires
- Secure Code Review Best Practices (Part 2)
- DevOps 101 Part II: Container Registries
- Highlights of New JEPs in Java 16
- Java Testing with VS Code
- Custom Controls in JavaFX (Part VII)
- Secure Code Review Best Practices (Part 1)
- Embracing JVM unified logging (JEP-158 / JEP-271)
- Download OpenJDK Today!
- DevOps 101 Part I: CI/CD
- How to Use Eclipse Transformer to Convert a 3rd Party Library to the New Jakarta Namespace
- "Foojay Announces Initial Companies Making Up Its Advisory Board" -- SD Times
- Custom Controls in JavaFX (Part VI)
- "Virtual Tour Is the Biggest Project Yet for the New Java Community Platform, Foojay" -- DZone
- Running Spring Boot Applications on OpenShift
- Virtual Tour Is Biggest Project Yet For New Java Community Platform Foojay
- Evolution of Java Memory Architecture (Post Java 7.0)
- Monitoring Across Frameworks: Spring Boot, Micronaut, Quarkus, and Helidon
- Introduction to JVM Unified Logging (JEP-158 / JEP-271)
- Deploying Spring Boot Applications on Kubernetes
- Custom Controls in JavaFX (Part V)
- Evolution of Java Memory Architecture (Pre Java 8.0)
- Towards Continuous Performance Regression Testing
- Delegation vs. Inheritance in Graphical User Interfaces
- Modules, Modules, Everywhere!
- Much Ado About Nothing in Java
- Payara Platform 2021 Survey
- Optional.stream()
- Schedule for Foojay Virtual JUG Tour
- Custom Controls in JavaFX (Part IV)
- Demystifying Google Container Tool, Jib: Java Image Builder
- MicroProfile OpenTracing with Jaeger
- Improved JFR Allocation Profiling in JDK 16
- Java Development with VS Code on the Raspberry Pi
- Custom Controls in JavaFX (Part III)
- Safe Writing to Files in IoT and Industrial Systems
- JCStress: Eliminate the Nightmare of Debugging Java Concurrency Bugs
- Generating Code with IntelliJ IDEA
- The SolarWinds Hack for Java Developers
- Welcome to VS Code for Java
- Custom Controls in JavaFX (Part II)
- "Foojay: A Place for Friends of OpenJDK" -- ADT Magazine
- OIDC Client with Mutual TLS Client Authentication
- Getting Started with DevSecOps
- Migrating Browser-Based Java Applets to IcedTea-Web using JNLP
- Creating Self-Contained Executable JARs
- Custom Controls in JavaFX (Part I)
- Azul, Datadog, DataStax, JFrog, Payara, and Snyk Form Inaugural Foojay Advisory Board
- Explaining Java Deserialization Vulnerabilities (Part 2)
- Creating a Kubernetes Operator in Java
- Virtual Foojay JUG Tour
- IntelliJ IDEA: Beyond The Basics
- A Compendium of 2021 Java & OpenJDK Predictions
- Explaining Java Deserialization Vulnerabilities (Part 1)
- Vert.x Example on the Raspberry Pi with a Virtual Potentiometer
- CI/CD Workflow for Spring Boot Applications on Kubernetes via Skaffold
- High Performance Rendering in JavaFX
- Hacking Java XML Input via External Entity Injection
- Preview of January 2021 OpenJDK Update Release
- 3 Ways to Refactor Your Code in IntelliJ IDEA
- Device Monitoring with JavaFX and FXGL
- How To Bring Your Java Microservices To The Cloud
- Friends of OpenJDK Schedule at FOSDEM 2021
- Java Syntax Puzzlers
- Local Variable Type Inference: Declare Var, Not War
- Java Predictions for 2021
- Containerizing Spring Boot Applications with Jib
- Java Predictions for 2021: Jakarta EE
- Java Predictions for 2021: Raspberry Pi
- 5 Tips to Create Secure Docker Images for Java Applications
- Creating a JavaFX World Clock from Scratch (Part 2)
- Light Up your Christmas Tree with Java and Raspberry Pi
- Avoiding NullPointerException
- Cloud Myth: Ahead of Time Compilation Will Save You Money
- Summer with Covid-19 in Australia, New Zealand and Polynesia
- Friends of OpenJDK at FOSDEM 2021
- Run WebSphere Liberty and Open Liberty on OpenShift
- How & When to Use JDK Flight Recorder in Production
- Creating a JavaFX World Clock from Scratch (Part 1)
- Separate Covid-19 Waves in Europe and South America
- Immutable Collections in Java with Sealed Types
- Creating CAD Applications with Java and JavaFX
- Minimizing Security Risks in Java Application Development
- Primitive Set Operations in Eclipse Collections
- Where is the 2nd Wave in Russia and China?
- What are Hidden Classes in Java 15?
- MicroProfile Metrics with Prometheus and Grafana
- Why I Love IntelliJ IDEA for Java Development
- The Second Wave Breaks in Europe
- Apple Silicon with Zulu OpenJDK and IntelliJ IDEA
- Native Applications for Multiple Devices from a Single JavaFX Project with Gluon Mobile and GitHub Actions
- IntelliJ IDEA Made Me Lazy
- Use Query Parameterization to Prevent Injection
- COVID-19 Time Series Analysis with Software EKG
- Announcing the Astra Service Broker: Tradeoff-Free Cassandra in Kubernetes
- Control JFR Programmatically
- 7 Ways to Contribute to OpenJDK
- Starting a JavaFX Project with Gluon Tools
- Run Oracle WebLogic Server on Azure Kubernetes Service
- For the Record!
- Getting Started with FXGL Game Development
- Avoid Java Serialization!
- Getting Started with Payara Server
- Continuous Production Profiling and Diagnostics
- How to Configure Your Java XML Parsers to Prevent XXE Attacks
- Analyze JFR Recordings
- OpenJDK, JDKs and Every Java Acronym in Between
- Securing Microservices with Auth0 and MicroProfile in Kubernetes
- "Foojay - All About Java and the OpenJDK" -- I Programmer
- Get Started with JDK Flight Recorder
- Spring Boot: Strategy Design Pattern - Convenience and Limitation
- OpenJDK vs. OpenJFX Release Cycles
- Handling JDK & GC Options Dynamically in Elasticsearch
- JavaFX 3D: A Look Back Through History & Some Experiments
- Live Templates in IntelliJ IDEA
- Evolution of Microservices
- Peter Lawrey Talks about Low-Latency, High-Performance Java
- Building OpenJDK from GitHub Sources on 64-bit Raspberry Pi
- Fixing Vulnerabilities in Maven Projects
- JDK 15 Hidden Classes
- What's New in the Payara Platform October Release?
- Cross-Platform Development in Java with Gluon and GraalVM (Part 2)
- Cross-Platform Development in Java with Gluon and GraalVM (Part 1)
- Faster & More Reliable 64-bit OS on Raspberry Pi 4 with USB Boot
- JDK 15 Sealed Classes
- Why You Should Join EclipseCon Community Day
- Quick Start with Machine Learning in Java
- Electronics & Micronaut Velocity with Raspberry Pi
- The Reason Java Was Invented
- New to IntelliJ IDEA? Me Too!
- 5 Minute Azure Survey: Java EE, Jakarta EE, and MicroProfile
- Electronics & Quarkus Qute on Raspberry Pi
- Getting Started with Babel for Java
- Timing Differences Between Compiling .java Code Files and Executing .class Bytecode Files
- WebLogic on Azure Virtual Machines Major Release Available
- Learning Java as a First Language
- Spectacular Java Projects on the Raspberry Pi
- A Simple Service with Spring Boot
- Azul Zulu OpenJDK 15 on Raspberry Pi
- Startup Speed of Spring and Quarkus JARs on the Raspberry Pi
- What's New in Java 15?
- What is JVM Bytecode?
- What's New in JavaFX 15?
- Useful JVM Options: Heap Sizing
- Redesigned Foojay Home
- Running Single-File Java Source Code Without Compiling (Part 2)
- Why the JVM Is a Brilliant Platform for New Programming Languages
- Running Single-File Java Source Code Without Compiling (Part 1)
- Interview: Frank Delporte, Foojay Raspberry Pi Community Manager
- Java 11 & JavaFX 11 on Raspberry Pi with ARMv6 Processor
- Introducing JmFrX: A Bridge From JMX to Java Flight Recorder
- Installing Java and JavaFX on the Raspberry Pi
- Interview: Java Command Line Switches
- 10 Basic Questions About PDF Files for Java Developers
- Performance: Stream.concat vs. New ArrayList
- Monitoring REST APIs with Custom JDK Flight Recorder Events
- Interview: Java Version Almanac
- Container Awareness for Java Developers
- A JavaFX App on ZuluFX in 60 Seconds
- Why Java, C, and Python Are Today's Most Utilized Programming Languages
- A Closer Look at JFR Streaming
- Is Java Still an 'Emerging Technology'?
- Sub-10 ms Latency in Java: Concurrent GC with Green Threads
- From Azure Active Directory via OpenID Connect to Open Liberty and Java
- Fantastic JVMs and Where to Find Them
- Highlights of Changes to the Core Java Platform
- Performance of Modern Java on Data-Heavy Workloads: The Low-Latency Rematch
- How does Java handle different Images and ColorSpaces – Part 4
- How does Java handle different Images and ColorSpaces – Part 3
- How does Java handle different Images and ColorSpaces – Part 2
- How does Java handle different Images and ColorSpaces – Part 1
- Performance of Modern Java on Data-Heavy Workloads: Batch Processing
- Performance of Modern Java on Data-Heavy Workloads: Real-Time Streaming
- Fun with Flags: My Top 10 Resources for JVM Flags
- JDK14: New Features and Enhancements
- Dashboard for OpenJDK Update Release Details
- foojay: A Place for Friends of OpenJDK