Home
Sitemap
- Home
- Java Version Almanac
- OpenJDK Terminology
- JVM Command Line Arguments
- OpenJDK 17 Command Line Arguments
- OpenJDK 18 Command Line Arguments
- OpenJDK 19 Command Line Arguments
- OpenJDK 20 Command Line Arguments
- OpenJDK 21 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
- Contributors
- Java Events
- Advisory Board
- Download OpenJDK
- OpenJDK Calendar
- Foojay.io AI Portal
- Friends of OpenJDK Today
- Video series “JavaFX In Action”, Part 5 with Cormac Redmond (KafkIO), Brian Schlining (Annotating the Deep-Sea Wildlife), Gerrit Grunwald (JavaFX Libraries), Dirk Lemmermann (JavaFX Libraries and Applications, JFX Central)
- How to Make a RAG Application With LangChain4j
- Understanding MCP Through Raw STDIO Communication
- 🚀 Document Your Spring Boot APIs with Redocusaurus in Minutes 🦕
- Getting Started With Scala
- Sustainability Starts with Your Runtime: Meet a Green JVM
- The Great Data Reimagination: From Static to Agile in the AI Era
- Testing an OpenRewrite Recipe
- Foojay Podcast #75: JCON Report, Part 4 - Tips and Tricks for Java Devs
- How I Improved Zero-Shot Classification in Deep Java Library (DJL) OSS
- Building a Spring Boot CRUD Application Using MongoDB’s Relational Migrator
- Prime Time: The High Performance Java Event
- CAP in the Pocket: Developing Java Applications on your Phone
- New AI Conference For And By Developers
- Carbon Aware Job Processing With JobRunr v8
- When ReadyNow Can Only Compile on Traffic Loads
- Data Modeling for Java Developers: Structuring With PostgreSQL and MongoDB
- Java 21+ Not Working on the Raspberry Pi Zero 2
- Kotlin adoption inside ING, five years later
- Java Virtual Threads in Action: Optimizing MongoDB Operation
- Foojay Podcast #74: JCON Report, Part 3 – AI, ChatGPT, LLM, ML, RAG, MCP, GenAI, and more!
- JavaFX Links of June 2025
- Improve Your Java Applications’ Startup and Compilation Speed with Optimizer Hub
- How to Identify the Underlying Causes of Connection Timeout Errors for MongoDB With Java
- Build a Sentiment Analysis API in Java with Quarkus and Local LLMs
- Benchmarking and profiling Java with JMH
- Clean and Modular Java: A Hexagonal Architecture Approach
- Save Time and Money by Reducing False Positives
- How to Train ReadyNow to Achieve Optimal Java Performance
- Multi-cloud Strategies With MongoDB Atlas
- Spring Boot + Kafka Streams: Event Routing & Testing
- Java, What's Old? Part I: Collections
- Book Review: Writing for Developers
- Ensuring Safe and Reliable AI Interactions with LLM Guardrails
- Your Complete Guide to Diagnose Slow Queries in MongoDB
- Sonar Connect Amsterdam 2025
- Foojay Podcast #73: JCON Report, Part 2 – Evolutions in the Java Language and Runtime
- How ReadyNow Improves Java Warmup Time
- Java Concurrency Best Practices for MongoDB
- Performance Best Practise No. 1: Optimize Database Operations
- Intro to RAG: Foundations of Retrieval Augmented Generation, part 2
- Authoring an OpenRewrite Recipe
- Faster Java Warmup: CRaC versus ReadyNow
- MongoDB Aggregation Framework: A Beginner’s Guide
- Java’s Structured Concurrency: Finally Finding Its Footing
- Cloudflare Tunnel for Home Assistant
- Foojay Podcast #72: JCON Report, Part 1 - Grow your career, public speaking, 30 years of Java, greener coding,...
- JavaFX Links of May 2025
- Getting a single value from a device's state in Home Assistant
- Brokk: AI for Large (Java) Codebases
- Testing MongoDB Atlas Search Java Apps Using TestContainers
- 10 Best Practises For Jakarta EE Performance Optimization
- Intro to RAG: Foundations of Retrieval Augmented Generation, part 1
- Azul and JetBrains Collaborate to Enhance Runtime Performance for Kotlin Workloads
- AI Test Generation: A Dev's Guide Without Shooting Yourself in the Foot
- Understanding BSON: A Beginner’s Guide to MongoDB’s Data Format
- How to send prompts in bulk with Spring AI and Java Virtual Threads
- How Deep Netts and Java AI Transformed Particle Physics at US DoE, Jefferson Lab
- Join the NLJUG JSpring Conference on Thursday, June 5
- How to Deploy a Vaadin Application as a WAR on Tomcat 11
- What is RAG, and How to Secure It
- Building a Real-Time AI Fraud Detection System with Spring Kafka and MongoDB
- Foojay Live @ JCON Köln
- Building Autopo: An AI-powered Open Source Application to Manage .po Files
- GenAI blood, sweat, and tears: Loading data to Pinecone
- Book Review: Raising Young Coders
- Building FormPilot: My Journey Creating an AI-Powered Form Filler with RAG, LangChain4j, and Ollama
- Local AI with Spring: Building Privacy-First Agents Using Ollama
- Semantic Search with Spring Boot & Redis
- You’re Invited to IntelliJ IDEA Conf 2025!
- Foojay Podcast #71: Celebrating 30 Years of Java with James Gosling
- Redis is now available under the AGPLv3 open source license
- Still Using JUnit Like It’s 2017? Learn What You’ve Missed—from the Team That Built It
- JavaFX Links of April 2025
- Supercharge Your Jakarta EE Skills with These Must-Read Guides
- IBM's Chief Java Architect Flies in from Canada to Share JVM Optimization Secrets—Will You Be There?
- Foojay Webinar Live Stream: Java's Place in the AI Revolution
- Improving Maven's dependency:analyze... or not
- Free Foojay.io Tickets for JCON EUROPE 2025, Cologne!
- Foojay Podcast #70: Celebrating 5 Years of Foojay
- Jakarta EE 11 Web Profile Released, Enabled by Eclipse GlassFish
- Async file IO with Java and io_uring
- Optimizing the Garbage Collector when Migrating Cloud Workloads
- Breaktime Tech Talks (Ep39): Why embedding models should match + Advice for starting a blog
- A Guide to Creating JavaFX Native Images
- Foojay Podcast #69: All Things Java at VoxxedDays Amsterdam
- Time to panic? AI and Cybercrime legislation is on your doorstep now
- Register for Foojay Webinar: "Java's Place in the AI Revolution"
- Mutation Testing in Rust
- The try block in Rust
- JavaPro Shout Out: "From Reactive Streams to Virtual Threads"
- Six JDK 24 Features You Should Know About
- Breaktime Tech Talks (Ep38): Spring AI Debugging + How to Contribute to Open Source
- Clean your Memory: From Finalize to Cleaner
- JavaFX Links of March 2025
- Video series “JavaFX In Action”, Part 4 with Mike Hearn (Conveyor), Sven Reimers (JTaccuino), and Chris Newland (DemoFX, JitWatch)
- One giant Kubernetes cluster for everything
- WebAssembly on Kubernetes
- Interview with Abdoulaye Wade Cissé: Using a JavaFX application as a virtual chemistry and biology lab
- Introduction to intermediate operations modeler: Stream Gatherers
- Breaktime Tech Talks (Ep37): Vector Database Frustration + Microsoft LazyGraphRAG
- Java 24 Rolls Out Today! Find Out Why It's Aptly Named
- Foojay Podcast #68: Welcome to OpenJDK (Java) 24
- Pull request testing on Kubernetes: testing locally and on GitHub workflows
- Pull Request testing on Kubernetes: Working with GitHub Actions and GKE
- Pull request testing on Kubernetes: vCluster for isolation and costs control
- Demo Application with CRaC and Loading Data in Memory
- Path Traversal Vulnerability in Deep Java Library (DJL) and Its Impact on Java AI Development
- Creating SBOMs with the Snyk CLI
- Code Reviews with AI: a Developer Guide
- Extending Java APIs - Add Missing Features Without the Hassle
- Book Review: DuckDB in Action
- SummarizingTokenWindowChatMemory: Enhancing LLM’s Conversations with Efficient Summarization
- JavaFX Links of February 2025
- Spring Cloud Stream: Demystifying Event-Driven Architecture
- Front End Debugging Part 3: Networking
- Building local LLM AI-Powered Applications with Quarkus, Ollama and Testcontainers
- Securing Vaadin Applications with Microsoft Entra
- Java 24 : What's New?
- Checking out Junie, a coding agent by JetBrains
- Sliding Window Counter Rate Limiter (Redis & Java)
- Foojay Podcast #67: Writing a book. Does it make you rich and famous?
- Pi4J Welcomes Java 21 on the Raspberry Pi
- Event-Driven Architecture and Change Data Capture Made Easy
- Webinar: Find Undead Code in Your Java Environments
- A Glance into JFR Class and Method Tagging
- Remote Development Made Simple with DevPod
- Building a Declarative API with Spring AOP and SpEL
- Foojay Podcast #66: Let's Talk About Java Code! Diving into a few Foojay blog posts...
- Spring Data Neo4j: How to update an entity
- Sliding Window Log Rate Limiter (Redis & Java)
- Join the Celebration of 30 Years of Java
- JavaFX Links of January 2025
- My first steps with Playwright
- A solution to the problem of cluster-wide CRDs
- Project Loom: Structured Concurrency - Java
- Token Bucket Rate Limiter (Redis & Java)
- Thinking differently about testing
- Receiving Mails in Java with IMAP or POP3
- Challenge yourself with Application Observability Code Challenges
- How JVM handles exceptions
- Fixed Window Counter Rate Limiter (Redis & Java)
- Foojay Podcast #65: Boost Your Career in 2025!
- The slow Death of the onjcmd Debugger Feature
- Reflections on 2024: A Remarkable Year for OmniFish, GlassFish, Piranha, and Jakarta EE
- An Example of HACS: Adaptive Lighting
- Rate limiting with Redis: An essential guide
- Make the Life of your Developer Client's Easier with Smart Object Builders
- Integrating Google Analytics With Vaadin Flow: A Step-By-Step Guide
- The Proper Way to Define Configuration Properties in Spring
- Encryption and Data Security Market Analysis: Market Analysis 2025
- 2024 in Retrospective: Nicolas Frankel
- Video series “JavaFX In Action”, Part 3
- AI-powered Chat Application using IBM watsonx.ai and Spring AI
- Pseudorandom Number Generator – The Secret Behind Santa's Gift Bag
- Incident Response Platform Comparison: Market Analysis 2025
- Java Conferences in 2025
- More Free Shells for your Java IDE
- JavaFX Links of December 2024
- Issues with old GlassFish server? Upgrade to Eclipse GlassFish!
- Foojay Podcast #64: Interviews at JFall about open source, OpenJDK evolutions, Project Loom, JVM, and more!
- Warp: the new CRaC engine
- Duplicate Finder for Text: Requirements
- Foojay Podcast #63: How do we keep our Java applications up to date and secure?
- Run a Java Lambda Function From a Docker image
- Speed up your Spring Batch with Native Image and GraalVM
- The Home Assistant Model
- Why Home Assistant
- Prevent LDAP injection in Java with SpringBoot
- Front End Debugging Part 2: Console.log() to the Max
- Foojay Podcast #62: Better Coding with AI: Friend or Enemy?
- JavaFX Links of November 2024
- Task Schedulers in Java: Modern Alternatives to Quartz Scheduler
- How Organizations Became Stuck on Outdated Java Versions
- GlassFish is rolling forward. What’s New?
- strace Revisited: Simple is Beautiful
- Langchain4J Musings
- Video series “JavaFX In Action”, Part 2
- Build and Run TornadoVM with IntelliJ IDEA
- Hot Class Reload in Java: A Webpack HMR-Like Experience for Java Developers
- Crafting Your Own Railway Display with Java!
- Foojay Podcast #61: As a developer, how do we keep our body and mind healthy?
- Why Java 8 is a Ticking Time Bomb Hiding Within Your Organization
- Summary of the AJAX Frameworks Comparison
- Spring Boot: Java Template Engine (JTE)
- Foojay.io At JFall 2024 (And The Winner Is...)
- Front End Debugging Part 1: Not just Console Log
- Effortless updates require a zero-migration policy
- Foojay Podcast #60: Proud Of Belgium - Devoxx, JobRunr, Timefold, OpenJDK Mobile, OpenJFX, Thymeleaf, and htmx
- How we almost missed a plane in Kazakhstan, but OpenJDK could have saved us...
- Exploring New Features in JDK 23: Module Design Pattern with JEP-476
- Java Tips # 01 - Writing Shebang Scripts in Pure Java
- JavaFX Links of October 2024
- The Art of Full Stack Debugging
- Learn About How Your Peers Use Java!
- Exploring New Features in JDK 23: Just-Write-And-Run prototyping with JEP-477 not only for beginners
- Vaadin: Battery-Included Server-Side AJAX Framework
- Foojay Podcast #59: DevRel Explained and How to Become a Conference Speaker
- Book Review: Mastering the Java Virtual Machine
- Deep dive into bits, bytes, shorts, ints, longs, signed, and unsigned with Java
- Changes Included in Release 24.08 of Azul Zing Builds of OpenJDK
- Profile IntelliJ IDEA with its own profiler
- Exploring New Features in JDK 23: Gatherers upgrades pipeline design pattern JEP-473
- Augmenting the client with HTMX
- Augmenting the client with Alpine.js
- Augmenting the client with Vue.js
- Exploring New Features in JDK 23: Builder Pattern Simplicity with JEP-455 Primitive Types in Patterns, instanceof, and switch (Preview)
- Unleashing the Power of Git Bisect
- Easily containerize Java applications with cloud native buildpacks
- FEPCOS-J: Implementing a Java Server and a Rust Client without Manual Network Programming
- Exploring New Features in JDK 23: Null object pattern to avoid null pointer exception with JEP-455
- Gear Up for NODES 2024: What to Know
- SQL Best Practices Every Java Engineer Must Know
- Foojay Podcast #58: How Java Developers Can Secure Their Code
- JavaFX Links of September 2024
- Azul Brings Java from Edge to Cloud
- Exploring New Features in JDK 23: Factory Pattern with Flexible Constructor Bodies with JEP-482
- Run true-to-production tests on your MicroProfile and Jakarta EE applications
- Server-Side Rendering with Spring Boot
- A Short History of AJAX and SSR
- TornadoVM for RISC-V Accelerators
- The Persistent Threat: Why Major Vulnerabilities Like Log4Shell and Spring4Shell Remain Significant
- Java: Where the Wild Code Isn't
- Java 23 Has Arrived, And It Brings a Truckload of Changes
- Foojay Podcast #57: Welcome to OpenJDK (Java) 23
- Health Check Response Format for HTTP APIs
- DRY your Apache APISIX config
- A Fresh Look at Embedded Java
- Press the Easy Button: Organize a Virtual Conference Schedule with a Graph Database
- Browserless Testing of Vaadin Applications with Karibu Testing
- Top Security Flaws Hiding In Your Code Right Now: And How To Fix Them
- Updating the Twelve-Factor app methodology: A call for participation
- Java 23: What’s New?
- Implementing the Idempotency-Key specification on Apache APISIX
- When (not) to write an Apache APISIX plugin
- How to profile a performance issue using Spring Boot profiling tools
- JavaFX Links of August 2024
- Four Easy Ways to Analyze your Java and Kotlin Code for Security Problems
- Get Recognized for your Cloud-Native Java Development Skills with this New Badge
- IBM Semeru Runtimes for Java includes FIPS 140-3 certified cryptography
- Debugging Kubernetes: Troubleshooting Guide
- Unsupported OpenJDK Distributions are at Risk of Non-Compliance with DORA
- Creating cloud-native Java applications with the 12-factor app methodology
- Running JavaFX applications on ARM with Azul Zulu
- OpenTelemetry Tracing on Spring Boot, Java Agent vs. Micrometer Tracing
- Connecting Resilience to Performance in Relation to OpenJDK
- Sustainable Software Engineering: Input Requested!
- Spring: Internals of @ComponentScan
- Are Critical Vulnerabilities Lurking in Your Java Ecosystem?
- Interview with a Java Champion: Reflections on a Storied Career and Insights for the Next Generation
- Defining patterns of data transfers for Java applications with TornadoVM
- DevIgnition with Foojay.io at Washington DC JUG
- The Impact of the EU DORA Act on Non-EU Financial Organizations
- Trash Pandas Love Enterprise Java Garbage Code
- Run AI-enabled Jakarta EE and MicroProfile applications with LangChain4j and Open Liberty
- Get Started With Allocation Profiling
- How does it feel to test a compiler?
- JavaFX Nodes versus Canvas
- Free tier API with Apache APISIX
- Differentiating rate limits in Apache APISIX
- Random and fixed routes with Apache APISIX
- Are Java Security Updates Important?
- Consequences of DORA on Java and OpenJDK with Azul
- JUG PH: 1H 2024 Meetups
- JUG PH: 1-Day Modern Java Development Bootcamp
- JavaFX Links of July 2024
- JManc 2024 Trip Report
- Video: Easy Implementation of a Client-Server Application in Java with FEPCOS-J
- Failure is Required: Understanding Fail-Safe and Fail-Fast Strategies
- Mastering Serverless Debugging
- Understanding JVM Memory Layout with OpenJDK24's New PrintMemoryMapAtExit VM Option
- Advanced URL Rewriting with Apache APISIX
- Creating a Command Line Tool with JBang and PicoCLI to Generate Release Notes
- Effective Java Logging
- Continuous Feedback Free Udemy Course: Additional Coupons Available
- New video series "JavaFX In Action", Part 1
- The Impact of the Digital Operational Resilience Act (DORA) on Java Investment with Azul
- Structured Concurrency is More Than ShutdownOnFailure
- Unsafe is Finally Going Away: Embracing Safer Memory Access with JEP 471
- 9 Best Java Profilers to Use in 2024
- Dynamic watermarking with imgproxy and Apache APISIX
- Dynamic watermarking on the JVM
- Wireshark & tcpdump: A Debugging Power Couple
- Foojay Podcast #56: Vectors in Java Code, Databases, and LLMs
- The Best Way to Handle Phone Numbers
- Java: Demystifying The Stream API - Part 3
- What's wrong with createDirectories() – A Beginner's Guide to IntelliJ Profiler
- beetRoot: Yet Another Web Framework?
- Step up your coding with Continuous Feedback: Free Udemy Course
- Foojay Podcast #55: Embedded Java, Part 2
- Master Your Journey in the School of OpenJDK Migration
- JavaFX Links of June 2024
- Renovate for everything
- How to Run Neo4j on Kubernetes
- Foojay Podcast #54: Music and MIDI with Java and Kotlin
- Example Java Application with Embedded Jetty and a htmx Website
- Exploring New Features in JDK 23: Simplifying Java with Module Import Declarations with JEP 476
- Even More Opentelemetry!
- Why is Kubernetes Debugging so Problematic?
- Java on Visual Studio Code May 2024 Update - New AI Feature, Spring Updates
- Foojay Podcast #53: JCON Report, Part 5 – CQRS, JOOQ, GraphQL, API, Vaadin, OpenRewrite, ErrorProne, Gateways, Proxies,...
- Book review: Frontend Development with JavaFX and Kotlin
- Debugger.godMode() – Hacking a JVM application with the debugger
- Vaadin 24.4 Adds React Support, In-App Coding Assistant
- Become a Better Java Developer: 19 Tips for Staying Ahead in 2024
- Foojay Podcast #52: JCON Report, Part 4 - Garbage Collectors, Intelligence Cloud, Test Containers and Flaky Tests, ToxiProxy, Structured Concurrency, Virtual Threads
- How to Identify Dependencies in Your Codebase During Microservices Migration
- Exploring New Features in JDK 23: Simplifying Java with Primitive Type Patterns with JEP 455
- Debugging Kubernetes Part 1: An Introduction
- Workflow, From Stateless To Stateful
- Java: Functional Programming f(x) – Part2
- Foojay Podcast #51: JCON Report, Part 3 - Persistence, Evolving your Career, Jakarta EE, GlassFish, Messaging via Telegram
- JavaFX Links of May 2024
- Who instruments the instrumenters?
- My opinion on the Tauri framework
- Five Java Developer Must-Haves For Ultra-Fast Startup Solutions
- Indexing all of Wikipedia, on a laptop
- Top 7 Java Microservices Frameworks
- The TornadoVM Programming Model Explained
- Exploring Cost-Effective Solutions for Stateful Rest Services
- Foojay Podcast #50: JCON Report, Part 2 - Maven, Software Security, Code Quality
- Evolutions in the Pi4J library by Tom Aarts and Robert von Burg
- Improve DevOps Productivity with Azul Intelligence Cloud for Any JVM
- Debug Unresponsive Apps
- Getting Started with JobRunr: Powerful Background Job Processing Library
- JManc Unconference 2024
- Foojay Podcast #49: JCON Report, Part 1 - JUGs, Communities, Open Source, Generative AI, LangChain4j, Machine Learning
- Calling Microservices in Java: Part 1
- A Modern Approach to Middleware with Chronicle
- NODES 2024: How to Submit a Technical Presentation
- The Vary HTTP Header
- Software Testing as a Debugging Tool
- Oracle Alternatives Survey & Report
- Hello eBPF: XDP-based Packet Filter (9)
- Diagnosing User-Reported Issues Using WireQuery
- Building a Simple Home Assistant using Langchain4j and Raspberry Pi
- SQL Query Optimization: How to Identify and Optimize Slow SQL Queries
- Spring AI: How to Write GenAI Applications with Java
- Duplicate Finder for Documentation
- Is your Java application ready for the next generation of server CPUs?
- Remotely Recording a JFR Log from a Container (Without Using the Command Line)
- Let's Replace the synchronized Keyword
- Why This JCON Europe Talk Is Unmissable (Part 2)
- Foojay Podcast #48: JUG Oberpfalz, JCON Conference, and JAVAPRO Magazine
- Writing a Data Orchestrator in Java
- Crowd-Publishing the 10x Java Dev Book
- Five ways to pass parameters to Apache APISIX
- JavaFX Links of April 2024
- Why This JCON Europe Talk Is Unmissable (Part 1)
- Java: Functional Programming f(x) - Part1
- The High Availability Features of Microservices using Chronicle Services
- Hello eBPF: Generating C Code (8)
- Using my new Raspberry Pi to run an existing GitHub Action
- Debug Without Breakpoints
- Debugging Using JMX Revisited
- Smarter Logging in Spring Boot with AOP
- Getting Started with bld
- Foojay Podcast #47: Artificial Intelligence and Machine Learning with Java
- Free Foojay.io Tickets for JCON EUROPE, Cologne!
- JUG Munich hosts the JCP Executive Committee meeting to 25th anniversary of JCP
- Hello eBPF: Auto Layouting Structs (7)
- Ensuring the right usage of Java 21 new features
- Calling Gemma with Ollama, TestContainers, and LangChain4j
- Effective cloud-native Java app development with Open Liberty in IntelliJ IDEA
- Search in Documentation with a JavaFX Chat LangChain4j Application
- 12 Text Tools For Developers
- Java on Raspberry Pi 5 with Pi4J
- Debugging Streams with Peek
- How to Detect Cache Misses Using Observability
- Changes Included in Release 24.02 of Azul Zing Builds of OpenJDK
- Records for Cleaner and More Expressive Parameterized Tests in JUnit 5
- Improving upon my OpenTelemetry Tracing demo
- Foojay Podcast #46: JUG Switzerland
- JavaFX Links of March 2024
- Aspect-Oriented Programming (AOP) Made Easy With Java
- Tips for reading code
- To Brussels, Canada and Back
- Apache APISIX North America Tour
- Spring: Internals of RestClient
- FEPCOS-J (4) Easy programming of a multithreaded TCP/IP server in Java
- The “Spring Way” of Doing Things: 9 Ways to Improve Your Spring Boot Skills
- Localize applications with AI
- Hello eBPF: Ring buffers in libbpf (6)
- Java 22 Is Here, And It's Ready To Rock
- Java 22: What’s New?
- Foojay Podcast #45: Welcome to Java 22
- How Oracle Separates Java Pricing from Value
- Increase readability and reduce complexity with Java's Pattern Matching
- Running JavaFX applications on the Windows Subsystem for Linux and more
- Foojay.io Mini Conference at Uber, Amsterdam
- Secure your API with these 16 Practices with Apache APISIX – part 2
- Secure your API with these 16 Practices with Apache APISIX - part 1
- TornadoInsight: Harness the Power of TornadoVM from IntelliJ IDEA
- Payara Cloud Hackathon is Open for Sign-ups!
- Hello eBPF: First steps with libbpf (5)
- Microservices Design Principles for Well-Crafted Architectures
- Why I moved my blog to RIFE2 after 23 years?
- Foojay Podcast #44: Quarkus Club
- JavaFX Links of February 2024
- Builders, Withers, and Records: Java’s path to immutability
- You’re Invited to IntelliJ IDEA Conf 2024!
- Foojay Podcast #43: Modern Java Testing
- Hello eBPF: Tail calls and your first eBPF application (4)
- 12 Lessons Learned From Doing The One Billion Row Challenge
- Cloud Cost Optimization Is Hard, Java Can Help
- Hardening Apache APISIX with the OWASP's Coraza and Core Ruleset
- Build Flexible Jakarta EE Applications With Apache CouchDB NoSQL Database
- Video: Spring Boot Testcontainers Support for Local Development
- State of Open (Source?!) and Free AI – a FOSDEM recap
- Top Most Detected Issues in Java Projects
- Minimize Costs by Utilizing Cloud Storage with Spring-Data-Eclipse-Store
- DTrace Revisited: Advanced Debugging Techniques
- Is JDWP's onjcmd feature worth using?
- The Evolution of Microservices with SOA: Navigating the Architectural Landscape
- Kicking the Tires of Docker Scout
- Sorting Text in Java, How Complicated Can It Be?
- OpenRewrite: Migrate to Spring Boot 3.2
- Foojay Podcast #42: Jozi-JUG and Cape Town Java Community
- Hello eBPF: Recording data in event buffers (3)
- Achieving High Throughput Without Sacrificing Latency
- JavaFX Links of January 2024
- Video: Spring Boot Docker Compose Support
- Building gdocweb with Java 21, Spring Boot 3.x and Beyond
- Friends of OpenJDK Hangout at FOSDEM 2024
- Foojay Podcast #41: Web Development with Java
- Book review: "Tidy first?"
- Java Flight Recording and Analysis with Azul Mission Control
- Microservices Architecture: Navigating the Buzz
- Benchmark JDBC Connectors and Java 21 Virtual Threads
- Controlling LED Strips with Java and JBang
- API Versioning
- Soft Assertions - testing kindly
- Hello eBPF: Recording data in basic eBPF maps (2)
- A Day in the Life of a Software Engineer in a Scrum Team Part-2
- Payara Platform Roadmap 2024
- Where do you get your Java?
- 2023 Software Conferences in the Philippines
- 2023 in Retrospective
- Foojay Podcast #40: Making Java Attractive for Beginners in Programming
- JUG PH: ING Partnership, Certification and Generative AI
- Journey of a Java Champion: Bert Jan Schrijver's Path to Mastery and Community Leadership
- Hello eBPF: Developing eBPF Apps in Java (1)
- Effective cloud-native Java app development with Open Liberty in the Eclipse IDE
- Interview with Gokul Chandrasekaran, the creator of JDoodle
- Looking Back on One Year of Speaking and Blogging
- Unlocking Scrum: A Software Engineer's Journey - Part 1
- (Semantic) Versioning your Java libraries
- Playing with WASM on Docker
- Foojay Podcast #39: Java Dominicana
- JavaFX Links of December 2023
- Securing Symmetric Encryption Algorithms in Java
- Using AI to Create JFR Event Descriptions
- When Should we Move to Microservices?
- Durable Subscription with JMS and Spring Boot
- Revolutionising Java Collections: The Advent of Sequenced Collections in Java 21
- Foojay Podcast #38: Java in the Cloud
- Five Apache Projects You Probably Haven't Heard Of (Yet)
- Book Review: Modern Frontends with htmx
- Handling security vulnerabilities in Spring Boot
- lntelliJ IDEA: Selectively Commit Changes to a File
- Writing C Code in Java
- Canary Releases with Apache APISIX
- Foojay Podcast #37: J-Fall Report, Part 4 (final)
- Book Review: The Software Engineer's Guidebook
- Integrate executable Java code in your blog posts, part 2: How to use dependencies
- Profiling Maven Projects with my IntelliJ Profiler Plugin
- FEPCOS-J (3) – Build native executables of Java-coded networked systems
- [Unit] Testing Supabase in Kotlin using Test Containers - PART 2
- Testing Spring Boot JMS with ActiveMQ Artemis and Testcontainers
- Foojay Podcast #36: J-Fall Report, Part 3
- Creating Executables For JavaFX Applications
- Chopping the monolith in a smarter way
- Who Killed the JVM? Attaching a Debugger Twice
- Couch to fully-observed code with Spring Boot 3.2, Micrometer Tracing, and Digma
- Effective Cloud-Native Development with Open Liberty in Visual Studio Code
- Foojay Podcast #35: Dublin JUG
- Virtual Event: JetBrains AI Launch Event
- The Theory of Debugging
- Exploring the OpenTelemetry Collector
- Video: Vaadin Drag & Drop Support. It's so easy!
- Strategies for Managing State in Chronicle Services
- JavaFX Links of November 2023
- Custom Events in the Blocky World: Using JFR in Minecraft
- Webinar: Harnessing the Power of AI Assistant in IntelliJ IDEA
- SpringBoot 3.2 + CRaC
- Foojay Podcast #34: J-Fall Report, Part 2
- Custom JFR Events: A Short Introduction
- Java for desktop applications: Tips and Tricks (Part 1)
- Video: "If I decide to stay with Oracle Java what issues will I face?"
- Feedback from calling Rust from Python
- Announcing the Build Server for Gradle Open-Source Repository
- Explore project structure with IntelliJ IDEA's Dependency Matrix
- Foojay Podcast #33: J-Fall Report, Part 1
- Unexpected Things That Make You a Senior Developer
- Preserving Software Continuity: Empowering Failover Strategies for Uninterrupted Operations
- Patterns For The Design Of Microservices – Part 3
- [Unit] Testing Supabase in Kotlin using Test Containers
- Live (re)compile, (re)load, (re)execute Java code in 100 LoC
- Loom is just HyperThreading in Java
- Digma, Apache APISIX, and OpenValue Sponsor Foojay.io at JFall 2023
- Payara Platform Surpasses 150,000 Monthly Users, Achieving Global Adoption Milestone
- Creating an OpenAPI Generator from Scratch: From YAML to JetBrains HTTP Client
- Integrate executable Java code in your blog posts
- How to find dead code in your Java services
- Foojay Podcast #32: Philippines JUG
- Generative AI and Java - hype or urgent reality?
- Python "magic" methods - part 2
- Python "magic" methods - part 1
- Putting JFR into Context
- GlassFish Embedded - a simple way to run Jakarta EE apps
- Controlling JIT Compiler Overhead to Avoid CPU Autoscaling
- JavaFX Links of October 2023
- Everything Bad in Java is Good for You
- Elevating Java Development in Visual Studio Code: Experience the New Build Server for Gradle
- Patterns For The Design Of Microservices – Part 2
- Book review: "Persistence Best Practices for Java Applications"
- JDWP, onthrow and a mysterious error
- Navigating Behaviour with Events
- Java 21 - JEP 445 - Unnamed Classes and Instance Main Methods
- Payara Makes a Splash at Devoxx Belgium 2023
- Resizing images on-the-fly
- Start using Java 21 in your apps on Open Liberty 23.0.0.10
- Book review: “Developing Apps with GPT-4 and ChatGPT”
- Domain-Deadline-Dog-Driven Development
- Not a Single Trace
- Beyond Pass/Fail- a Modern Approach to Java Integration Testing
- New: JDKMonitor
- The Files in JDK 21
- Level-up your Java Debugging Skills with on-demand Debugging
- Foojay Podcast #31: Report of Devoxx '23 in Belgium
- Book review: "Get Your Hands Dirty on Clean Architecture - Second Edition"
- FEPCOS-J (2) – Declaratively compose networked systems in Java
- State of the Software Supply Chain Report: Key Takeaways for Java Developers
- Send Your Logs To Loki
- Changes Included in the Stable release 23.08 of Azul Zulu Prime Builds of OpenJDK
- Patterns For The Design Of Microservices - Part 1
- How to Diagnose and Mitigate Pinning in Java's Virtual Thread Execution
- Debugging Tips and Tricks: A Comprehensive Guide
- Java 21 and the Upcoming Jakarta EE 11: A New Era of Cloud Native Java
- OpenJDK Migration Book Review
- How to Participate in the Foojay Community Certification Project
- Spring Boot and React in Harmony
- Contributing to Open Source: Hacktoberfest
- JVector 1.0
- Report of My Trip to JavaZone and Northern Germany
- Foojay Podcast #30: Utrecht JUG
- JavaFX Links of September 2023
- Web Crawling in Java: A Tale of Classical Threads and Virtual Threads
- C2 Might Be Slowing Down Your Builds
- The Systemic Process of Debugging
- Memory Management in Java: An Introduction
- Down the Rabbit Hole of an Apache APISIX Plugin
- How Software Companies Give Away Stuff for Free
- Visit Azul at Devoxx
- Foojay Podcast #29: How will AI and ML Influence the Role of Developers?
- Book Review: Get Your Hands Dirty on Clean Architecture
- Mastering the Challenges of OpenJDK Migration
- Eliminating Bugs Using the Tong Motion Approach
- New FXComponents Library Released
- Using JLink to create smaller Docker images for your Spring Boot Java application
- Monkey-patching in Java
- Easily Manage Different Java Versions on Your Machine with SDKMan!
- Exploring the Impact of Stack Size on JVM Thread Creation: A Myth Debunked
- Java 21 is Available Today, And It's Quite the Update
- Foojay Podcast #28: Java 21 Has Arrived!
- Exposing your data using Spring GraphQL
- New User Interface for JFX Central, the Home for All JavaFX Information – Part 2
- New User Interface for JFX Central, the Home for All JavaFX Information - Part 1
- Book Review: "OpenJDK Migration for Dummies"
- Book Review: "Java Basics: A Practical Introduction to Full Stack Java"
- Review: OpenJDK Migration for Dummies
- Building Real-Time Applications to Process Wikimedia Streams Using Kafka and Hazelcast
- System Architecture: Move Authentication to the API Gateway
- Extending Availability of IBM Semeru Runtimes V11 Beyond October 2024
- ArchUnit: Testing Your Architecture
- OpenRewrite: Automatic Code Refactoring and Maintenance - Part 2
- Chronicle Services: Building Fast Microservices with Java
- Five Ways to Use Gradle Enterprise to Identify and Manage Flaky Tests
- Disco API: Helping You To Find Any OpenJDK Distribution
- The Evolution of Bugs
- New JavaFX theme library "Transit" released
- Embracing Modernity: A Comprehensive Look at Sealed Classes, Pattern Matching, and Functional Paradigms in Java
- Gerrit and Ivar's North America JUG Tour!
- The New JdbcClient Introduced in Spring Framework 6.1
- Load Testing: Shoot Your Application With Gatling
- Ops friendly Apache APISIX
- OpenRewrite: Automatic Code Refactoring and Maintenance
- JUG PH: Continuing the Connection with the Java Enthusiasts
- Foojay Podcast #27: Chicago JUG and KUG
- Unlocking Java Wisdom: A Conversation with Oracle ACE Simon Martinelli
- Book review: "OpenJDK Migration for Dummies"
- It's 2AM Do you Know What Your Code is Doing?
- JavaFX Links of August 2023
- Azul Enhances ReadyNow to Solve Java’s Warmup Problem, Simplify Operations, and Optimize Cloud Costs
- Spring 6.1 - RestClient
- Configuring Spring Boot to Build a Docker Image with Azul Zulu and Debug Options
- Writing Testable Code: A Journey Through Consideration and Refactoring
- Three Key Elements to Incorporate into Your Flaky Test Remediation Approach
- How to Create a Spring Boot Application to Retrieve Data from Evernote
- Spring Boot: Local Development Enhancements, Let's Compose!
- Well Worth My Time: "OpenJDK Migration for Dummies"
- Debugging as a Process of Isolating Assumptions
- Exploring File Storage Solutions in Spring Boot: Database, Local Systems, Cloud Services, and Beyond
- Introduction to the Tower Library
- Testing and Local Development Made Simpler with Testcontainers Desktop App
- Generate AI-based Images with Quarkus and OpenAI DALL.E
- Is OpenJDK Just a Drop-In Replacement?
- Taming the Bias: Unbiased Safepoint-Based Stack Walking
- Thread-Safe Counter in Java: A Comprehensive Guide
- 6 Considerations when Building High-Performance Java Microservices with EDA
- Pitest: Do You Test Your Tests?
- My Final Take on Gradle (vs. Maven)
- Can't Reproduce a Bug?
- Pi4J Operating System for Java development on Raspberry Pi
- Working with GitLab Merge Requests in IntelliJ IDEA
- AsyncGetCallTrace Reworked: Frame by Frame with an Iterative Touch!
- Observing Java Applications Running via Docker Compose Using OpenTelemetry
- Sealed Interfaces and Pattern Matching: A Quick Dive into Java's Modern Capabilities
- We All Grow Older, But Do Our Projects Really Have To?
- Starting Apache Kafka - Java Producer & Consumer (Windows 10)
- Book Review: "OpenJDK Migration for Dummies"
- Reading the temperature, humidity, and pressure from a BME280 Sensor with Java, Pi4J, I2C, SPI, and JBang
- Preparing for JDK 21: A Comprehensive Overview of Key Features and Enhancements
- The Inner Workings of Safepoints
- Book Review: "Designing APIs with Swagger and OpenAPI"
- Book Announcement: "OpenJDK Migration Guide for Dummies"
- Java on Visual Studio Code – July 2023
- Starting Apache Kafka on Windows 10 (Kafka v3.4)
- JavaFX Links of July 2023
- Evaluating Apache APISIX vs. Spring Cloud Gateway
- The IKEA Effect
- When Speed Matters: Real-time Stream Processing with Hazelcast and Redpanda
- Busting Myths, Building Futures: A Conversation with Cay Horstmann on Java and Machine Learning
- Getting Started With Apache Camel On Jakarta EE 10
- Building for Failure: Best Practices for Easy Production Debugging
- Build Rot: The Hidden Technical Debt in Maven and Gradle Builds
- SnakeYaml 2.0: Solving the unsafe deserialization vulnerability
- How We Developed the Eclipse OpenJ9 CRIU Support for Fast Java Startup
- Contributing to Open Source Software: Creating a Pull Request
- JDK Safari: How To Find Hidden Tools in the JDK
- Dive into the OpenJDK: Top 10 Reads on Foojay.io
- Effective Coding with Java Observability
- GraphQL, JavaScript, Preprocessor, SQL and more in Manifold
- Reactive Database Access on the JVM
- I could write a blog post, or ...
- How to Share Your Work With a Video or Podcast
- Reactive Programming Made Easy
- Journeys in Java, Level 10: Service Discovery with Eureka
- Enterprise Java Application Development With Jakarta EE and Vaadin
- Charting the Course of Java: An Insightful Conversation with Java Champion, Sebastian Daschner
- Dissection of Joeffice: Open Source Office Suite in Java
- Java on Visual Studio Code – June 2023
- Sticky sessions with Apache APISIX - the demo
- Sticky sessions with Apache APISIX
- The Evolution of Java: Challenging Stereotypes and Embracing Modernity
- Understanding Security Vulnerabilities: A First Step in Preventing Attacks
- Billions of Messages Per Minute Over TCP/IP
- Exploring the Depths of Java: A Comprehensive Conversation with Jakob Jenkov, Part-II
- Running a CRaC Java application on Raspberry Pi
- A Dissection of Java JDBC to PostgreSQL Connections, Part 2: Batching
- Seven Reasons You Should Not Ignore Flaky Tests
- Foojay Status Report: July 2023
- Working on An Unfamiliar Codebase
- JavaFX Links of June 2023
- The Curious Case of Different Runtimes
- Exploring the Depths of Java: A Comprehensive Conversation with Jakob Jenkov, Part-I
- How to Optimise CPU Performance Through Isolation and System Tuning
- Time Machine: A Look-Back at Java Sessions from NODES 2022
- How to Upgrade to Jakarta EE 10 and GlassFish 7: It’s Much Easier Than You Think!
- Debugging OpenJDK Tests in VSCode (Without Losing Your Mind)
- Foojay Podcast #26: The Future of Source Control and CI/CD
- Why I prefer trunk-based development
- Introducing the Foojay.io Calendar API
- Building Custom Solutions vs. Buy-and-Build Software
- Exploring Java 21's Intriguing Additions: Unveiling New Features (Part 1)
- Manifold vs. Lombok: Enhancing Java with Property Support
- Foojay Podcast #25: Game Development with Java, JavaFX, and FXGL
- Report of My Small Tour d’Europe
- The Anatomy of a JVM
- Vaadin 24.1: Bringing You More Than Minor Improvements!
- Exploring Java Records In A Jakarta EE Context
- Unique Identifiers Based on Timestamps in Distributed Applications
- Java on Visual Studio Code – May 2023
- GitLab Pages Preview
- Breaking the Code: How Chris Newland is Changing the Game in JVM Performance!
- Operator Overloading in Java
- Preventing Cross-Site Scripting (XSS) in Java applications with Snyk Code
- Upgrade a Java 8 Project to 11 or Higher
- Neo4j's Online Conference Is Coming In October... And You're Invited!
- 2023 Community Survey
- Cracking Code and Conventions: An Exclusive Interview with Nicolas Fränkel
- Foojay Podcast #24: BeJUG, BruJUG and how Devoxx was born as JavaPolis
- Class Loader Hierarchies
- Java String Templates Today
- FP in Kotlin: Defining a Pipe Operator
- Java is Very Fast, If You Don’t Create Many Objects
- Resilience in Coding: Miro Wengner on Thriving in the Software Industry
- JavaFX Links of May 2023
- Boosting Similarity Search with Real-time Stream Processing
- 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 2024
- 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 and Join the CRaC Forum
- 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 19 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 2022 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
- 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!
- 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