Tools on foojay.io - Friends of OpenJDK

BoxLang AWS, Azure, and Google Secrets Manager Module Released

Tue, 21 Jul 2026 11:38:18 +0000

Every production application carries secrets: database passwords, API tokens, encryption keys. The question is never whether to manage them – it’s how badly the current approach is going to hurt you.

Hardcoded credentials in config files get committed to repos. Environment variables sprawl across deployment pipelines with no audit trail. Custom integration code for each cloud provider means three different patterns to maintain, test, and rotate. And when a key needs to rotate at 2am? Someone is waking up.

BoxLang 1.15.0 Released: Blazing Fast Strings, Runtime Portability, and much more

Tue, 14 Jul 2026 17:57:10 +0000

BoxLang 1.15.0 is a high-impact release with two big headlines and a long tail of hardening. The first headline is a massive performance upgrade to string handling : a new first-class BoxStringBuilder type, compile-time literal folding, smarter &= semantics, and a runtime concat strategy that automatically switches to builder-backed accumulation once your expression gets big enough. Your existing string-heavy code just got faster. No rewrites required.

The second headline is architectural. Every class loader in the BoxLang runtime and module system has been fully abstracted behind a pluggable IClassLoaderFactory interface. That single seam is what unlocks the Android runtime and Ahead-of-Time (AOT) compiled runtimes such as GraalVM Native Image that we have on the roadmap. The default behavior is unchanged, but the ceiling just got a lot higher.

BoxLang 1.14.0 : Navigate Anything: JSONPath Comes to BoxLang's DataNavigator

Thu, 02 Jul 2026 18:17:16 +0000

Every application eventually has to deal with deeply nested data. JSON API responses with payloads six levels deep. Configuration files where the key you need is buried inside an array of objects, one of which has a null for the field you thought was required. Module metadata structures that nobody wrote a schema for. Runtime introspection data shaped like a tree that grew without a plan.

BoxLang introduced DataNavigators in version 1 so you can use dataNavigate(), call .from() to scope down, chain your .get() calls, provide defaults everywhere. Clean and safe. But even with the fluent API, extracting a specific slice of a complex payload still required multiple navigator hops, or a loop, or defensive key-exists checks stacked three levels deep.

BoxLang 1.14.0 : Query Transformers - Take Full Control of Your Query Results

Wed, 24 Jun 2026 10:46:13 +0000

BoxLang 1.14.0 ships a lot of exciting features – Dynamic Sets, Ranges, Inner Classes, JSONPath navigation – but one quietly powerful addition will change the way you think about every database call in your application: Query Transformers, and this is just the start, we have plans for a whole lot more cool query features.

If you have ever executed a query and then immediately written a loop to reshape the result into what you actually needed, this feature is for you.

Foojay Podcast #99: Testing the Untestable: LLM Security for Java Developers with Tiberius

Mon, 22 Jun 2026 06:54:00 +0000

Your AI-powered Java application is live in production. But have you actually tested whether it can be jailbroken or manipulated into leaking data it should never reveal? In this episode, Iryna Dohndorf walks us through Tiberius, an open-source security testing library for LLM applications in Java, and explains why everything you know about unit testing needs a rethink when non-determinism is part of the design.

YouTube

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

BoxLang 1.14.0 : BoxSet is Here, BoxLang's New First-Class Set Type

Wed, 17 Jun 2026 10:36:28 +0000

BoxLang 1.14.0 ships with a new dynamic first-class Set type baked directly into the language. Not a wrapper you reach for manually, not a createObject( "java", "java.util.HashSet" ) incantation you paste from a Stack Overflow answer years ago. A real BoxSet with literal syntax, operator overloads, a full functional pipeline, change listeners, JSON serialization, and deep Java interop.

If you have ever deduplicated an array with a loop, compared two collections element by element, or modeled a permission system on top of a struct – Sets are the tool you were missing. Let’s dig in.

BoxLang AI 3.2.0 — Image Generation, Web Search, Fluent Audio, Agent Registry & MCP Observability

Tue, 02 Jun 2026 12:27:07 +0000

BoxLang AI 3.2.0 is here, and it’s a landmark release. We’re shipping five major features: image generation, web search, a fluent audio builder API, a centralized agent registry, and deep MCP observability along with a suite of analytics improvements and a critical bug fix. Let’s dig in. 🎉

🖼️ Image Generation — aiImage()

You can now generate images directly from BoxLang using any provider that supports text-to-image generation. The aiImage() BIF follows the same fluent, chainable philosophy as the rest of bx-ai then act on the result with expressive method calls.

Intro to the BoxLang Formatter

Thu, 28 May 2026 17:45:09 +0000

You know the drill. Someone opens a PR and half the review comments are about tabs vs spaces, where braces go, or why that one function has its arguments formatted differently from everything else. It’s noise. And it’s over.

The BoxLang Formatter is here, and it handles all of that for you.

You can find the docs here: https://boxlang.ortusbooks.com/getting-started/ide-tooling/boxlang-formatter

The BoxLang Formatter is a built-in code formatting tool that ships with BoxLang. It enforces consistent style across .bx, .bxs, .bxm, .cfm, .cfc, and .cfs files — automatically.

A New Generation of Java Libraries Is Born: Wasm Becomes the Implementation Detail

Tue, 26 May 2026 13:00:47 +0000

If you’re running JRuby in production, you’re running WebAssembly. If TrinoDB is evaluating your Python UDFs, that’s WebAssembly too. If Microcks is running JavaScript dispatchers to route your mock API responses, WebAssembly is doing the work.

You didn’t install a native binary. You didn’t configure JNI. You didn’t cross-compile anything for your target platform. It just works, because the Wasm module is hiding inside a regular JAR on your classpath.

Introducing bx-jwt: Enterprise-Grade JSON Web Tokens for BoxLang

Tue, 26 May 2026 10:14:00 +0000

JWT authentication is everywhere. But rolling it correctly — with proper algorithm enforcement, key management, clock skew handling, JWE encryption, and zero security footguns — is anything but trivial. Today, we’re shipping bx-jwt, a production-ready JWT/JWE module for BoxLang that handles all of it out of the box, so you can focus on building, not fighting cryptography.

bx-jwt is part of the BoxLang+ and BoxLang++ subscription tiers — our enterprise-grade module collection built for teams that take security seriously.

Introducing skills.boxlang.io — The Open Agent Skills Ecosystem for BoxLang & the Ortus World

Thu, 21 May 2026 11:42:26 +0000

Today we’re launching something we’ve been quietly building for months: skills.boxlang.io — a public, agent-agnostic directory for AI skills covering BoxLang, ColdBox, TestBox, CommandBox, and the entire Ortus ecosystem.

If you’ve ever pasted a 400-line system prompt into yet another AI agent, watched two of your bots drift onto subtly different versions of the same coding standard, or spent half a Friday afternoon trying to convince an LLM that BoxLang is not Java and is not CFML, or how to code for Modern CFML; this launch is for you. 🎯

BoxLang AI Series: Complete Guide to Building AI Agents

Thu, 14 May 2026 09:26:48 +0000

The world of AI development is moving fast, but building real, production-ready AI agents doesn’t have to be complex.

This series walks you step by step through how to design, build, and deploy AI agents using BoxLang AI. Whether you’re exploring AI for the first time or looking to modernize your current applications, these guides will help you move from concept to implementation with clarity.

Start Here: A Practical Overview

If you’re new to BoxLang AI or want to understand what’s possible before diving into the technical details, start here:

UCanAccess: The Modern Pure-Java Bridge to Microsoft Access

Wed, 06 May 2026 08:44:00 +0000

Microsoft Access databases are everywhere. Decades of .mdb and .accdb files silently power spreadsheets, small business applications, and legacy data stores across organizations of all sizes. Yet for Java developers, connecting to these files has historically meant wrestling with native Windows libraries, ODBC bridges, and platform-specific hacks.

UCanAccess puts an end to that. It is an open-source, pure-Java JDBC driver that lets you read and write Microsoft Access databases (.mdb and .accdb) just like any other SQL database — no native drivers, no Windows dependency, no friction.

BoxLang AI Deep Dive — Part 4 of 7: Middleware — The Missing Layer in Every AI Framework 🧵

Thu, 23 Apr 2026 14:25:53 +0000

BoxLang AI 3.0 Series · Part 4 of 7

Here’s the question every team eventually asks about their AI agents: how do we test these things?

Agents make live LLM calls. They invoke real tools. They have non-deterministic outputs. Standard unit testing approaches fall apart. You can’t mock every provider. You can’t replay a conversation from three weeks ago. You can’t confidently tell stakeholders that the agent you deployed today behaves the same way it did when you signed off on it.

Eliminating Flaky Tests to End World Hunger

Thu, 23 Apr 2026 09:02:34 +0000

Rita Mae Brown once said:

Insanity is doing the same thing over and over again and expecting different results.

However, everyone has at least once experienced a test that failed and then passed in the next run without changing the code or the environment. In software engineering, we don’t call it insanity; we call such unpredictable failures flaky tests. At first, they may seem like minor problems, but like clutter in a junk drawer, they become worse over time if you never take care of them.

Grails Is Back: Inside the Apache Software Foundation Migration

Wed, 25 Mar 2026 08:30:21 +0000

Steve Poole | With contributions from James Fredley, Apache Grails PMC Chair

For a technology that many people filed under “legacy,” Grails has been unusually active. While much of the industry’s attention has drifted toward newer frameworks and shinier stacks, something more deliberate has been happening in the background.

Grails has been moving into the Apache Software Foundation (ASF), modernising and positioning itself for the next chapter.

If you have not looked at Grails recently, your mental model is likely several years out of date. And that, in many ways, is exactly the problem.

TestBox 7: Real-Time Feedback, a Browser-Based IDE, and Modern Testing Workflows on the JVM

Tue, 24 Mar 2026 16:58:53 +0000

TestBox 7.x focuses on improving testing workflows for BoxLang and CFML applications. This release introduces improvements to the BoxLang CLI runner , real-time streaming test execution via SSE , dry run capabilities, a browser-based TestBox RUN interface, and several developer experience enhancements.

Check out the what’s new here: https://testbox.ortusbooks.com/readme/release-history/whats-new-with-7.0.0

TestBox RUN: A Browser IDE for Your Tests

The centerpiece of TestBox 7 is TestBox RUN : a self-hosted, single-page web app (bx/tests/index.bxm) that you drop into any BoxLang project and open in a browser. No build toolchain. No external service. Just BoxLang.

Introducing the BoxLang IDE Plugin for IntelliJ

Tue, 10 Mar 2026 14:25:33 +0000

The IntelliJ ecosystem is one of the most powerful development environments for JVM developers. Today, we’re excited to introduce the official BoxLang IDE plugin for IntelliJ , bringing modern BoxLang development directly into the JetBrains IDE family.

Whether you’re building new BoxLang applications or maintaining existing CFML codebases, this plugin gives you first-class tooling inside IntelliJ.

Installing the Plugin

Installing the plugin is easy from the JetBrains Marketplace.

BoxLang Homebrew Installer Released

Tue, 03 Mar 2026 12:34:03 +0000

We’re excited to announce the official BoxLang Homebrew tap — the easiest way to get BoxLang up and running on macOS (and Linux with Homebrew). One command, and you’re in business.

Getting Started

First, make sure you have Homebrew installed , then add our tap:

brew tap ortus-boxlang/boxlang

From there, choose your installation path.

Option 1: BVM — BoxLang Version Manager

If you want to manage multiple BoxLang versions side by side, BVM is your tool.

From “Crypto AI” to general AI: Do AI agents dream of electric langoustines?

Mon, 23 Feb 2026 18:11:54 +0000

A Blade Runner riff for a world where the lobster ships paid endpoints while humans still argue about the roadmap.

The shift that matters for agent commerce - From “Crypto AI” to general AI

Today, you can search the web all day and never see an invoice.

That happens because you are not the paying client.

The commerce runs through ads, affiliate deals, and platform incentives, so results often optimize for who pays, not for what you asked for.

BoxLang NeoVim Plugin Released

Wed, 18 Feb 2026 14:51:35 +0000

We’re excited to announce the release of the BoxLang NeoVim Plugin - a comprehensive syntax highlighting solution designed specifically for BoxLang developers working in Vim and NeoVim environments. This isn’t a port or adaptation of existing CFML syntax files; it’s a ground-up implementation built for BoxLang’s modern feature set. Coming soon as well will be our runners, syntax validators, and integration with our LSP for live previews, insights, and much more.

Unikernel: Profiling and Troubleshooting JVM on Nanos Unikernel

Wed, 11 Feb 2026 13:50:41 +0000

Profiling a Java Application Running Inside an Unikernel with JProfiler

Unikernels are often associated with minimalism and tight resource control.

But can we profile a Java application running inside a unikernel using a standard JVM profiler?

The answer is yes.

In this guide, we will walk step by step through profiling a Quarkus

application running inside a Nanos unikernel using JProfiler and
IBM Semeru JRE 25 (OpenJ9).

No special hacks. Just standard JVM tooling.

Not a Lucid Web3 Dream Anymore: x402, ERC-8004, A2A, and The Next Wave of AI Commerce

Fri, 09 Jan 2026 16:05:58 +0000

This article is for technically savvy readers, especially developers, protocol designers, and product teams working with AI agents, APIs, or crypto rails, who want a clear view of how these areas connect.
It explains how x402, ERC-8004, and agent discovery layers turn APIs and agents into small usage-based businesses, and what that means for real systems over the next 1–3 years.

Vocabulary for this article

In this article, I use the term micro business for a very small overall business, and nano business for a single x402-priced endpoint or agent that earns on its own from per-call payments in stablecoins.

AP2 (Agent Payment Protocol): AP2 defines how agents pay each other. It standardizes how a service quotes a price, how payment is confirmed, and how both sides record what was bought, so payments fit directly into automated agent workflows. In practice, it is a protocol that lets one machine pay another machine for work, without a human in the loop.

A2A (Agent-to-Agent communication): A2A covers how agents talk, pass context, and coordinate work. It lets agents call each other, exchange structured messages, and chain tasks instead of acting as isolated scripts.

x402: x402 is an HTTP-based payment protocol for APIs. A server responds with status 402 Payment Required, the price, and a payment route, and the client pays by using stablecoins on-chain and then retries the request to get the result.

ERC-8004 (8004): ERC-8004 standard is an on-chain registry for agents. It gives each agent an identity and a place to store reputation data, so other agents and tools can decide whom to trust and which services to call.

Foreword

x402 and ERC-8004 .

TornadoInsight - Compatibility with TornadoVM SDK 2.0+ & Configuration Guide

Tue, 30 Dec 2025 09:00:00 +0000

This blog updates the previously published TornadoInsight configuration ++guidelines++ and explains how to configure the required environment variable to ensure that TornadoInsight correctly detects the TornadoVM SDK when IntelliJ IDEA is launched from a graphical environment.

Overview

TornadoInsight requires access to a compatible Java Development Kit (JDK) and the TornadoVM SDK.{#o7o5c20810}

Important update:{#mvwo920904}

Since version ++v1.4.0++ , TornadoInsight can also use the JDK configured directly in IntelliJ IDEA via Project Structure. This means that, in many cases, users no longer need to configure the Java SDK in the plugins settings.{#welj420814}

Getting Started with TornadoVM 2.0 for Accelerating Java Applications

Mon, 22 Dec 2025 10:00:00 +0000

Starting with TornadoVM 2.0 , installing and using TornadoVM is easier than ever. The project now provides prebuilt SDKs for multiple operating systems, architectures, and accelerator backends, and is also available via Maven Central for seamless integration with existing Java codebases.{#viewer-bsvyh182}

This guide walks you through:{#viewer-aq221189}

Installing the TornadoVM SDK
Verifying your setup
Integrating TornadoVM into Java projects using Maven

Prerequisites

Before installing TornadoVM, ensure that your system has the following:{#viewer-k00hu10420}

Announcing bx-ldap: Enterprise LDAP for BoxLang

Tue, 16 Dec 2025 17:01:13 +0000

We’re excited to announce the release of bx-ldap, a comprehensive LDAP module that brings enterprise-grade directory access to BoxLang! This module goes above and beyond traditional CFML LDAP implementations, offering modern features like connection pooling, event-driven programming, multiple return formats, and a clean, intuitive API.

Note: bx-ldap is a premium module available exclusively to BoxLang +/++ subscribers.

🎯 Why?

Whether you’re integrating with Active Directory, OpenLDAP, or any LDAP-compliant directory service, bx-ldap makes it simple and powerful. From basic queries to complex directory operations, this module handles it all with grace and performance.

BoxLang RSS : Full-Featured RSS/Atom Feed Module for BoxLang

Tue, 02 Dec 2025 11:19:11 +0000

We’re thrilled to announce the release of bx-rss, a comprehensive RSS and Atom feed module that brings powerful syndication capabilities to BoxLang ! Whether you’re building a content aggregator, publishing a podcast, or exposing your application’s data as feeds, bx-rss makes it incredibly simple.

Thanks To Ray Camden

I just want to thank you to Ray Camden for his contributions to this module. Thanks Ray! You rock!

Why bx-rss?

In today’s interconnected web, RSS and Atom feeds remain crucial for content distribution and syndication. From blog posts and news articles to podcasts and video channels, feeds power how content flows across the internet. The bx-rss module brings enterprise-grade feed capabilities to BoxLang with an elegant, easy-to-use API.

Beyond Keywords: Implementing Semantic Search in Java With Spring Data (Part 1)

Thu, 16 Oct 2025 13:39:59 +0000

Building a semantic movie search app with embeddings and vector queries

Have you ever tried to search for something such as a product, a song, or a movie but couldn’t quite remember its exact name? Maybe you recall only a clue—a desert pyramid, a short melody, or “that ship that hit an iceberg.” Keyword search struggles with that. Vector search doesn’t: It lets you search by meaning.

It works by turning text into embeddings, vectors (arrays of numbers) that capture semantic similarity, so results are ranked by what they mean, not just what they say.

New Java Benchmark for Coding LLMs puts GPT-5 at the top

Mon, 18 Aug 2025 08:06:40 +0000

The Brokk Power Ranking is a new open-source coding benchmark , featuring 93 tasks from large, real-world codebases. You can check out the current Power Ranking here .

SWE-bench is the closest thing we have to a standard, objective benchmark for LLM coding performance, but it has a bunch of issues, the largest of which are that it’s Python-only, and it’s old enough that almost certainly some labs are now training to the test. (Epoch AI has a great writeup on the more subtle problems with SWE-bench if you want to go deeper.)

New Features in Jakarta EE 11, with Examples

Mon, 11 Aug 2025 06:40:56 +0000

Jakarta EE 11 is a major update in the enterprise Java world. It offers key changes that enhance developer productivity and modernize the platform.

This release introduces several new features and improvements. These streamline workflows and integrate the latest Java advancements.

Key Features of Jakarta EE 11

Java 21 Virtual Threads : This update introduces Virtual Threads from Java 21. They enable lightweight concurrency for handling thousands of simultaneous tasks. This improves performance and scalability. Learn more about Java 21 Virtual Threads .
Jakarta Data : This new specification simplifies database access with the repository pattern, which reduced a lot of boiler plate code. Explore more about Jakarta Data .
New features in existing APIs: Several APIs were updated to enhance existing features or add new features. For example. Jakarta Persistence 3.2 saw a lot of improvements (see the long list here or an article about most of them here . Many other APIs like Concurrency, Security, Faces, Servlet, or CDI received many enhancements as well.
Java 17+ Compatibility: This release aligns with Java 17 and 21. Besides virtual threads, it also supports Java Records introduced in Java 17. This ensures developers can leverage the latest Java features and run on up-to-date Java versions.
Modernized APIs: Jakarta EE 11 also replaces outdated Managed Beans with CDI and removes SecurityManager references. This aligns the platform with current best practices and Java features.

These updates focus on streamlining workflows. They improve performance and integrate modern Java features. This makes Jakarta EE 11 a powerful choice for enterprise and cloud-native applications.

Save Time and Money by Reducing False Positives

Mon, 23 Jun 2025 08:35:27 +0000

Recently Azul announced that AVD (Azul Vulnerability Detection), which is our solution to scan for security vulnerabilities in production, now comes with a new feature that only makes it possible to identify vulnerable components on a JAR file level but also on class file level.

The Production Scanning Challenge

So what does that mean? Usually, security scanners work in environments from development up to CI/CD, but not in production. The main reason for that is the fact that once you start scanning for vulnerabilities in production, the scanning process itself needs too many resources, which brings down the performance of the system. The performance decrease can be in the range of 10 to 30%, which explains why companies trust security scanners that scan in CI/CD and don’t add additional scans in production.

Getting a single value from a device's state in Home Assistant

Sat, 31 May 2025 09:27:38 +0000

I recently acquired Netatmo smart radiator valves to manage my rooms’ temperature remotely. I’m not skilled at manual tasks, but I could easily replace the old thermo-static valves. I then registered the smart ones in the Netatmo app. Finally, I integrated them in my Home Assistant via the dedicated Netatmo integration . Everything was very straightforward.

I noticed that each valve not only allows remote control but also offers a state with several attributes. I wanted to extract the room’s temperature indicator from it. It was not as easy as I thought it was, so I want to describe how I managed to achieve it.

Brokk: AI for Large (Java) Codebases

Fri, 30 May 2025 04:39:44 +0000

There are two reasons that AI makes mistakes writing code:

The LLM just isn’t smart enough to tackle the problem effectively, and it simply gets the answer wrong.
The AI doesn’t know enough about the relationships and dependencies of the code it’s editing, so (best case) it hallucinates APIs that don’t exist or (worse, because more subtle) it solves the problem in an awkward way that increases technical debt.

The first category is small, but it does still exist; e.g., concurrent data structures remain challenging for today’s models to get right the first time. AI labs will continue to make progress on this.

10 Best Practises For Jakarta EE Performance Optimization

Thu, 29 May 2025 13:44:01 +0000

With this article, we start a series where we compiled 10 best practices for performance optimizations and suggestions how to implement them using Jakarta EE & Eclipse GlassFish .

Enjoy reading this initial overview and watching the video about performance tuning Java applications, and stay tuned for upcoming articles from our OmniFish team that will go into details about each best practice.

To make your Jakarta EE applications faster and more efficient, here are 10 proven best practices you can easily implement:

How Deep Netts and Java AI Transformed Particle Physics

Mon, 19 May 2025 10:58:34 +0000

At the intersection of nuclear physics and artificial intelligence, Jefferson Lab is leveraging Java-based AI to overcome one of the most computationally intense challenges in modern science: reconstructing particle trajectories from high-frequency electron scattering experiments.

Each second, over 16,000 interactions are recorded as particles pass through a complex array of drift chambers. Traditional reconstruction methods—based on mathematical likelihood calculations—must sift through thousands of signal combinations to identify valid particle tracks. The result? Up to 300 milliseconds of processing per event on a single core, leading to massive compute demands.

Semantic Search with Spring Boot & Redis

Mon, 05 May 2025 15:35:55 +0000

TL;DR: You’re building a semantic search app using Spring Boot and Redis. Instead of matching exact words, semantic search finds meaning using Vector Similarity Search (VSS). It works by turning movie synopses into vectors with embedding models, storing them in Redis (as a vector database), and finding the closest matches to user queries.

A traditional searching system works by matching the words a user types with the words stored in a database or document collection. It usually looks for exact or partial matches without understanding the meaning behind the words.

Creating SBOMs with the Snyk CLI

Fri, 07 Mar 2025 12:25:36 +0000

The software bill of materials (SBOM) is quickly becoming an essential aspect of open source security and compliance. In this post, we’ll delve into what SBOMs are, why they’re necessary, and their role in open source security.

What are SBOMs?

A software Bill of Materials (SBOM) is a comprehensive inventory of all components used in a software product. They include all the necessary details about each component, such as their names, versions, and licensing information. SBOMs can be seen as the ingredients list for software, providing complete transparency into what makes up a software product.

Sliding Window Counter Rate Limiter (Redis & Java)

Tue, 25 Feb 2025 21:21:11 +0000

This content is also available on YouTube. Check it out!

The Sliding Window Counter offers a more efficient way to handle rate limiting compared to the Sliding Window Log. While the Sliding Window Log keeps an exact log of timestamps for each request, allowing precise tracking over a rolling time period, this precision comes at the cost of higher memory usage and computational overhead as the number of requests increases.

AI-powered Chat Application using watsonx.ai and Spring AI

Fri, 03 Jan 2025 08:31:51 +0000

Generative Artificial Intelligence (Gen AI) disrupted enterprises with the introduction of GPT-4 foundation model by Open AI in the late 2022 to early 2023 triggering big tech to release their own Gen AI platform and foundation models. Among them are Google, Microsoft, AWS and IBM. In this article, we will deal with the Gen AI platform and model of IBM called watsonx and integrate it with Spring AI to create a custom chat application using the IBM Granite Foundation Model.

Speed up your Spring Batch with Native Image and GraalVM

Tue, 10 Dec 2024 15:47:53 +0000

Spring Batch is often used for data processing jobs that don’t run continuously. Instead, they start, process, and stop,which makes them a perfect candidate for GraalVM Native Image. Unlike traditional Java applications that require a long JVM startup time, Native Images execute almost instantly, giving a significant performance boost.

In this article, you’ll learn how to build a Spring Batch application that reads a CSV file, logs its content, and writes it to a PostgreSQL database.We’ll see how to compile it into a Native Image using GraalVM , and most importantly**, we’ll benchmark the difference between** running it as a traditional JAR and as a native binary.

The Home Assistant Model

Mon, 09 Dec 2024 15:58:27 +0000

Home Assistant (home-assistant.io ) is a massive beast. It can be overwhelming for a newcomer; it was for me.

In this article, I want to describe the underlying model of Home Assistant, which is a good entry point for your home automation journey.

The biggest issue in describing the Home Assistant is the number of conflicting sources for this model:

The helpers package of the GitHub repository
The database; disclaimer: I didn’t find the schema generation in the code, and I wasn’t bold enough to check the deployed SQLite database
The documentation
The web interface

As far as I understand it, here’s the conceptual model.

Why Home Assistant

Mon, 09 Dec 2024 15:54:20 +0000

Last June, I spoke at Berlin Buzzwords . In all honesty, I rarely attend others’ talks for a variety of reasons: lack of time, lack of energy, no interest in the proposed subjects, etc. When I do, I go either for subjects I know and want to deepen my understanding of or for subjects I know nothing about to get a foot in the door.

This time, I attended Monitoring your home, with DevOps observability tools . I thought it would be about OpenTelemetry for your home. After the speaker mentioned Home Assistant (home-assistant.io ), however, I didn’t pay much attention to the rest.

Task schedulers in Java: modern alternatives to Quartz Scheduler

Thu, 28 Nov 2024 18:04:32 +0000

Quartz is often considered the standard job scheduling library in Java, which can lead developers to overlook more modern alternatives.

For a long time, Quartz, also known as Quartz Scheduler, was the only viable open-source task scheduler in Java. In fact, the official Quartz documentation still suggests that there is no real alternative . In this article, we will list a few different Quartz alternatives that offer a similar set of features while being easier and more enjoyable to use.

strace Revisited: Simple is Beautiful

Tue, 26 Nov 2024 14:58:28 +0000

Understanding strace and its Origins
- A Look Back: strace and dtrace
- Originating from Sun Microsystems
Technical Functioning of strace
- The Role of ptrace in strace
- Comparing with DTrace
Practical Usage and Advantages
- Ease of Use and Accessibility
- Favored in Linux Environments
strace in Action: A Closer Look at System Calls
- Basic Usage and Output Analysis
- Interpreting System Calls for Debugging
Advanced Features and Tips
- Filtering System Calls for Efficiency
- Exploring a Variety of System Calls
strace and Java: A Special Case
- strace with the JVM
- Allocations and Threading in Java
Final Word

In the realm of system debugging, particularly on Linux platforms, strace stands out as a powerful and indispensable tool. Its simplicity and efficacy make it the go-to solution for diagnosing and understanding system-level operations, especially when working with servers and containers.

In this article, we’ll delve into the nuances of strace, from its history and technical functioning to practical applications and advanced features. Whether you’re a seasoned developer or just starting out, this exploration will enhance your diagnostic toolkit and provide deeper insights into the workings of Linux systems.

Build and Run TornadoVM with IntelliJ IDEA

Wed, 20 Nov 2024 19:08:13 +0000

TornadoVM is an open-source Java technology that is developed to aid Java programmers in adapting their code bases for hardware acceleration.

This blog aims to explain how Java programmers can build TornadoVM with IntelliJ IDEA, and how they can run TornadoVM unit-tests or other Java programs.

Prerequisites

This blog uses IntelliJ IDEA 2024.2.4 version and the list of required plugins are as follows:{#r55ph1440}

Python ++plugin++ to be installed in IntelliJ. This plugin allows python scripting from the IDE.

{#x95ro33520}

Profile IntelliJ IDEA with its own profiler

Wed, 16 Oct 2024 15:49:38 +0000

Other languages: Español 한국어 Português 中文

Just like my previous post , this one is going to be slightly meta. Obviously, you can use IntelliJ IDEA to profile another process , but did you know IntelliJ IDEA can profile itself?

This might be useful if you are writing an IntelliJ IDEA plugin and need to address issues related to your plugin’s performance.

Also, regardless of whether you are a plugin author, the described case might be interesting to you because the profiling strategy that I’ll cover is not exclusive to IntelliJ IDEA – you can use it to troubleshoot similar bottlenecks in other types of projects and using other tools.

Augmenting the client with Alpine.js

Mon, 14 Oct 2024 10:59:44 +0000

This article is part of a series comparing different ways to implement asynchronous requests on the client, which is colloquially known as AJAX. I dedicated the previous post to Vue.js; I’ll dedicate this one to Alpine.js - not to be confused with Alpine Linux.

I’ll follow the same structure as previously.

Laying out the work

Here’s the setup, server- and client-side.

Server-side

Here is how I integrate Thymeleaf and Alpine.js in the POM:

Augmenting the client with Vue.js

Mon, 14 Oct 2024 10:53:42 +0000

In my previous article , I laid the ground to build upon; now is the time to start “for real”.

I heard a lot of Vue.js . Additionally, a friend who transitioned from developer to manager told me good things about Vue, which further piqued my interest. I decided to have a look at it: it will be the first “lightweight” JavaScript framework I’ll study - from the point of view of a newbie, which I am.

Run true-to-production tests on your Java applications

Tue, 24 Sep 2024 11:48:46 +0000

As supported by the 12 factor and 15 factor app methodologies, in application development, we’ve come to realize just how important it is to test our applications in a true-to-production environment before releasing them to consumers. This helps us to mitigate potential failures and spot bugs that could appear in production but be missed in testing due to environmental differences and ensure we have high confidence in our applications being deployed to production environments. But, traditionally, developers have struggled with replicating an application’s production environment locally.

Help update the Twelve-Factor app methodology

Thu, 05 Sep 2024 07:44:26 +0000

The 12 factor application methodology is being updated and we need your help with it! Be a part of this project helping to update and modernize the original methodology to enable it to be even more effective for modern cloud-native applications.

What is the 12 factor app methdology?

Originally created back in 2012, the 12-factor app methodology was designed to provide a set of guidelines for helping developers and organizations to design and build cloud-native applications. This methodology was defined by the developers at Heroku, but has been adopted and even in some cases extended by the community since then.

Four Easy Ways to Analyze your Java and Kotlin Code for Security Problems

Fri, 30 Aug 2024 09:07:43 +0000

Originally published at Snyk.io .

Nowadays, the security of your applications is just as important as the functionality they provide. Therefore, analyzing your code for security vulnerabilities is a vital part of maintaining the integrity of your applications and protecting your users’ data. As developers, we are at the front lines of this battle. It’s our responsibility to ensure that the code we write is not just functional and efficient but also secure.

Creating 12-factor cloud-native Java apps with open source

Fri, 23 Aug 2024 05:30:51 +0000

Learn how you could create cloud-native Java apps that are portable, scalable, and reliable with the 12 factor app methodology and open source Java frameworks.

Created in 2012, the 12-factor app methodology was designed to provide a set of guidelines for helping developers and organizations to design and build cloud-native applications. We’ll explore how you can take advantage of each of these 12 factors to create applications, utilizing open source technologies, that thrive in the cloud.

Allocation Profiling in Java

Fri, 09 Aug 2024 08:44:59 +0000

Read in other languages : 中文 Español Português

We often find ourselves in situations when code is not working properly, and we have no idea where to even begin investigating.

Can’t we just stare at the code until the solution eventually comes to us? Sure, but this method probably won’t work without deep knowledge of the project and a lot of mental effort. A smarter approach would be to use the tools you have at hand. They can point you in the right direction.

A Beginner's Guide to IntelliJ Profiler

Thu, 04 Jul 2024 06:26:35 +0000

Read in other languages: 中文 Español Português

Sometimes your app works, but you want to increase performance by boosting its throughput or reducing latency. Other times, you just want to know how code behaves at runtime, determine where the hot spots are, or figure out how a framework operates under the hood.

This is a perfect use case for profilers. They offer a bird’s eye view of arbitrarily large execution chunks, which helps you see problems at scale.

Java on Visual Studio Code May 2024 Update - New AI Feature, Spring Updates

Tue, 18 Jun 2024 10:42:26 +0000

Hi everyone, welcome to the May update for Visual Studio Code for Java!

In this articlem we are going to share an exciting new AI related feature for Java developers on Visual Studio Code.

In addition, there will be several important Spring updates, so let’s get started.

Rewriting your Java code with Copilot-based suggestions

As our code undergoes updates and iterations, our business logic continues to grow in complexity. Meanwhile, Java versions are constantly evolving. Often, our older code can be replaced with newer, more efficient alternatives, not only improving their performance but also making the code more elegant, concise and secure. Previously, these tasks may have been done manually, but with the power of AI, many tasks can now be handled automatically.

Hack a Java application with the debugger

Thu, 13 Jun 2024 04:58:03 +0000

Read in other languages: 中文 Español Português

Back in the day, computer games were different. Not only have graphics and mechanics evolved since, but there’s also one characteristic that doesn’t seem very common in games today: nearly all of them had cheat codes.

Cheat codes were sequences of keys that would give you something extraordinary, such as infinite ammo or the ability to walk through walls. The most common and powerful of them was ‘god mode’ – it made you invincible.

Vaadin 24.4 Adds React Support, In-App Coding Assistant

Wed, 12 Jun 2024 14:38:32 +0000

Unified Vaadin Platform: Seamless Integration with Hilla

24.4 adds React support to the entire Vaadin platform by including the Hilla framework.

The Vaadin BOM and Vaadin Spring Boot Starter now include Hilla, allowing you to choose between Flow and Hilla or mix both in your projects.

Vaadin Copilot: an in-app development assistant

Vaadin 24.4 introduces Vaadin Copilot , a visual development tool and AI-powered assistant.

Available by default in development mode, Copilot helps you inspect and edit the UI, and use generative AI to create or modify code.

Identify Dependencies in Codebases During Microservice Migration

Fri, 07 Jun 2024 07:17:58 +0000

Migration from a monolithic architecture to microservices presents challenges, particularly in identifying and managing dependencies within the codebase. By analyzing the application’s training data, we can uncover the seams and threads that bind the application together, discovering a safer, more iterative path to refactor our code.

Table of Contents

Collecting tracing data to understand code dependencies
Using Digma Analytic Insights to identify dependencies in your codebase:
Code Nexus Point Insight
Top Usage Insight
Discovering Dead Code
Duration Breakdown Insight
Conclusion: Identifying Dependencies in Your Codebase During Microservices Migration

Migration from a monolithic architecture to microservices can be crucial for scalability, flexibility, and development velocity. However, this transformation has challenges, particularly when trying to identify and manage dependencies within the codebase. Many teams optimistically embark on an application-wide modernization epic, thinking of making short work of refactoring their codebase to be more modular. Unfortunately, many of these initiatives quickly lose the initial momentum, as it becomes apparent that untangling the Gordian monolith knot is proving to be an uphill struggle.

Debugging Kubernetes Part 1: An Introduction

Wed, 05 Jun 2024 06:12:40 +0000

Introduction to Kubernetes and Distributed Systems
Enter Kubernetes
- Why Kubernetes Stands Out
Kubernetes For Developers
- Kubernetes Basics In Practice
Final Word

While debugging in an IDE or using simple command line tools is relatively straightforward, the real challenge lies in production debugging. Modern production environments have enabled sophisticated self-healing deployments, yet they have also made troubleshooting more complex. Kubernetes (aka k8s) is probably the most well known orchestration production environment. To effectively teach debugging in Kubernetes, it’s essential to first introduce its fundamental principles.

Indexing all of Wikipedia, on a laptop

Wed, 29 May 2024 15:54:32 +0000

In November, Cohere released a dataset containing all of Wikipedia , chunked and embedded to vectors with their multilingual-v3 model .

Computing this many embeddings yourself would cost in the neighborhood of $5000, so the public release of this dataset makes creating a semantic, vector-based index of Wikipedia practical for an individual for the first time.

Here’s what we’re building:

You can try searching the completed index on a public demo instance here .

Task scheduler in Java: background job processing with JobRunr

Wed, 22 May 2024 11:05:04 +0000

What is JobRunr

Task scheduler in Java

JobRunr is an open-source Java library for task scheduling and distributed background job processing. It offers an effortless way to perform background tasks using only Java 8 lambdas.

Whether it is a fire-and-forget , scheduled or recurring job , JobRunr analyzes the lambda and stores the metadata needed to process the job in a database. This simple architecture, with a few other mechanisms, allows a job to be executed on any available server running your application (👋 k8s).

Hello eBPF: XDP-based Packet Filter (9)

Mon, 13 May 2024 07:13:38 +0000

Welcome back to my series on ebpf . In the last blog post, we learned how annotation processors can generate C code, simplifying writing eBPF applications.

This week, we’ll use this work together with new support for XDP to create a simple package blocker for eBPF (GitHub ):

./run_bpf.sh XDPPacketFilter twitter.com

This blocks all incoming IPv4 packages from twitter.com. We see how it works in this blog post. First, we start with some background on networking and explain what XDP is.

Hello eBPF: Generating C Code (8)

Wed, 24 Apr 2024 13:11:40 +0000

Welcome back to my series on ebpf . In the last article, we learned how toauto-layout struct members and auto-generate BPFStructTypes for annotated Java records . We’re going to extend this work today.

This is a rather short article, but the implementation and fixing all the bugs took far more time then expected.

Generating Struct Definitions

We saw in the last article how powerful Java annotation processing is for generating Java code; this week, we’ll tackle the generation of C code: In the previous article, we still had to write the C struct and map definitions ourselves, but writing

Getting Started with bld

Mon, 15 Apr 2024 18:31:32 +0000

bld is an up-and-coming build tool for the Java ecosystem. This article guides you through getting set up to use it in your own projects.

What is `bld`?

bld is a build tool for the Java ecosystem.

Why use `bld`?

bld is a very simple build tool.

Unlike its contemporaries Maven and Gradle, which concern themselves with abstract models of a project, lifecycles, declarative DSLs, and avoiding repeated work, bld just runs Java code.

Hello eBPF: Auto Layouting Structs (7)

Sun, 14 Apr 2024 16:19:50 +0000

Welcome back to my series on ebpf . In the last article, we learned how to use ring buffers with libbpf for efficient communication. This week, we’re looking into the memory layout and alignment of structs transferred between the kernel and user-land.

Alignment is essential; it specifies how the compiler layouts the structs and variables and where to put the data in memory. Take, for example, the struct that we defined in the previous article in the RingSample :

IntelliJ IDEA and Open Liberty - Effective Java app development

Fri, 12 Apr 2024 13:36:25 +0000

See how you can use Liberty Tools for IntelliJ IDEA to enable rapid, easy, and efficient development of cloud-native Java applications with Open Liberty and WebSphere Liberty

When it comes to integrated development environments, within the Java community, IntelliJ IDEA is the most popular IDE amongst professional developers. It is the preferred IDE of choice by two-fifths of developers, making up the biggest majority of IDE users in this community, according to JRebel’s 2023 Java Developer Productivity Report .

Hello eBPF: Ring buffers in libbpf (6)

Tue, 19 Mar 2024 17:54:22 +0000

Welcome back to my article series on eBPF. Some weeks ago, I got started in using libbpf instead of libbcc . This week, I show you how to use ring buffers, port the code from Ansil H’s blog post eBPF for Linux Admins: Part IX from C to Java, and add tests to the underlying map implementation.

My libbpf-based implementation advances slower than the bcc-based, as I thoroughly test all added functionality and develop a proper Java API, not just a clone.

TornadoInsight: Harness the Power of TornadoVM from IntelliJ IDEA

Fri, 08 Mar 2024 11:59:07 +0000

TornadoInsight is an open-source IntelliJ IDEA plugin for enhancing the developer experience when working with TornadoVM.

It provides a built-in on-the-fly static checker, empowering developers to identify unsupported Java features in TornadoVM and understand the reasons behind these limitations.

Additionally, TornadoInsight introduces a dynamic testing framework that enables developers to easily test individual TornadoVM tasks. It automatically wraps TornadoVM tasks, invoking the native TornadoVM runtime on the developer’s machine for seamless debugging and testing. In this blog, we expand on TornadoInsight by:

Payara Cloud Hackathon is Open for Sign-ups!

Thu, 07 Mar 2024 13:53:56 +0000

We’re excited to announce that the 2nd edition of Payara Hackathon is now open for sign ups! Find out more and sign up here!

The Payara Cloud Hackathon will be running from the 11th until the 31st of March and this time, we are looking for applications that tackle environmental, social, and economic sustainability challenges. With a focus on deploying to our Payara as a Service platform Payara Cloud, this is your chance to showcase the power and versatility of Jakarta EE technologies.

Hello eBPF: First steps with libbpf (5)

Thu, 07 Mar 2024 13:51:35 +0000

Welcome back to my blog series on eBPF. Two weeks ago, I showed you how to write your own eBPF application using my hello-ebpf library based on libbcc . This week, I show you why using libbcc is not the best idea and start working with the newer libbpf .

With my current libbcc-based approach, we essentially embed the executed eBPF program into our programs as a string into our applications and compile them on the fly for every run:

Foojay Podcast #43: Modern Java Testing

Mon, 26 Feb 2024 08:03:08 +0000

As developers, we all want to write bug free and high quality code. Writing tests is a crucial part to achieve this.

Let’s explore the art of ensuring robust and bug-free code in the Java ecosystem.

Whether you’re a seasoned developer or just starting out, there’s a lot you can learn from the experts in this podcast about testing methodologies, tools, and best practices, empowering you to write reliable Java applications.

Hello eBPF: Tail calls and your first eBPF application (4)

Fri, 23 Feb 2024 08:44:51 +0000

Welcome back to my series on eBPF. Two weeks ago, I showed you how to use perf event buffers to stream data from the eBPF program to the Java application .

This week, we will finish chapter 2 of the Learning eBPF book, learn how to use tail calls and the hello-ebpf project as a library and implement one of the book’s exercises.

We start with function and tail calls:

Function Calls

Regular C programs are divided into functions that call each other; so far in this series, all our eBPF programs consisted of just a single function that calls kernel functions. But can we call other eBPF functions? End of 2017, Daniel Borkman et al. introduced the ability to call other functions defined in eBPF:

Hello eBPF: Recording data in event buffers (3)

Fri, 02 Feb 2024 14:45:02 +0000

Welcome back to my article series on eBPF. Last week, I showed you how the eBPF program and Java application can communicate using eBPF maps . This allowed us to write an application that counts the number of execve calls per user.

This week, I’ll show you briefly how to use another kind of eBPF maps, the perf event buffer, and run tests with docker and JUnit 5 .

This article is shorter than the previous one as I’m preparing for the OpenJDK committers workshop in Brussels and my Python and Java DevRoom talks at FOSDEM. I’m happy to meet my readers; say hi when you’re there.

Soft Assertions - testing kindly

Fri, 19 Jan 2024 10:17:45 +0000

Given it’s the advent of a new year, I thought let’s start with something nice and fun that can make live more enjoyable for everyone.

As developers, we write testcases all the time to help us in our development process, and to help us detect potential regressions in the future.

Now ideally we want our testcases to be as efficient as possible, and ideally to require as few reruns as possible. And this is where Soft Assertions come into play.

Hello eBPF: Recording data in basic eBPF maps (2)

Thu, 18 Jan 2024 15:50:44 +0000

Welcome back to my article series on eBPF.

Last week, I introduced eBPF, the series, and the project and showed how you can write a simple eBPF application with Java that prints “Hello World!” whenever a process calls execve:

public class HelloWorld {
 public static void main(String[] args) {
 try (BPF b = BPF.builder("""
 int hello(void *ctx) {
 bpf_trace_printk("Hello, World!");
 return 0;
 }
 """).build()) {
 var syscall = b.get_syscall_fnname("execve");
 b.attach_kprobe(syscall, "hello");
 b.trace_print();
 }
 }
}

But what if we want to send more information from our eBPF program to our userland application than just some logs?

Payara Platform Roadmap 2024

Wed, 17 Jan 2024 10:39:43 +0000

Now that New Year is here, we reflect on 2023 and look ahead to what you can expect from our entire suite of Payara products in 2024. What is the future for Payara Community, Enterprise and Payara Cloud?

Read below to find out more about Payara Rodmap in the coming months - Java 21 compatibility, the upcoming Jakarta EE 11 and our plan for support, and more!

You can also watch the Payara Roadmap 2024 presented at the Virtual Payara Conference last month.

Hello eBPF: Developing eBPF Apps in Java (1)

Tue, 09 Jan 2024 16:34:56 +0000

eBPF allows you to attach programs directly to hooks in the Linux kernel without loading kernel modules, like hooks for networking or executing programs.

This has historically been used for writing custom package filters in firewalls. Still, nowadays, it is used for monitoring and tracing, becoming an ever more critical building block of modern observability tools. To quote from ebpf.io :

Historically, the operating system has always been an ideal place to implement observability, security, and networking functionality due to the kernel’s privileged ability to oversee and control the entire system. At the same time, an operating system kernel is hard to evolve due to its central role and high requirement towards stability and security. The rate of innovation at the operating system level has thus traditionally been lower compared to functionality implemented outside of the operating system.

Effective cloud-native Java dev in Eclipse IDE with Open Liberty

Tue, 09 Jan 2024 12:50:12 +0000

The Eclipse IDE has been a popular choice with developers for many years, placing 2nd in “most popular IDE of 2022” by JRebel . This mature and fully-featured IDE , with an extensive plugin repository, can help to significantly improve the development experience. However, ensuring that developers have the most appropriate and helpful plugins can be the key to unlocking this improved development experience and enhanced productivity.

In this article, we’ll explore the Liberty Tools plugin for Eclipse IDE and how it can help enable fast, easy, and efficient development of cloud-native Java applications with Open Liberty and WebSphere Liberty.

lntelliJ IDEA: Selectively Commit Changes to a File

Thu, 21 Dec 2023 06:15:09 +0000

Sometimes you’re making multiple changes to a file that you don’t want to commit together. For example, if you’re working on a new feature, but notice some other small things you want to fix. If these changes are in separate files, we can commit each file separately. But what if they’re in the same file?

In IntelliJ IDEA (as of version 2023.3 ), we can now select which chunks and specific lines we want to add to our commit.

Effective cloud native development with Open Liberty in VS Code

Tue, 05 Dec 2023 10:25:29 +0000

Open Liberty is a lightweight, open cloud-native runtime, great for building fast and efficient cloud-native Java applications. If you’re unfamiliar with Open Liberty, and want to learn more, check out the “Why cloud-native Java developers love Liberty ” article.

However, choosing an effective cloud-native Java runtime for your application doesn’t always directly equate to efficient creation of cloud-native applications. As developers, it’s important we use these runtimes and supporting tools effectively to enable an efficient development cycle and ensure productivity within our development teams.

Virtual Event: JetBrains AI Launch Event

Mon, 04 Dec 2023 11:32:32 +0000

Don’t miss the online JetBrains AI launch event, where we’ll release our AI-powered coding companion, JetBrains AI Assistant.

With JetBrains AI, your favorite tools gain new abilities while you are empowered with more information at your fingertips.

Free yourself from the routine and stay in the flow like never before!

Join the JetBrains AI launch event online ! December 6, 5:00 pm (CET) | 8:00 am (PST).

Learn more about JetBrains AI and AI Assistant from the creators themselves.

Announcing the Build Server for Gradle Open-Source Repository

Tue, 21 Nov 2023 10:08:33 +0000

Build Server for Gradle

In September, we shared that Microsoft and Gradle have joined forces to explore a novel approach to Gradle project import and building, based on the Build Server Protocol (BSP) . The objective is address the existing Gradle issues on Visual Studio Code and improve support for Gradle projects.

The Build Server for Gradle, developed in collaboration with Gradle, will delegate build tasks to the Gradle build tool, which will be responsible for compiling and generating code directly. This ensures that the results of building in Visual Studio Code will be consistent with the output obtained by running Gradle build commands.

How to find dead code in your Java services

Tue, 07 Nov 2023 10:40:48 +0000

When building solutions, the code we write can last many years. While casually browsing legacy code, we might wonder; is this still used? The missing documentation or outdated tests do not help us answer this. When asking around, nobody really knows. Let’s try to delete it, shall we? Then, chaos ensues: it turns out it is still used to support some legacy users, in case of emergency, or by that one forgotten integration everyone still uses.{#2406}

Generative AI and Java - hype or urgent reality?

Mon, 06 Nov 2023 07:59:04 +0000

It’s hard to grasp that it’s been about a year since Chat GPT and other generative AI tools burst onto the scene. We’re all still grappling with, well, everything about them. Whatever equilibrium we eventually find, it’s clear that the world is changing. The whole world mind, not just the IT industry.

Olimpiu Pop and I have debated the situation multiple times, and we realised that there’s lots of rumour around AI and Java but not much in the way of fact.

Elevating Java in Visual Studio Code: New Build Server for Gradle

Mon, 30 Oct 2023 15:24:14 +0000

Introducing Build Server for Gradle

In recent years, Gradle has become one of the most popular Java build tools due to its flexibility in configuring build processes and its powerful extensibility. In Visual Studio Code, users can import Gradle projects into their workspace for development. However, there are some areas where support for Gradle projects is not entirely satisfactory, with two major issues that users have below:

Compiled files are output to the ‘bin’ directory, which differs from Gradle project’s default output location.
Support for code generation, such as Annotation Processing, is suboptimal.

To address these issues, Microsoft and Gradle have joined forces to explore a novel approach to Gradle project import and building, based on the Build Server Protocol (BSP) .

New: JDKMonitor

Wed, 18 Oct 2023 08:04:08 +0000

During Devoxx Morocco I’ve spent some time coding a little new tool where the main reason was to have a widget on my MacOS desktop that shows the days until the next release/update of OpenJDK .

Because this alone was not enough to get it into the Mac App Store, I needed to add more functionality and so I’ve decided to also show the latest version of the last 4 LTS (Long Term Support) releases with the ability to download them either as JDK or JRE and if you like bundle JavaFX with it. At the moment that would mean JDK 8, 11, 17 and 21 with their latest versions available.

How do software companies give away stuff for free?

Tue, 26 Sep 2023 14:34:20 +0000

In today’s world, it has never been easier to get your hands on a piece of software for evaluation purposes. Having worked for multiple enterprise companies, I have noticed over the years that they all take different approaches to allowing developers to get their hands dirty with their tech.

There are many different ways of doing this and in this article I will try and explain the main approaches that software companies use and the reasoning behind these methods.

Manage Different Java Versions on Your Machine with SDKMan!

Wed, 20 Sep 2023 07:05:16 +0000

So, you’re a Java developer, or maybe you’re aspiring to be one. Either way, you’ve probably faced the challenge of managing multiple versions of Java on your machine. One project requires Java 8, but another needs Java 11, yet another requires Java 17. The open-source library you’re keen on contributing to needs yet another version. What do you do? You start juggling environment variables, and before you know it, your system is a tangled mess of configurations. Not fun, right?

Chronicle Services: Building Fast Microservices with Java

Wed, 13 Sep 2023 13:47:47 +0000

Low Latency?

In computing, latency is defined as the length of time to perform some task. This could be the time it takes to respond to an interrupt from hardware or the time it takes for a message sent by one component to be available to its recipient.

In many cases, latency is not seen as a primary non-functional concern when designing an application, even when considering performance. Most of the time, after all, computers seem to do their work at speeds that are well beyond human perception, typically using scales of milliseconds, microseconds, or even nanoseconds.

The DiscoAPI Helps You To Find Any OpenJDK Distribution

Tue, 12 Sep 2023 03:42:44 +0000

Did you know Foojay is not only a human-readable OpenJDK knowledge base but also provides the Disco API that lets you search all OpenJDK distributions? And even if you didn’t know, you probably already are using it, as it’s integrated into SDKMAN! , JReleaser , JBang! , Gradle toolchain , Paketo buildpacks ,and more.

The Disco API (i.e., the short name for the Universal OpenJDK Discovery API) is a database and API with all the available OpenJDK versions from all distributors, like Corretto, Liberica, Oracle, Temurin, Zulu, and many others. In total, there are now 89352 different packages at the end of August 2023.

Load testing - shoot your application with Gatling

Wed, 06 Sep 2023 09:32:29 +0000

What is load testing?

Load testing entails testing how our application performs under a significant load so we can be certain it behaves as expected when there’s an influx of users.

Or at least so we know what it can cope it, and at what point we might potentially need to take action.

After all, it might not (only) be the code that’s the issue.

This is a process that requires quite a bit of cooperation between testers, developers, and those using it to properly determine the scenarios, and a smooth & swift feedback loop is important to make sure our solutions work properly. And it will likely be some of the most expensive tests given both the people involved and the need for a testing environment that’s representative of the production configuration.

Spring Boot: local development enhancements, let's compose!

Fri, 25 Aug 2023 11:16:05 +0000

Quite often when we are developing an application we need external services such as rabbitMQ, Kafka, etc.

When you are developing locally, you are quite likely using a docker-compose file to start these up, and I am certainly (hopefully) not the only one that has forgotten at least once to start these instances up.

And maybe you are even already using Testcontainers for your testing.

Luckily, Spring Boot 3.1 introduced some nice improvements to make our lives a bit easier.

OpenRewrite: we all grow older, but do our projects really have to?

Tue, 08 Aug 2023 09:24:44 +0000

We have all likely worked on a project, that has grown quite “mature” over time, who knows we might even have forgotten to keep our dependencies up to date? Mayhap we finally got the green light to move from JDK 8 to 17?

This will quite likely entail a lot of library updates, and maybe some interesting changes (cough javax => jakarta).

This is where a rewrite tool like OpenRewrite can come in handy, and I would like to walk through some of the options of this tool in this article.

Getting Started With Apache Camel On Jakarta EE 10

Mon, 24 Jul 2023 10:20:06 +0000

Apache Camel is an open source enterprise integration framework that helps you connect different systems and applications together with as little effort as possible. It provides a simple and powerful way to define and implement message-based routing and mediation rules. It is an implementation of the patterns described in the book Enterprise Integration Patterns by Gregor Hohpe and Bobby Woolf.

In simple terms, Apache Camel acts as a “translator” or “bridge” between different systems. It allows you to easily route, transform, and process messages as they move from one system to another. It supports a wide range of communication protocols and data formats (JSON, XML, YAML, etc.), making it easier to integrate different technologies and applications.

SnakeYaml 2.0: Solving the unsafe deserialization vulnerability

Thu, 20 Jul 2023 07:17:16 +0000

In December of last year, we reported ++CVE-2022-1471++ to you. This unsafe deserialization problem could easily lead to arbitrary code execution under the right circumstances.

In the deep-dive blog post “++Unsafe deserialization vulnerability in SnakeYaml (CVE-2022-1471)++ ”, I explained the problems in this library and how it could be executed. The gist of the problem was that by default SnakeYaml parsed the incoming yaml to the generic object type.

Enterprise Java Applications With Jakarta EE and Vaadin

Wed, 12 Jul 2023 09:26:07 +0000

Watch this webinar recording to get an overview of the Vaadin framework and learn how to use it to build modern web applications on the Jakarta EE Platform in pure Java, without any frontend framework.

Find out more about the core features of Jakarta EE, like its dependency injection (Jakarta CDI) and persistence (Jakarta Persistence) APIs. Additionally, you will learn how to use Vaadin and Jakarta EE to build responsive web applications that can run on different devices and browsers.

Java on Visual Studio Code – June 2023

Mon, 10 Jul 2023 12:44:47 +0000

Hi everyone, welcome to the our June update for Visual Studio Code for Java!

In this article, we’re going to provide you an update about our code completion performance improvement, user experience enhancements in both unit testing and project creation, so let’s get started!

Code Completion Performance Improvement

Faster code completion is a crucial aspect of any developer tool that can greatly enhance coding productivity. In the past, we have heard from our users they felt Java code completion was slow sometimes which has impacted their work. As a result, we have been researching into how to make it faster and as a result, we have actually made significant progress.

Working on An Unfamiliar Codebase

Sun, 02 Jul 2023 09:00:47 +0000

In our profession, it’s common to work on an unfamiliar codebase.

It happens every time one joins a new project or even needs to work on a previously untouched part in big ones.

This occurrence is not limited to a developer having to fix a bug; it can be a solution architect having to design a new feature or an OpenSource contributor working on a GitHub issue in their free time.

Debugging OpenJDK Tests in VSCode (Without Losing Your Mind)

Mon, 26 Jun 2023 11:27:55 +0000

Consider you want to debug a test case of the JDK like serviceability/AsyncGetCallTrace . This test, and many others, are implemented using the Regression Test Harness for the JDK (jtreg):

jtreg is the test harness used by the JDK test framework. This framework is intended primarily for regression tests. It can also be used for unit tests, functional tests, and even simple product tests – in other words, just about any type of test except a conformance test, which belong in a TCK.

Java on Visual Studio Code – May 2023

Tue, 13 Jun 2023 11:03:09 +0000

Hi everyone, welcome to our May update for Visual Studio Code Java! In this article, we have tons of new features covering performance improvement, user experience as well as Spring Boot integration, so let’s get started!

Built-in Java Profile Templates in VS Code

Profiles is a recent feature from VS Code that allows you to quickly switch your editor extensions, settings, and UI layout based on your current project or task. Starting in VS Code version 1.78, we have provided two built-in Java profile template for you to use. The two Java profiles are

JavaFinder: Keeping Track of Java Inventories

Wed, 24 May 2023 20:12:31 +0000

Do you ever wonder how many Java distributions you have installed on your machine?

I not only mean versions that you use for development but also versions that come bundled with the applications you use.

Last weekend I decided to write a little tool that can help me to figure that out… JavaFinder.

This is a simple command line tool that will search a given path, including its subfolders for any OpenJDK distribution or GraalVM derivate.

TornadoVM: Code Interoperability Mode

Thu, 11 May 2023 07:54:04 +0000

TornadoVM is a programming framework for accelerating Java applications on heterogeneous devices, like multi-core CPUs, GPUs and FPGAs.

Java developers can use the TornadoVM API to prototype Java methods within their code bases for hardware acceleration.

TornadoVM is hardware-agnostic, but the generated code (i.e., kernels) for acceleration can be executed only through the TornadoVM runtime.

This blog outlines the key changes in TornadoVM to enable code interoperability of kernels with other programming languages beyond Java.

Using Async-Profiler and Jattach Programmatically with AP-Loader

Thu, 04 May 2023 11:45:20 +0000

Using async-profiler and jattach can be quite a hassle. First, you have to download the proper archive from GitHub for your OS and architecture; then, you have to unpack it and place it somewhere.

It gets worse if you want to embed it into your library, agent, or application. Library developers cannot just use maven dependency but have to create wrapper code and build scripts that deal with packaging the binaries themselves, or worse, they depend on a preinstalled version which they do not control.

Couldn’t we just Use AsyncGetCallTrace in a Separate Thread?

Tue, 25 Apr 2023 05:31:36 +0000

I’m keenly interested in everything related to profiling on the JVM, especially if it is related to AsyncGetCallTrace, this tiny unofficial API that powers most profilers out there, heck, I’m even in the process of adding an improved version to the OpenJDK , AsyncGetStackTrace.

During the discussions on the related JDK enhancement proposal and PRs fixing AsyncGetCallTrace bugs, one thing often arises: Why is AsyncGetCallTrace always called in the signal handler on top of the stack that we want to walk (like in my Writing a Profiler from Scratch series)?
Interaction between the wall-clock sampler thread and the different signal handlers, as currently implemented in async-profiler.

Replacing Postman with the Jetbrains HTTP Client

Thu, 13 Apr 2023 06:59:28 +0000

TL;DR: I’ve created the first version of an openapi-generator for the JetBrains HTTP Client, and together with the CLI runner it allows you to play against APIs without ever going out of your terminal and it can even run in your CI/CD pipeline. See repository here .

I work a lot with APIs, whether for an app I develop myself, or to interact with others. Most people I know tend to use Postman for this. But I personally don’t quite like the product any more , and it forces me to move out of my IntelliJ environment which really kills my productivity.

Chronicle FIX: Much More Than a Quick Fix

Wed, 12 Apr 2023 13:55:24 +0000

Many of our customers have upgraded from QuickFIX/J to Chronicle FIX and this article provides some background as to why.

Introduction

QuickFIX/J is free, accessible, supports the FIX standard and is therefore often chosen by the IT team for a first FIX engine.

However, when the business grows, its limitations become clear. The reasons most commonly given to us are:

Throughput and latency
HA/DR functionality
Advanced features e.g. routing and message translation
Global commercial support

Also, some customers engage with us because they already use our open source products e.g. Chronicle Queue, or our enterprise products e.g., Chronicle Queue Enterprise replication, or Chronicle Services EDA/Microservices accelerator.

Introducing Bld: A New Pure Java Build System

Mon, 10 Apr 2023 20:12:47 +0000

RIFE2’s bld is a new build system that allows you to write your build logic in pure Java.

bld was initially created for RIFE2 web applications, but has already moved outside of that narrow focus and is now used for non-web projects also, like the RIFE2 framework itself and our URL Encoder for Java library .

We created bld because we’re not really interested in build tools. We use them because we have to, but we’d rather just get on with coding the real stuff.

My First Firefox Extension

Mon, 10 Apr 2023 18:36:13 +0000

A couple of weeks ago, I spent the weekend creating another submission helper in the form of a Firefox extension.

It was not a walk in the park.

To help others who may be interested in doing the same (and my future self), here’s my journey!

Context

I’ve written multiple posts about my conference submission workflow .

To sum up:

Everything is based on a Trello board
I created an app that registered a webhook on the board
When I move a conference from one lane to another, it starts or continues a workflow on the app side

I source the board by looking at websites, mainly Papercall and Sessionize , and manually copying conference data on cards. Two automation options are available:

Instrumenting Java Code to Find and Handle Unused Classes

Sat, 08 Apr 2023 13:26:34 +0000

In this article, let’s take a look at writing a Java agent and instrumentation code to find unused classes and dependencies in your project.

Knowing which classes and dependencies are not used in your application can save you from considering the bugs and problems in these dependencies and classes if you remove them.

There a multiple tools out there, for gradle and maven (thanks, Marit), that do this statically or dynamically (like the one described in the paper Coverage-Based Debloating for Java Bytecode, thanks, Wolfram).

Writing a Profiler in 240 Lines of Pure Java

Thu, 30 Mar 2023 07:14:46 +0000

A few months back, I started writing a profiler from scratch, and the code since became the base of my profiler validation tools.

The only problem with this project: I wanted to write a proper non-safepoint-biased profiler from scratch.

This is a noble effort, but it requires lots C/C++/Unix programming which is finicky, and not everyone can read C/C++ code.

For people unfamiliar with safepoint bias: A safepoint is a point in time where the JVM has a known defined state, and all threads have stopped. The JVM itself needs safepoints to do major garbage collections, Class definitions, method deoptimizations, and more. Threads are regularly checking whether they should get into a safepoint, for example, at method entry, exit, or loop backjumps. A profiler that only profiles at a safepoint have an inherent bias because it only includes frames from the locations inside methods where Threads check for a safepoint. The only advantage is that the stack-walking at safepoints is slightly less error-prone, as there are fewer mutations of heap and stack. For more information, consider reading the excellent article Java Safepoint and Async Profiling by Seetha Wenner, the more technical one by JP Bempel , or the classic article Safepoints: Meaning, Side Effects and Overheads by Nitsan Wakart. To conclude: Safepoint-biased profilers don’t give you a holistic view of your application, but can still be helpful to analyze major performance issues where you look at the bigger picture.

Getting started with OpenAPI Generators : tips and tricks

Tue, 28 Mar 2023 15:50:14 +0000

TL;DR: In this article, I’m sharing some tips and tricks on how to get productive creating OpenAPI generators.

Lately, I’ve started dabbling more and more with OpenAPI . The OpenAPI specification is a super useful way to describe the API that you’re exposing to your users, both internally and externally.

Some of you may also have heard about those under the name of “Swagger files”. They’re both kinda the same in the common speak, though OpenAPI is an open standard (lead with the OpenAPI Initiative) and Swagger is a set of tools built by a company (SmartBear ).

Java on Visual Studio Code Update

Tue, 21 Mar 2023 15:47:04 +0000

Hi everyone, welcome to our February update!

In this article, we will bring you new features related to JUnit 5 parallel testing as well as new filter widget for Spring Boot dashboard.

There is also some exciting news from GitHub Copilot, so let’s get started.

JUnit 5 Parallel Testing Support

JUnit 5 is a popular testing framework for Java developers, known for its comprehensive support for unit, integration, and functional testing. One of the significant improvements in JUnit 5 is its ability to execute tests in parallel, making testing faster and more efficient.

Authenticate with OpenID Connect and Apache APISIX

Thu, 09 Mar 2023 07:51:47 +0000

Lots of companies are eager to provide their identity provider: Twitter, Facebook, Google, etc. For smaller businesses, not having to manage identities is a benefit. However, we want to avoid being locked into one provider.

In this article, I want to demo how to use OpenID Connect using Google underneath and then switch to Azure.

OpenID Connect

The idea of an authorization open standard started with OAuth around 2006. Because of a security issue, OAuth 2.0 superseded the initial version. OAuth 2.0 became an in 2012:

SBOMs and Software Composition Analysis │ Foojay.io

Mon, 27 Feb 2023 08:11:28 +0000

This article is the second in a series about SBOMs, software supply chains, the government and you.

I hope you are still hungry after the first article as more cake is available below!

If you have read the first article in this series that introduces SBOMs SBOMs: First Steps in a New Journey for Developers | Foojay.io then you already know how important they are and will be increasingly going forward.

A Quick Look At Faces (JSF) 4.0 In Jakarta EE 10

Fri, 17 Feb 2023 09:07:05 +0000

Jakarta EE 10 shipped with the fourth major release of its component based web framework Jakarta Faces.

Hitherto known as Jakarta Server Faces, and Java Server Faces before that, Jakarta Faces , or just Faces, version 4.0 is the first major version with API change since version 2.3 in Java EE 8.

Among the major changes in this version are the following.

Issue #1581 : New API to programmatically create Facelets
Issue #1508 : New automatic extensionless mapping
Issue #1509 : New annotation @ClientWindowScoped
Issue #1555 : New attribute <h:inputFile multiple="…">
Issue #1556 : New attribute <h:inputFile accept="…">
Issue #1559 : New tag <f:selectItemGroups>
Issue #1560 : New attribute <h:inputText type="…">
Issue #1563 : New tag <f:selectItemGroup>
Issue #1565 : Skip type attribute from <link> and <script> when doctype is HTML5

There were also some pruning of the API such as:

Migrating Applications to TornadoVM v0.15 (Part 1)

Thu, 16 Feb 2023 07:58:43 +0000

TornadoVM 0.15 introduced changes at the API level with the aim of making the exposed operations more comprehensive to the programmers.

It is imperative after all to get an understanding of how to use the TornadoVM API, as it includes very powerful operations, such as expressing parallelism, chaining Java methods (tasks) for deployment on heterogeneous hardware, configuration of the data transfers, etc.

This article has the following objectives:

Give an overview of the TornadoVM programming model.
Provide guidelines on how to define what to run on a device.
Provide guidelines on how existing TornadoVM programs can migrate to use the TornadoVM v0.15 API.

TornadoVM Programming Model {#h2-0-1-tornadovm-programming-model}

TornadoVM uses a programming model that derives from the state-of-the-art programming models of heterogeneous hardware accelerators, such as OpenCL, Level Zero, and CUDA. A key aspect for software applications that require to offload computations for hardware acceleration is that they are composed of two parts:

SBOMs: First Steps in a New Journey for Developers

Tue, 14 Feb 2023 10:01:28 +0000

This article is the first in a series about SBOMs, software supply chains, the government and you. Buckle up - it’s going to be a wild ride. Luckily there is cake to see you through.

Software bill of materials, anyone? A year ago, most developers had not heard of the ‘SBOM’ acronym.

Indeed, related terms like “software supply chain” or “security hygiene” were absent from most developers’ vocabularies.

Things are about to change! This year is already shaping up to be the year of SBOMs, of securing the software supply chain, and of the appearance of legislation that enforces better security practices among those involved in software. Whether in creation, testing, deploying, securing or operating, we all have specific security responsibilities in protecting our part of the software supply chain.

Using Firefox Profiler beyond the web

Fri, 03 Feb 2023 15:28:55 +0000

This blog post is the base for the second half of my upcoming talk at FOSDEM 2023 on the topic “Firefox Profiler beyond the web: Using Firefox Profiler to view Java profiling data .”

I detailed in my last blog post how the Firefox Profiler can be used to view Java profiling data:

But I’m of course not the only one who uses Firefox Profiler beyond the web because using it has many advantages: You’re essentially getting a prototypical visualization for your data in an afternoon.

AsyncGetStackTrace: A better Stack Trace API for the JVM

Thu, 26 Jan 2023 09:16:06 +0000

This article is the basis for my upcoming talk at FOSDEM 2023, “AsyncGetStackTrace: The Improved Version Of AsyncGetCallTrace (JEP 435),” and is based on JEP Candidate 435.

Consider you want to write a profiler to profile Java applications. Why? Because you think that the existing ones "[…] Are Fucking Terrible" or "[…] Broken" . Or you want to start a blog series on writing a profiler from scratch to learn their inner workings (hi there,**regular readers).

Foojay Podcast #12: State and Future of the IDEs

Mon, 23 Jan 2023 10:14:45 +0000

In this podcast, we are talking to some of the key people working on different IDEs, Integrated Development Environments.

Those are applications that provide tools to computer programmers for software development.

An IDE typically consists of at least a source code editor, build automation tools, and a debugger.

Let’s learn how these tools evolved, and the challenges they face to stay up-to-date with the many evolutions in Java and all other programming languages.

Java on Visual Studio Code Update – December 2022

Wed, 28 Dec 2022 08:11:44 +0000

Hi everyone, we are near the end of year. Looking back on 2022, there are a few highlights that we wanted to share with you all!

Highlights from 2022

Major Visualization Experience Upgrade for Spring Boot Extensions

Starting earlier this year, we began to make a series of improvements on Spring Boot dashboard , aiming to increase Spring developer’s productivity on Visual Studio Code.

This includes the beans and endpoints mapping view, more live information display for Spring applications and the brand new memory as a graph.

Two Million Java Developers on Visual Studio Code!

Mon, 19 Dec 2022 13:12:37 +0000

Hi everyone, we are excited to share that now there are over two million Java developers on Visual Studio Code, which wouldn’t be possible without all the support from the community and our users, so thank you!

For the November update, we are bringing you new code editing features, such as postfix completion and optimized organize imports. In addition, the debugger gets a nice update, as we support a new feature called “Step Into Target”. Lastly, we’ve made some visual enhancements to the Spring components.

Preparing to Move Away from Twitter

Fri, 16 Dec 2022 06:42:40 +0000

I opened my Twitter account more than 13 years ago, in August 2009. For 12 years, I kept focusing on professional-related content: Java, the JVM, programming, etc. I built my audience, trying to promote good technical content, either my own or stuff that I enjoyed reading.

Then, on February 24^th^, Russia invaded Ukraine. My first visit to Ukraine was in 2014, just after the Maidan revolution. During eight years, I returned there often and made plenty of friends.

Debug Like a Senior Developer

Fri, 16 Dec 2022 06:34:02 +0000

My book on debugging is already on preorder and I’m super thrilled to announce I’m doing a full online course to go along with it.

The course website isn’t ready yet but I already have the full outline and a lot of recorded material. I will try to drop videos at a rate of two per week in the next few months until the full course will be online.

It’s shaping up to be a very detailed course. I recorded the first module and half of the second module and I’m already close to 3 hours of dense recorded material!

Web resource caching: Server-side

Fri, 09 Dec 2022 15:32:42 +0000

The subject of Web resource caching is as old as the World Wide Web itself.

However, I’d like to offer an as-exhaustive-as-possible catalog of how one can improve performance by caching.

Web resource caching can happen in two different places: client-side - on the browser and server side.

In the previous post , I explained the former; this post focuses on the latter.

While client-side caching works well, it has one central issue: to serve the resource locally, it must first have it in the cache. Thus, each client needs its cached resource. If the requested resource is intensive to compute, it doesn’t scale.

JFR Event Collection

Thu, 08 Dec 2022 10:08:52 +0000

Ever wondered what all the JDK Flight Recorder events are, in which JDK versions they are supported, and what examples of an event looks like?

Wonder no more, I created the JFR Event Collection website which contains all this and more.

This site gives you an up-to-date collection of all OpenJDK JFR events for every JDK since 11, giving you the following additional information:

configuration properties
fields with their types and description
examples from a renaissance benchmark run
with which GC this event appears
additional descriptions collected by JFR users

The idea for this website came during the development of my prototypical JFR UI:

What is An Application Server? In 3 Minutes!

Thu, 01 Dec 2022 17:01:44 +0000

Low on time and want to know what an ‘application server’ really is?

Here we offer our explanation. This video covers the difference between application servers and web servers, what an application server can do to make your life as a developer easier, and more, all in less time than your average pop song!

This is a high-level view that might be helpful to pass on to managers and procurement teams who aren’t sure what an application server is.

AP-Loader: A New Way to Use and Embed async-profiler

Tue, 22 Nov 2022 14:54:35 +0000

Using async-profiler can be quite a hassle.

First, you have to download the right archive from GitHub for your OS and architecture, then you have to unpack it and place it somewhere.

Or you get it from your OS distribution, hoping that it is the current version.

It gets worse if you want to embed it into your library, agent, or application. Library developers cannot just use a Maven dependency but have to create wrapper code and build scripts that deal with packaging the binaries themselves. Or, worse, they depend on a preinstalled version which they do not control.

Payara Launches Payara Cloud – Serverless for Jakarta EE

Tue, 15 Nov 2022 16:31:30 +0000

The cloud native application runtime automates tasks like Kubernetes deployment, ingress and YAML.

Payara has launched a new product ++Payara Cloud++ , designed to run Jakarta EE apps easily and quickly on the cloud.

Developers simply upload any web application following the Jakarta Web Profile specification and run it in a containerized Payara Micro instance.

Payara Cloud deals with infrastructure, allowing them to build the code and concentrate on business logic.

Geo-routing with Apache APISIX

Mon, 07 Nov 2022 16:41:47 +0000

Apache APISIX, the Apache-led API Gateway, comes out of the box with many plugins to implement your use case.

Sometimes, however, the plugin you’re looking for is not available.

While creating your own is always possible, it’s sometimes necessary.

Today, I’ll show you how to route users according to their location without writing a single line of Lua code.

Why geo-routing?

Geo-routing is to forward HTTP requests based on a user’s physical location, inferred from their IP. There are many reasons to do that, and here is a couple of them.

Renovate: Dependabot Alternative

Fri, 28 Oct 2022 07:17:55 +0000

I won’t introduce Dependabot . Lots and lots of developers use it daily on GitHub. I do use it as well. However, it suffers from two drawbacks:

While it’s perfectly integrated with GitHub, integrations with other platforms are less seamless.
It’s limited in the list of ecosystems it supports For example, I generally use Docker Compose files for my demos. When necessary, I use Kubernetes. Dependabot supports none.Worse, Dependabot doesn’t accept contributions to add new ecosystems .

Recently, I watched Viktor Farcic’s Automate Dependency Management With Renovate . I found Renovate super neat, thought about using it, and… forgot. Then I stumbled upon another mention of it. It pushed me to implement it in two locations:

Java on Azure Tooling Update – September 2022

Mon, 17 Oct 2022 09:25:59 +0000

Hi everyone, welcome back to September update of Java on Azure Tooling.

In this update, we will introduce the Azure Cosmos DB Support, Azure Virtual Machine Enhancement.

In addition, we have made some improvements for users to create/update the dependencies with Azure SDK Reference Book.

Please download and install the Azure Toolkit for IntelliJ .

We hope you like these features and enjoy the smooth experience with our Azure toolkit. So let us get started.

Java on Azure Tooling Update – August 2022

Mon, 17 Oct 2022 09:15:27 +0000

Hi everyone, welcome back to August update of Java on Azure Tooling.

In this update, we will introduce the AKS support and Virtual Machine support.

In addition, we make some improvements for users to search for subscriptions and find our tutorials easily.

We hope these features could improve your user experience. So let us get started.

Azure Toolkit for IntelliJ Improvements

AKS Management Support

Azure Kubernetes Service (AKS) simplifies deploying a managed Kubernetes cluster in Azure by offloading the operational overhead to Azure. You can find more details about Azure Kubernetes Service (AKS) .

Starting Docker Desktop with Spring Boot

Fri, 30 Sep 2022 05:37:53 +0000

I came across Docker Desktop for the first time about three years ago, when I was working as a Principal Architect (Strategic R & D) on the Microservices Reference Architecture for a product development organization.

At that time, when I was working on my corporate laptop - It became a tedious task to configure virtualization and settings to get it to work. Once I got it running smoothly, I realized that the memory requirements required to run it is quite high. At times, I found it tough to use my laptop for daily development with it running. It was also because I was working on microservices and had almost 6+ spring boot applications running.

External Debugging Tools 3: JMXTerm

Fri, 26 Aug 2022 14:52:23 +0000

When tracking a bug we need to take a two pronged approach. Similar to tongs that wrap the buggy module from both sides and squeezes to find the problematic part. Up until now we discussed tools that are very low level. Some can be used to debug system level services. Today we’ll discuss the other side of the stack but still a very advanced management tool. To understand this you need to understand the field we’re in.

External Debugging Tools 1: dtrace and strace

Fri, 05 Aug 2022 13:13:43 +0000

Often when debugging, we need to step outside of the comforting embrace of the IDE to reproduce or track an issue.

In this series, I’d like to go over some tools you might find useful for these cases. I’ll try to limit myself to tools that are 100% debugging tools and not those that are useful for development testing.

E.g., tools like curl or jq are remarkably useful. You can/should use them while debugging. But you probably used them while building and testing the feature. So you would already be familiar with them and should have some sense of what they do. I want to focus on tools that you would mostly reach for when debugging. In that sense, tools like SDKMan etc. also make no sense here.

Write Your Own Service Discovery Client for Apache APISIX

Mon, 01 Aug 2022 10:27:42 +0000

API Gateways in general, and Apache APISIX in particular, provide a single entry point into one’s information system.

This architecture allows for managing load balancing and failover over similar nodes.

For example, here’s how you can create a route balanced over two nodes in Apache APISIX:

curl http://localhost:9080/apisix/admin/routes/1 -H 'X-API-KEY: edd1c9f034335f136f87ad84b625c8f1' -X PUT -i -d '{
 "uri": "/*",
 "upstream": {
 "type": "roundrobin",
 "nodes": {
 "192.168.0.1:80": 1, # 1
 "192.168.0.2:80": 1 # 1
 }
 }
}'

Every request has a 50/50 chance of being sent to either node

It worked for a long time, but in this day and age, nodes are probably not pets but cattle: they come, and they go. Hence, it’s essential to dynamically update the nodes list when it happens.

Java on Azure Tooling Update – June 2022

Mon, 13 Jun 2022 07:40:38 +0000

Hi everyone, welcome back to June update of Java on Azure Tooling.

In this update, we will introduce the new application-centric view on Azure toolkit for IntelliJ that will make the interface more user-friendly.

In addition, we have added support for more Azure services.

For Gradle plugins, we have some new features for Azure Web Apps and Azure Functions.

We hope you like these new features and share your feedback with us. So let us get right into it…

Running Jekyll on a Mac

Mon, 06 Jun 2022 17:41:49 +0000

At the beginning of the year, I had two new Macs in a row in one month. I changed my company and had to return my previous laptop. Thus, I ordered a replacement one, but due to the current hardware shortage, the shipping took weeks: I had to rent one in the meanwhile.

It means I had to install my Jekyll stack twice in a row. The first time took quite some time; the second one was much faster.

How to run the Java Incubator Module from the Command Line and IntelliJ IDEA

Tue, 10 May 2022 16:52:15 +0000

JEP 425: Virtual Threads (Preview) has been proposed recently. It has been a long-awaited feature in Java. It opens the door to Structured Concurrency. This article isn’t about it, in case you are interested, you can read, the JEP draft: Structured Concurrency (Incubator)

Also, if you are interested in how the incubator module works, please read: JEP 11: Incubator Modules

I downloaded the early access build and wrote the following very simple program that demonstrates structure concurrency.

How to enable java preview feature and run code from IntelliJ IDEA

Sun, 08 May 2022 10:07:50 +0000

JEP 425: Virtual Threads (Preview) has been proposed recently. It has been a long-awaited feature in Java. I wanted to give it a try. So I download the early release of JDK which has the project loom in it. However, it is under preview.

The following snippet was pretty much my first program written for testing virtual threads.

public class Main {
 public static void main(String[] args) throws InterruptedException {
 Thread.startVirtualThread(() -> {
 System.out.println("Hello from virtual thread");
 }).join();
 }
}

It is so simple that I could just run it in the command line using the source code launcher :

Easy Jakarta EE Integration Testing

Wed, 04 May 2022 14:41:49 +0000

One major issue when developing modern enterprise applications is the “works on my machine” problem: when an application works well on your machine but is not functional in production or even on a colleague’s machine.

An even more prevalent problem is to maintain the quality of ever-changing applications during development and maintenance.

This is especially prevalent when Jakarta EE applications are developed and not properly tested in an isolated and cohesive manner.

Hardware Acceleration For Java? TornadoVM Can Do It!

Fri, 01 Apr 2022 07:37:03 +0000

Java programs can primarily run on x86 and Arm platforms and recent efforts focus on ports to PowerPC and RISC-V.

Despite the diverse range of ISAs, contemporary computers are equipped with heterogeneous devices, such as Graphics Processing Units (GPUs), Field Programmable Gate Arrays (FPGAs), and Tensor Processing Units (TPUs), which operate as co-processors that offload data processing from the main processor.

A question that rises is whether such compute power can be utilized by Java programs. The answer is that several frameworks have been created to address this challenge. For instance, IBM J9 , Aparapi , and TornadoVM , are frameworks that aid Java programmers to accelerate their programs on heterogeneous hardware devices.

JDKMon 17.0.23 Released

Fri, 11 Mar 2022 09:52:39 +0000

JDKMon is a little tool written in JavaFX that tries to detect all OpenJDK distributions installed on your machine while keeping track of updates for those distributions.

It will scan for new updates every three hours and will inform you about available updates.

Note: JDKMon won’t install the distributions on your machine but will enable you to download them to a place of your choice.

At the moment the following distributions are supported:

The Flatten Maven plugin - fooay.io

Mon, 31 Jan 2022 14:06:05 +0000

One of the Apache Maven committers recently wrote about their plans for Maven 5 . I consider the following one of the most significant changes:

In summary, we need to make a distinction between two POM types: the build POM, stored in the project source control, that uses v5 schema for build time, requiring a new Maven version able to use the new features associated with the new schema. The other one is the consumer POM, that is published to Maven Central in the good old v4 schema, so every past or future build tool can continue to consume pre-built artifacts as usual for their dependencies.

Monitoring Spring Boot Applications (Part 1)

Wed, 12 Jan 2022 16:34:53 +0000

In part 1 of this series, we will learn about JDK Flight Recorder and how we can use it to monitor a Spring Boot application.

Introduction

Application monitoring is one thing that we as developers cannot overlook. It doesn’t matter if you run a monolith or microservices application because application monitoring is a must for production workloads to know what’s happening with your application. If you are using Spring Boot, there are different ways to monitor an application. The most popular way to monitor a Spring Boot application is to enable the spring-boot-actuator module to achieve the desired result.

JDKMon 17.0.18 Released

Mon, 20 Dec 2021 09:06:26 +0000

JDKMon is a little tool written in JavaFX that tries to detect all OpenJDK distributions installed on your machine and keep track of updates for those distributions.

It will scan for new updates every three hours and will inform you about available updates.

JDKMon won’t install the distributions on your machine but will enable you to download them to a place of your choice.

At the moment the following distributions are supported:

Port Management in Local Kubernetes Clusters

Mon, 29 Nov 2021 08:44:25 +0000

Most of my talks contain a demo. A fair share of these demos require multiple “infrastructure” dependencies: a database (or more), Elasticsearch, you name it. To ease my setup and avoid messing up my machine, I use either Docker Compose or Kubernetes locally on my Mac. Both rely on Docker Desktop.

To expose a cluster Service on my host, I use nodePort. Hence, I set a dedicated node port for each service. I need to remember each of them for each demo. Worse, services might be (are) declared across different manifest files.

Git Archeology: Removing the Sands of Time from Code

Sat, 23 Oct 2021 06:55:03 +0000

Working on a large codebase, it’s pretty normal to not remember every small or large subsystem or implementation choice. Be it whether you’re new to a codebase, or you’ve been focused on a specific area of the codebase.

When working on refactorings or bug fixes, I often end up in areas I might not be too familiar with. Generally not dramatic, it happens quite often that I’m stopping what I’m doing because I need to decide on how to move forward. As software engineers, we have to make so many micro-decisions every minute that we’re pretty used to it.

Updating Data Files: Commits vs. Pull Requests?

Wed, 18 Aug 2021 17:22:05 +0000

For once, I’m wondering a bit if this article can be helpful to somebody else since I believe my context is pretty specific. Anyway, just in case it might be the helpful case, here it is!

My Jet Train project makes use of GTFS . GTFS stands for General Transit Feed Specification. It models public transportation schedules and their associated geographic information.

GTFS is based on two kinds of data, static data, and dynamic data. Static data may change but do so rarely, e.g., transit agencies and bus stations. They are available as static files that you need to download now and then. Before, I had to download and overwrite them every time I run the demo.

GitLab: Your Continuous Deployment One-Stop Shop

Wed, 04 Aug 2021 07:44:20 +0000

This week, I want to take a break from my Rust series and focus on a different subject. I’ve already written about my blogging stack in detail.

However, I didn’t touch on one facet and that facet is how I generate the static pages from Jekyll. As I describe in the blog post, I’ve included quite a couple of customizations. Some of them require external dependencies, such as:

A for PlantUML diagrams generation
The graphviz package for the same reason
etc.

All in all, it means that I require a fully configured system. I solved this problem by using containerization, namely Docker. Within the Dockerfile, I’m able to install all required dependencies. Then, in my GitLab build file, I can reference this image and benefit from all its capabilities.

JDKMon: Your Friendly JDK Distribution Updater

Tue, 06 Jul 2021 06:59:15 +0000

I don’t know if you have the same problem but I have around 8 OpenJDK distributions installed on my machine and I always have the problem of keeping them up to date. I know there is sdkman which is awesome but I somehow never got used to it.

Meaning to say I download the OpenJDK distributions manually and install them on my machine. So the main problem is that there so many different distributions out there and all of them have a different way on how to get the latest version. To solve exactly this problem we at foojay.io created the DiscoAPI which keeps track on (hopefully) all available OpenJDK distributions available. Well and because we like to eat our own dogfood I’ve created a little tool that helps me keeping my installed OpenJDK distributions up to date… JDKMon .

Troubleshooting Java Processes Running on Your Machine

Fri, 02 Jul 2021 09:27:12 +0000

When your application has some problem, the first thing to check is running processes on the machine.

For Linux OS we generally use ps -ef. ps is one of the most used Linux troubleshooting commands. The JDK provides similar functionality for Java processes through jps. The jps command-line utility provides a list of all running Java processes on a machine for which the user has access rights. The access rights are determined by access-control mechanisms specific to the operating system.

Announcement: JMC 8.0.1 Has Been Released!

Fri, 25 Jun 2021 18:10:26 +0000

The 8.0.1-ga tag was just set in the jmc8 repository on GitHub. This is a patch update release, and will therefore not include any new features.

The 8.0.1 release contains the following fixes:

Jira Issue	Summary
7188	JMC fails to dump file and gets stuck when flightrecording is attempted on jmxremote connection
7172	Fix spell mistake in secure store class
6920	UI improvements
6336	Remove Triple DES Cipher in Secure store
6398	Better JNDI Usage

It is up to individual vendors to release binaries of JMC 8.0.1, and some vendors already have binary builds available, for example Oracle .

How to Debug Java on the Command Line

Thu, 24 Jun 2021 16:51:14 +0000

Some bugs are hard to replicate on your personal computer but easily replicated on production or test machines. It is a common situation that professional Java developers deal with frequently. To debug such problems, OpenJDK provides two tools, remote debugging and jdb.

This article focuses on jdb.

For Java applications, typical production and test machines are Linux servers without display managers, so that only command line tools are available. Here we cannot use professional IDEs like IntelliJ IDEA, Eclipse, or Apache NetBeans IDE.

Hazelcast, from Embedded to Client-Server

Fri, 23 Apr 2021 06:58:00 +0000

Java developers are particularly spoiled when using Hazelcast. Because Hazelcast is developed in Java, it’s available as a JAR, and we can integrate it as a library in our application. Just add it to the application’s classpath, start a node, and we’re good to go. However, I believe that once you start relying on Hazelcast as a critical infrastructure component, embedding limits your options. In this post, I’d like to dive a bit deeper into the subject.

How to create your own custom Spring Data repository

Wed, 14 Apr 2021 07:33:08 +0000

Frameworks promise to speed up one’s development pace provided one follows the mainstream path.

The path may be more or less narrow. I’m a big fan of the Spring ecosystem because its design is extensible and customizable at different abstraction levels: thus, the path is as large as you need it to be.

Functional Programming is becoming more and more popular. Spring provides a couple of s for the Kotlin language. For example, the Beans DSL and the Routes DSL allow for a more functional approach toward Spring configuration. On the type side, Vavr (previously Javaslang) is pretty popular in Java, while Kotlin has Arrow .

Towards Continuous Performance Regression Testing

Thu, 25 Feb 2021 09:44:43 +0000

Functional unit and integration tests are a standard tool of any software development organization, helping not only to ensure correctness of newly implemented code, but also to identify regressions — bugs in existing functionality introduced by a code change. The situation looks different though when it comes to regressions related to non-functional requirements, in particular performance-related ones: How to detect increased response times in a web application? How to identify decreased throughput?

Eliminate the Nightmare of Debugging Java Concurrency Bugs

Wed, 10 Feb 2021 17:58:33 +0000

Writing concurrent programs is hard, testing concurrent programs is harder, and debugging concurrent programs is a nightmare. An incorrect concurrent program can run for years, tricking us to believe it is stable code, and it fails when we least expect.

JCStress is a concurrency stress test tool used by JVM developers to test the correctness of the JVM itself.

The OpenJDK provides this amazing tool to test the correctness of your concurrent programs.

Getting Started with VS Code for Java Developers

Mon, 08 Feb 2021 08:10:07 +0000

VS Code, a.k.a. Visual Studio Code, is a modern editor available for Windows, macOS and Linux. It supports many languages and runtimes including Java. Besides editing features like IntelliSense, Code Action, etc., developers and students also like its lightweight, modern UI, extensibility, and the comprehensive support of remote development. Also, it’s free. You can refer to VS Code Overview for more details.

On Java, thanks to the investments communities and Microsoft have been constantly making, VS Code has been used by more and more Java developers to edit, build, run, debug, test and deploy their code and manage their projects, and by more and more students and educators to learn and teach Java language.

A Compendium of 2021 Java & OpenJDK Predictions

Fri, 22 Jan 2021 08:03:25 +0000

Now that 2021 is well underway, many prominent Java developers have taken the time to predict what 2021 may bring to the Java universe.

In December, here on Foojay.io, several articles were published on this theme, such as Java Predictions for 2021 , Java Predictions for 2021: Jakarta EE , and Java Predictions for 2021: Raspberry Pi . In early January, Simon Ritter published Staring Into My Java Snow Globe 2021 . Separately, I conversed with another six developers about their visions for the coming year.

Using Java Flight Recorder and Mission Control (Part 3)

Thu, 19 Nov 2020 09:13:02 +0000

Continuing from part 1 and part 2 , while from JDK 14 events can be consumed on the fly, previous JDK versions (from JDK 11) offer a public API useful enough to control Flight Recorder programmatically or to read events from a JFR file.

Configuration c = Configuration.getConfiguration("profile"); [1]
Recording r = new Recording(c);
r.setName("monitor jvm");
r.enable("jdk.*"); [2]
r.setMaxAge(java.time.Duration.ofMinutes(4)); [3]
r.start(); [4]

// to be profiled

r.stop(); [5]
r.dump(Files.createFile("/var/log/jfr/app-initiated.jfr")); [6]

As shown above, choose the JFR configuration.
Choose which events the recording should be interested in. Another signature accepts classes, it’s unlikely to be helpful for JDK events, but it may get interesting for custom events, your classes.
Eventually set recording constraints, like the maximum age of the records.
Hit record.
When the recording session is over, stop JFR.
Then store the results in the location of your choosing.

The above snippet creates a continuous profiling session with a 4 minute window.

Using Java Flight Recorder and Mission Control (Part 2)

Thu, 05 Nov 2020 16:50:59 +0000

Now, continuing from part 1 , to exploit the recording by analyzing it, we have a tool named jfr that ships with the JDK. On Linux the alternative jdk management may not be aware of jfr, which means you may need to use the full path to this executable.

The first interesting thing to do is to get an overview of the recording, the summary sub-command displays an histogram of the events, shown below.

Using Java Flight Recorder and Mission Control (Part 1)

Mon, 02 Nov 2020 09:49:11 +0000

Java Flight Recorder is the profiler you can use in production, continuously. Flight Recorder has been available before in the JDK, e.g., it shipped as part of the JDK 8, but to use it, it required that you set specific commercial VM flags to unlock Flight Recorder, this is not anymore necessary from Java 11 onwards.

|—|———————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————-| | | This page assumes JDK 11, that means there is no need to set -XX:+UnlockCommercialFeatures, -XX:+FlightRecorder flags. Or, more particular to JFR, the use of -XX:+UnlockDiagnosticVMOptions and -XX:+DebugNonSafepoints source |

Live Templates for Java Developers in IntelliJ IDEA

Mon, 26 Oct 2020 08:31:52 +0000

Okay, I did the math. If you use all 38 of the Live Templates for Java that are available out of the box in IntelliJ IDEA 2020.2, you will save your finger pads approximately 2092 presses of wear and tear, and that’s just each one once, the reality is likely to be substantially higher.

I will caveat this by saying that I counted the unresolved variables, yours may be longer or shorter. Still, it’s impressive!

Fixing Vulnerabilities in Maven-Based Projects

Tue, 20 Oct 2020 06:40:22 +0000

Maven is still the most used build system in the Java ecosystem. According to the JVM report 2020 , Maven is the number one build tool in the ecosystem with two-thirds of the share.

Therefore, it is important to know how Maven works. For instance, if you find vulnerabilities in your Maven project using Snyk, how can you fix them?

In this article, I will explain how you can fix vulnerabilities in third-party libraries when using Maven, even when it is not obvious.

Why You Should Join EclipseCon Community Day

Thu, 08 Oct 2020 06:46:57 +0000

EclipseCon Community Day is on Monday, October 19 14:00 to 18:00 CET (the day before the start of the main EclipseCon conference). Community Day at EclipseCon has always been a great event for Eclipse working groups and project teams. This year both EclipseCon and Community Day is virtual and free. Space for Community Day is limited, so please register and save your spot soon.

We have a packed agenda centered on the Jakarta EE, MicroProfile and Cloud Native Java communities. If there is a set of very focused sessions you should attend on these topics, the agenda offers the one place this year to do so. The sessions are intended not only for learning, but also for the community to actively engage with some key leaders. Note, after you register for EclipseCon, you will need to reserve your spot for Community Day through the Swapcard platform (let me know if you run into any issues).

New to IntelliJ IDEA by JetBrains? Me Too!

Fri, 02 Oct 2020 10:07:49 +0000

Until recently, I last wrote Java in anger in 2002. IntelliJ IDEA had just been released; it wasn’t remotely on my radar. I honestly can’t remember what IDE we were using back then, but it certainly was a very long way to the fully featured IDE that JetBrains produce today.

Here’s my experience of using IntelliJ IDEA for the first time!

1. Downloading IntelliJ IDEA

There’s a lot going on when you first load IntelliJ IDEA, but I learned pretty quickly that there are also some good first steps you can take to make your experience a little more comfortable.