Developer 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.

Toward a Durable Spring PetClinic

Sun, 19 Jul 2026 18:06:06 +0000

Overview

Durable Execution is a way of running code so that its progress survives failure. A normal program keeps its state in memory: if the process crashes, the machine reboots, or a network call times out halfway through a multi-step operation, that state is gone and the work is left half-done.

Temporal, the Durable Execution platform, persists every step of a process to its Event History — a durable, append-only log of Events — so that after any failure the work resumes exactly where it left off, as if the crash never happened.

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.

"This Can't Possibly Work": What I Learned at a Temporal.io Workshop

Fri, 10 Jul 2026 08:41:22 +0000

When developers first hear about Temporal , they tend to move through a predictable sequence of emotions. First comes disbelief — the claim that your application can crash mid-execution and simply pick up where it left off, variables intact, sounds like nonsense. Then comes irritation that anyone would even say such a thing is possible. Then they try it, discover it actually works, and get very excited. And finally they ask the only question that matters: how?

BoxLang 1.14.0 : Sets, Ranges, Inner Classes, and a Runtime That Talks Back

Thu, 09 Jul 2026 18:02:59 +0000

BoxLang has never stood still, but 1.14.0 is something different. This is the release where the language stops filling gaps and starts defining what a modern dynamic JVM language looks like on its own terms. Sixty-five issues closed. Four innovative language features. A formatter that has grown up. And a companion module - bx-mcp - that fundamentally changes how you operate a running BoxLang application with AI.

This could have easily been a major release for the team. This has been a really amazing effort by everybody at Ortus and all of the amazing feedback from our clients migrating to BoxLang and coming up with such amazing and innovative ideas for this platform. We have only just begun!

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.

AI-Assisted Unused & Dead Code Removal

Sun, 28 Jun 2026 07:19:42 +0000

Why Your Codebase Is Forcing AI to Underperform, and What to Do About It

Your AI coding assistant is only as good as the codebase it works on. If your Java application carries years of dead & unused code, and most do, the AI spends its reasoning budget on code that nobody runs. The result is more hallucinations, worse suggestions, and higher token costs. Here’s what to do about it.

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.

Quarkus Unpacked: Insights from the Foojay Podcast

Tue, 23 Jun 2026 12:36:54 +0000

I recently had the pleasure of joining the Foojay podcast to talk about Quarkus in depth. The conversation covered a lot of ground, from what makes Quarkus different to the practical trade-offs between JVM and native mode. This post captures the key questions and answers from that discussion, lightly edited for readability.{#_quarkus_unpacked_insights_from_the_foojay_podcast}

If you have been following this blog series, note that the third installment on building your own stack with Quarkus is coming next. Consider this a bonus entry that distills the podcast conversation into a format you can read, reference, and share.

Where production policy belongs: building Eliya in public

Fri, 19 Jun 2026 08:15:28 +0000

This is an argument about where production intent belongs in a managed runtime, and the OpenJDK distribution we built to act on it - Eliya, an opinionated, compliance-conscious OpenJDK distribution. This is the first article in a series. The later parts are engineering: reproducible builds, the glibc floor, release signing, the one source patch we shipped. This part is the thesis they all serve.

Every configurable system has two spaces. The configuration space: every behaviour you can reach by setting the knobs the system already exposes. And there’s the implementation space: behaviour that only exists if someone goes in and changes the internals.

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.

Observing Apache NetBeans with OpenTelemetry and Dash0

Sun, 14 Jun 2026 22:03:09 +0000

What happens when you point an observability agent at your IDE rather than your application?

The question nobody thinks to ask

Observability is something we do to our applications. We instrument services, add trace context to HTTP requests, collect JVM heap metrics, ship logs to a backend. The IDE we use to write that instrumentation is — by convention — invisible. It just runs. When it is slow, we assume it is busy. When it crashes, we restart it. We have no data.

BoxLang 1.14.0 : Introducing Inner Classes

Thu, 11 Jun 2026 10:29:32 +0000

BoxLang has always embraced a simple truth: the way you organize code shapes the way you think about problems. For a long time, if you needed a helper class, you needed a file. One class, one .bx file, no exceptions. This also stemmed from the CFML days. That’s clean and predictable, but it creates real friction when a class is tightly coupled to exactly one caller and has no business existing anywhere else.

Context Is Code: A Tour of APM and AgentRC

Fri, 05 Jun 2026 08:35:05 +0000

If you’ve shipped an AI agent into a real codebase in the last twelve months, you’ve felt this: every agent, every developer, every machine — different setup. A README that says “install these extensions.” A copilot-instructions.md somebody copy-pasted from another repo. MCP server configs in three different files. The same skills duplicated for Copilot, Claude, Cursor, and Codex.

No version pinning.

No integrity.

No reproducibility.

That’s the problem APM , the Agent Package Manager fixes. And it pairs with AgentRC to close the loop on generating and evaluating that context in the first place.

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.

Enterprise Java quality gates in the age of AI

Fri, 29 May 2026 07:00:00 +0000

People and AI can write code together, but enterprise repositories still need deterministic quality gates to protect code quality.

Enterprise quality is a scaling problem

Enterprise Java development is not only about writing correct code. It is about keeping a large, long-lived codebase understandable, reviewable and safe to change while many people and many tools touch it over time.

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.

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.

Context Is a Budget — Reducing Token Usage in AI-Assisted Development

Fri, 22 May 2026 12:52:06 +0000

Eight levers and three workflow patterns that pay for themselves in a week.

A team of fifty developers can quietly burn $30,000 a month on AI coding assistants without anyone noticing. Premium-request quotas vanish by the third week. The bill arrives. Nobody has a story for where it went.

The cost is the obvious pain. The other two are sneakier:

Latency. Bigger contexts take longer. The model thinks more, but you also wait more.
Context rot. This is the surprising one. Anthropic and Chroma have both shown that as the context window fills up, model recall and reasoning degrade — even well inside the advertised window. The 200K-token model is genuinely worse at the 150K mark than at the 20K mark. More context is not free; past a point, it’s actively harmful.

The mental model that fixes all three: stop treating context as a free buffet. Treat it as a budget you spend on every turn.

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. 🎯

From Zero (Really Zero) to OpenTelemetry

Tue, 19 May 2026 13:36:11 +0000

Here’s a super awesome prompt (e.g., for Claude Code) that you can use with https://github.com/dash0hq/agent-skills , the free collection of skills for AI coding agents to make applications observable with OpenTelemetry, such as with Dash0 .

And the end result is this, a view into the traces of your application (without anything at all at the start of the process).

The Super Awesome Prompt

Take a careful look below: before doing this prompt, not only do we not have an application that is instrumented with OpenTelemetry yet. Not only do we not have the agent we need to do the instrumentation yet.

BoxLang v1.13.0: Compatibility, Concurrency, and Formatter Maturity

Tue, 19 May 2026 12:11:19 +0000

BoxLang 1.13.0 is a stability-first release with deep compatibility work and runtime hardening. This build closes 48 issues, with the majority focused on CFML compatibility edge cases, concurrency correctness, formatting parity, and miniserver/runtime reliability under real production loads.

While this release is bug-fix heavy, it still introduces several meaningful features and quality-of-life improvements: character-aware trimming, class metadata lookup by absolute path, process environment control in SystemExecute(), SOAP headers, new query column rename capabilities, and safer miniserver routing/security defaults.

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:

How to Develop AI Agents Using BoxLang AI: A Practical Guide

Tue, 12 May 2026 12:52:39 +0000

AI agents are transforming how we build software. Unlike traditional chatbots that just answer questions, agents can reason about what tools they need, decide when to use them, chain multiple actions together, and remember what happened earlier in a conversation.

In this tutorial, I’ll show you how to build a real-world AI agent using BoxLang AI — the official AI framework for the BoxLang JVM language. We’ll build SupportBot, an e-commerce customer support agent that can look up orders, check inventory, issue refunds, and answer questions grounded in your knowledge base.

BoxLang AI Deep Dive — Part 7 of 7: MCP — The Protocol That Connects Everything

Thu, 07 May 2026 21:51:08 +0000

BoxLang AI 3.0 Series · Part 7 of 7

The AI ecosystem has a tool problem. Every framework has its own way of defining tools, every agent has its own way of calling them, and every integration requires custom code on both sides. An agent built in Python can’t easily use tools built in Java. An MCP server written for Claude Desktop can’t easily be consumed by a BoxLang agent without a custom adapter.

BoxLang AI Deep Dive — Part 5 of 7: One API, 17 Providers — The Provider Architecture Deep Dive

Wed, 29 Apr 2026 16:38:08 +0000

BoxLang AI 3.0 Series · Part 5 of 7

Vendor lock-in is the silent killer of AI projects. You pick OpenAI, build everything against the OpenAI API, and then GPT-5 launches at three times the price. Or a competitor launches a model that’s faster for your use case. Or you need to self-host for compliance. Or your client is on AWS and wants Bedrock.

Every time the answer to “can we switch providers?” is “it would take months,” something went wrong architecturally.

The Road to Docker Official Images for Java: The Azul Zulu Story

Fri, 24 Apr 2026 08:57:12 +0000

Previously in this series:

Trusted Java Containers: Azul Zulu OpenJDK Joins Docker’s Official Images

After more than two years of collaboration, reviews, and back-and-forth with the Docker team, Azul Zulu Builds of OpenJDK have officially joined Docker’s Official Images program. This is not just a badge of honor. It changes how Java developers can pull and trust their container base images.

The formal announcement is on the Azul blog . In this post, I’ll walk you through what happened, why it matters, and how to start using these images today.

Introducing Floci: A High-Performance, GraalVM-Powered AWS Emulator

Fri, 03 Apr 2026 19:00:53 +0000

The Motivation: Why Another AWS Emulator?

As Java developers, we are used to local-first development. Tools that emulate the cloud environment have become essential for keeping feedback loops tight and costs at zero. However, the ecosystem has shifted. Many of us have felt the friction of:

Mandatory Authentication: Needing to log in or use tokens just to run local tests.
Heavy Resource Footprint: Docker containers that consume a lot of resources.
Slow Startup: Waiting several seconds for the environment to be ready.

I created Floci (from the floccus cloud formation) to solve these specific pain points. It is a 100% open-source, MIT-licensed alternative designed for speed, privacy, and simplicity.

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.

JC-AI Newsletter #15

Fri, 20 Mar 2026 07:56:01 +0000

Over the past two weeks, the field of artificial intelligence has continued its remarkable pace of advancement. As AI becomes increasingly woven into the fabric of daily life, shaping how we work, communicate, and make decisions, it is both timely and valuable to step back and understand the broader trajectory of this technology. Whether the developments around us feel promising or challenging, one truth remains clear: AI is not simply leaving. It is here to stay, and understanding its evolution is essential from many perspectives.

Introducing the BoxLang Spring Boot Starter: Dynamic JVM Templating for Spring

Thu, 19 Mar 2026 14:20:02 +0000

Spring Boot developers know the pain of evaluating view technologies. Thymeleaf is great — until you need more expressiveness. FreeMarker is powerful — until the syntax fights you. What if you could write templates in a dynamic JVM language that gives you the full power of the platform, feels natural, and requires zero setup to integrate?

Meet the BoxLang Spring Boot Starter.

TL;DR: Drop one dependency into your Spring Boot 3 app and start writing dynamic .bxm templates powered by BoxLang — a modern, expressive JVM language. Zero configuration. Full web scopes. 100% Java interoperable. Not only that, you get full access to BoxLang’s framework capabilities so you can integrate tons of features into your Spring Boot applications:

BoxLang 1.11.0 Release

Tue, 17 Mar 2026 09:40:04 +0000

We’re proud to announce BoxLang 1.11.0, a highly focused performance and stability release that delivers measurable speed improvements across every BoxLang application, with zero code changes required. The team invested deeply in bytecode generation, class loading, lock management, and type casting to produce one of the most impactful runtime optimization releases to date. Alongside the performance wave, this release resolves critical concurrency bugs, hardens DateTime handling, and ships powerful new developer tooling.

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.

25 Years of IntelliJ IDEA: The IDE That Grew Up With Java

Mon, 02 Mar 2026 07:21:06 +0000

In this Foojay Podcast, we’re celebrating a major milestone in Java development history: 25 years of IntelliJ IDEA.

Think about it: IntelliJ IDEA launched in 2000, and since then, it has become the go-to IDE for millions of Java developers worldwide. From its revolutionary code completion and refactoring tools to AI-powered features and the recent unified Community and Ultimate release, IntelliJ has shaped how we write Java, and keeps reinventing itself to stay ahead.

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.

How to Customize JaCoCo Report Styling in Your Java Project

Fri, 13 Feb 2026 13:10:45 +0000

JaCoCo is the go-to code coverage tool for Java projects. It integrates seamlessly with Maven, generates detailed HTML reports, and works out of the box. But let’s be honest — the default reports look like they were designed in 2008, because they were.

If you’re publishing coverage reports as part of your project documentation (on GitHub Pages, for example), you probably want them to match your site’s look and feel. The good news: it’s entirely possible. The bad news: JaCoCo offers zero built-in support for CSS customization.

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.

DocBox v5 - Reborn: Modern API Docs for BoxLang & CFML

Tue, 27 Jan 2026 12:15:45 +0000

Welcome to DocBox v5! We didn’t just update DocBox. We rebuilt it from the ground up.

DocBox v5.0.0 represents a complete architectural rewrite—modern syntax, blazing performance, and a stunning new look that finally brings API documentation into 2025. Gone are the clunky HTML pages of yesteryear. Say hello to a gorgeous, theme-driven single-page application that makes browsing your API docs feel like using a premium developer tool. We have also released a dedicated module for BoxLang: BX-DOCBOX. A fully interactive CLI tool for generating your docs from the command line using pure BoxLang.

BoxLang AI v2: Enterprise AI Development Without the Complexity

Thu, 22 Jan 2026 15:09:25 +0000

One Year. 100+ Features. Unlimited Possibilities.

Just one year ago, in March 2024, we launched BoxLang AI 1.0. Today, we’re thrilled to announce BoxLang AI v2—a massive leap forward that positions BoxLang as one of the most powerful and versatile AI framework on the JVM. This release is 9-months in the making, with over 100 new features! This would have not been possible without all the new features that the BoxLang JVM language exposes to developers like: Server Side Events, HTTP Streaming, HTTP pooling, Caching, and so much more.

SonarQube AI Code Assurance & MCP: Auto-Fix Java (Part 4)

Mon, 19 Jan 2026 15:27:14 +0000

Hola Java developers! 👋

Welcome to the Grand Finale of our series.

Part 1 : We turned your IDE into a fortress.
Part 2 : We synced the team with Connected Mode.
Part 3 : We secured the Supply Chain (dependencies).

We have become excellent at finding bugs. But let’s be honest: Finding them is only half the battle. Who is going to fix them?

We are drowning in a backlog of “Technical Debt,” “Code Smells,” and “Security Hotspots.” You don’t have enough hours in the day to refactor every complex method or research the perfect fix for a regex denial-of-service vulnerability.

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 .

Stop the trojan horse in your pom : SonarQube Advace Security

Mon, 22 Dec 2025 10:42:41 +0000

Hola Java developers! 👋

Welcome to Part 3.

In Part 1 , we turned your IntelliJ into a security guard.
In Part 2 , we connected it to the server to enforce the Quality Gate.

We are feeling good. Our code is high quality. Our logic is sound. But here is the scary reality: In a modern Spring Boot application, you only wrote about 10% of the code.

The other 90%? It comes from Maven Central. It’s Hibernate, Jackson, Apache Commons, Spring Security… You are building a house, and you made sure your bricks are solid. But did you check if the foundation you bought from a stranger is made of explosive material? 🧨

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.

The End of One-Sized-Fits-All Prompts: Why LLM Models Are No Longer Interchangeable

Sun, 14 Dec 2025 18:48:31 +0000

For developers and product builders, one assumption has guided the last few years of LLM application development. To improve your product, just swap in the latest frontier large language model. Flip a single switch and your tool’s capabilities level up.

But that era is over. We’re now seeing that new models like Anthropic’s Claude Sonnet 4.5 and OpenAI’s GPT-5-Codex have diverged in fundamental ways. The choice of which model to use is no longer a simple engineering decision but a critical product decision. Flip that switch today… and the very texture of your product changes.

How to Release a Java Module to Maven Central with JReleaser and GitHub Actions (2025 Guide)

Fri, 12 Dec 2025 07:42:00 +0000

This article is a tutorial that guides you through the process of releasing a Java module with JReleaser to Maven Central with Github Actions. It is a 2025 update of the foojay.io/today/how-to-release-a-java-module-with-jreleaser-to-maven-central-with-github-actions article.

JReleaser is a tool that streamlines the release process for Java projects, allowing developers to quickly and efficiently publish their modules to Maven Central.

This article will use the SemVer Check project as an example project that uses Maven as a build tool.

How CodeRabbit's Agentic Code Validation helps with code reviews

Sun, 07 Dec 2025 11:10:21 +0000

The 2025 Stack Overflow survey reveals a paradox: while 84% of developers express confidence in adopting AI tools, nearly half (48%) still distrust the accuracy of their outputs. This tension between optimism and skepticism has reshaped how teams think about quality assurance.

From PRD to PR in days (not weeks)

The bottleneck in software development has fundamentally shifted from writing code to validating it.

In the early days of AI-assisted development, the workflow was straightforward: AI suggested code, humans read the suggested snippet and then decided whether or not to accept that suggestion. Tab completion wrote boilerplate. Copilot suggested functions. But a senior engineer still manually validated and chose each line of code to ensure its quality, structure, and safety before making a pull request.

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.

7 habits of Highly Effective Java Coding

Wed, 15 Oct 2025 11:25:03 +0000

From AI User to AI Pro

Let’s be real, AI coding tools are everywhere now. 🤖 They’re no longer some shiny new toy—they’re a part of our daily grind as developers, just like our morning coffee. ☕

For us Java devs, whether we’re wrestling with a giant legacy app or juggling a bunch of microservices, these tools look like a huge win for getting stuff done faster. 🚀

But here’s the catch: just coding faster isn’t the whole story. If you’re not careful, it can actually lead to bigger problems down the road. 🤔

JetBrains and Azul Collaborate on Kotlin Performance in Various JVMs

Wed, 10 Sep 2025 07:11:44 +0000

JetBrains and Azul are collaborating on a shared vision of running Kotlin-generated bytecode on a high-performance Java platform to find new ways to enhance runtime performance. Benchmarks of Kotlin performance on Azul Platform Prime have yielded some eye-opening results.

In this article you will learn:

Kotlin is a high-level programming language designed to interoperate fully with the JVM
Runtime performance and scalability are derived predominantly from the JVM
JetBrains and Azul benchmarked Kotlin on both standard OpenJDK and on Azul Platform Prime, a high-performance Java platform
Platform Prime reduced latencies by 23.9% and improved throughput by as much as 30.5%

As modern JVMs combine language features and runtime optimizations, they unlock new levels of performance.

GitHub workflows tips and tricks

Tue, 26 Aug 2025 12:06:00 +0000

I’ve quite a lengthy experience with GitHub workflows, but not up to the point where I can claim I’m an expert. However, I recently developed a new workflow, and it prompted me to write this post. Feel free to add your own.

What are GitHub workflows?

A workflow is a configurable automated process that will run one or more jobs. Workflows are defined by a YAML file checked in to your repository and will run when triggered by an event in your repository, or they can be triggered manually or at a defined schedule.

Git default options

Tue, 26 Aug 2025 11:59:57 +0000

Git has become a fundamental part of our developers’ daily routine that it’s hard to remember our lives without it. And yet, most of us use a limited set of commands and options. Today, I want to focus on two commands most developers probably use every day and look at the defaults behind them.

git push

After git commit, git push is probably the second most used command. I don’t think I’ll teach you anything with this excerpt from the documentation:

AI Gives Time, Not Confidence: Developer Productivity Toolkit

Mon, 25 Aug 2025 07:07:56 +0000

Let’s be real – keeping up with the pace of software development today is intense. New frameworks pop up and the push for faster, better, and more secure code never stops.

This article is all about cutting through the buzz and looking at how AI-powered tools can actually help you, the Java developer, day-to-day. We’ll dive into specific ways AI can help you through the whole SDLC:

Understanding Complex Tasks
Accelerating Code Creation
Streamlining Cloud Deployment
Creating Effective Tests
Increasing Code Quality and Security
Improving Code Review

Okay, first up: wrapping your head around the job at hand. You know those moments where you need to implement a feature based on requirements that feel a bit… fuzzy. Traditionally, this means lots of reading, maybe drawing diagrams, and asking clarifying questions.

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.

Java 22 to 24: Level up your Java Code by embracing new features in a safe way

Wed, 23 Jul 2025 15:29:09 +0000

Java introduces several new language features in the 22 to 24 versions which collectively simplify code, enhance documentation, and provide powerful tools for bytecode manipulation and advanced stream processing. This article shows you how to leverage these new features with simple examples.

Understanding these new features in Java is crucial for writing updated, efficient, and high quality code. To assist developers in adopting these changes correctly, SonarQube has introduced several new rules designed to check for the proper usage of unnamed variables and patterns, javadoc and markdown, Class-file new API and Stream gatherers, ensuring your code adheres to best practices and avoids common pitfalls.

Multi-cloud Strategies With MongoDB Atlas

Thu, 19 Jun 2025 11:49:29 +0000

In the technological world, the cloud has become more prevalent. It brings many benefits, including flexibility, scalability, faster innovation, and collaboration. Plus, when it comes to data storage and access with databases, it allows data to be located closer to the user for lower latency and thus, faster performance.

Most people have heard of the big cloud providers, such as Azure from Microsoft, Google Cloud, and Amazon Web Services (AWS). But when it comes to a business selecting a cloud provider, how do you choose?

Sonar Connect Amsterdam 2025

Mon, 16 Jun 2025 15:51:13 +0000

Code quality + Code security for Open Source & AI code

In the age of AI, ensuring code quality and code security is more critical than ever. Are you using the best methodologies to introduce GenAI in your company? do you know the risks? have you heard about AI MCP and the benefits ? what about using AI in the full SDLC? do you know the latest features of SonarQube regarding AI and SCA(dependencies vulnerabilities)?

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.

Understanding BSON: A Beginner’s Guide to MongoDB’s Data Format

Thu, 22 May 2025 08:05:06 +0000

When working with MongoDB, it’s easy to think you’re dealing with JSON. After all, the queries, documents, and API responses all look like JSON. But MongoDB is not storing JSON. It’s storing BSON—a binary format designed for efficient storage and fast traversal.

BSON (Binary JSON) is more than just a binary version of JSON. It introduces additional data types like ObjectId, Decimal128, and Timestamp, allowing MongoDB to handle more complex data structures and ensure data integrity. While we might rarely interact with raw BSON directly, understanding how MongoDB stores and processes BSON documents can help us write more efficient queries, handle data conversions properly, and debug unexpected behavior.

You’re Invited to IntelliJ IDEA Conf 2025!

Mon, 05 May 2025 10:20:30 +0000

We are excited to invite you to IntelliJ IDEA Conf 2025, a free virtual event.

IntelliJ IDEA Conf is a celebration of the developer community, bringing together professionals who strive for excellence in software development. Join us for this free, live online conference and learn from industry leaders and experts on June 3–4, 2025.

You’ll be able to learn about a variety of topics, including Core Java, Kotlin, Java and AI, Spring Boot, GraalVM, Gradle, Junit and Kafka. For more details, see the agenda below.

Pull request testing on Kubernetes: vCluster for isolation and costs control

Sun, 16 Mar 2025 11:47:20 +0000

This week’s article is the third and final in my series about running tests on Kubernetes for each pull request. In the first post , I described the app and how to test locally using Testcontainers and in a GitHub workflow. The second post focused on setting up the target environment and running end-to-end tests on Kubernetes.

I concluded the latter by mentioning a significant quandary. Creating a dedicated cluster for each workflow significantly impacts the time it takes to run. On , it took between 5 and 7 minutes to spin off a new cluster. If you create a GKE instance upstream, you face two issues:

Code Reviews with AI a developer guide

Fri, 07 Mar 2025 12:10:37 +0000

Code reviews are a cornerstone of software development. They’re where we share knowledge, catch bugs early, and ensure our code meets the highest standards.

But let’s be honest…

Traditional code reviews can be time-consuming and tedious and sometimes even miss subtle yet critical issues. Enter the age of AI-powered code review, a game-changer that addresses these challenges and elevates code quality to new heights.

This article dives into the common pitfalls of code reviews and explores how AI tools can revolutionize each phase of the development lifecycle.

Find Undead Code in Your Java Environments

Mon, 17 Feb 2025 09:36:55 +0000

10-30% of the custom code in applications is undead code and can just be deleted. Eliminating undead code can enhance the overall performance and maintainability of your applications. Time vampire (n) – a service or application that is said to suck time from engineers by warming up and updating at preternaturally slow speeds.

You’re on deadline to finish a project, and you open the application to do your work. The application informs you that it needs to update before it will open. Based on past experience, you have half an hour to burn before this time vampire is ready.

A Glance into JFR Class and Method Tagging

Mon, 17 Feb 2025 09:26:02 +0000

Ever wonder how the JDK Flight Recorder (JFR) keeps track of the classes and methods it has collected for stack traces and more?

In this short article, I’ll explore JFR tagging and how it works in the OpenJDK.

Remote Development Made Simple with DevPod

Thu, 13 Feb 2025 16:06:30 +0000

I come relatively late to the subject of Remote Development Environments (also known as Cloud Development Environments).

The main reason is that I haven’t worked in a development team for over six years. However, I’m now working for Loft Labs, and we have a product: DevPod . I wanted to understand our value proposition as was on my way to FOSDEM operating the DevPod booth .

The problem

As a former developer, I vividly remember the pain of setting up each developer’s development environment. At the beginning of my career, the architect had to configure my development machine painfully, so it was similar to his setup. Later on, I did the same for my team members repeatedly. The scope of possible discrepancies impacting development is virtually endless: Operating System, of course, version and flavour of the SDKs, e.g., Java’s Eclipse Temurin vs SapMachine, git hooks, etc. It was sweat, toil, and blood on every project.

Encryption and Data Security Market Analysis: Market Analysis 2025

Tue, 07 Jan 2025 09:01:13 +0000

The data encryption and security market continues to evolve as organizations face increasing demands for data protection while maintaining operational efficiency.

The market includes established solutions and innovative approaches to encrypted data processing and security.

Market Overview

The global encryption software market is driven by data protection regulations, Cloud adoption, and the need for secure data processing. Organizations seek solutions that balance robust security with practical operational capabilities.

Competitive Landscape

Anjuna

Anjuna delivers baseline confidential computing capabilities focused on hardware-based security measures. Their platform implements routine encryption management through standard TEE integrations and common key management approaches. The solution provides fundamental confidential computing features while following accepted enterprise security patterns.

Incident Response Platform Comparison: Market Analysis 2025

Thu, 02 Jan 2025 08:38:07 +0000

The incident response platform market continues to expand as organizations prioritize effective incident management in their Cloud-native environments and beyond.

The market features a range of solutions offering incident management capabilities, with varying approaches to enterprise and team needs.

Market Overview

The incident management market is driven by increasing Cloud complexity, rising downtime costs, and growing DevOps adoption.

Organizations are seeking solutions that can effectively integrate with their existing tools while providing streamlined incident response workflows.

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.

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.

Unleashing the Power of Git Bisect

Tue, 08 Oct 2024 08:15:50 +0000

The Essence of Debugging with Git
Setting the Stage for Debugging
Advanced Usage and Tips
Unraveling a Regression Mystery
Final Word

We don’t usually think of Git as a debugging tool. Surprisingly, Git shines not just as a version control system but also as a potent debugging ally when dealing with the tricky matter of regressions.

Easily containerize Java applications with cloud native buildpacks

Mon, 07 Oct 2024 09:15:53 +0000

The concept of containers has helped to bring Java developers closer than ever to the cloud-native idiom of ‘write once, run anywhere.’

Effectively and efficiently containerizing your Java application can be much more of a challenge than you might originally expect, especially when you might not be a container expert. Having to write and maintain a dockerfile, run a Docker daemon as root, wait for all the builds to complete, and then finally push the image to a remote registry can be complex, time-consuming, and frustrating!

Java Server and Rust Client Built with Generated Networking Code

Fri, 04 Oct 2024 11:58:05 +0000

FEPCOS-J allows declaratively implementing a Java server and generating its profile, which, for example, can be used to generate the networking code of a Rust client.

Introduction

As I have shown in a previous post [1] and a video [2], the FEPCOS-J development tool [3] prototypically implements a Java language extension that allows implementing a client-server application in Java without the need for manual network programming.

In a nutshell, FEPCOS-J allows a Java developer to program a server’s system specification declaratively using annotations. The FEPCOS-J Processor fjp uses this specification to generate the server’s system export module and system import module.

Foojay Podcast #58: How Java Developers Can Secure Their Code

Mon, 30 Sep 2024 07:43:46 +0000

Three years after Log4Shell caused a significant security issue, we still struggle with insecure dependencies and injection problems.

In this podcast, we’ll discuss how developers can secure their code.

I talked with three authors who posted a security and code quality post on Foojay.io.

Video

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

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.

Client-server application in Java: Easy with FEPCOS-J – Video.

Tue, 30 Jul 2024 11:51:04 +0000

This is a result of the FEPCOS-Project , aka @FepcosInfo; #FepcosJ_blog5.

See how FEPCOS-J relieves developers of the network programming required to implement a client-server application in Java.
External link to : G. Fuchs: Video: Easy Implementation of a Client-Server Application in Java with FEPCOS-J; On: YouTube, FEPCOS-Project (@FepcosInfo); 29-July-2024; https://youtu.be/qtPP7kZbriQ .
Impression of the above-linked video: FEPCOS-J provides annotations like @AYSpec, @In, @Out, and @Behavior for programming a client-server application in Java. Watch the video for a complete example application of FEPCOS-J.

beetRoot: Yet Another Web Framework?

Tue, 02 Jul 2024 07:26:01 +0000

News: beetRoot 3.2.0 was released on December 8, 2025.

Over the years, I have struggled with various Java web development frameworks and they all have their weaknesses and strengths.

A few years ago, I evaluated around 10 of these frameworks for a project for a Swedish company. Nothing really impressed me at the time.

It was only later that SpringBoot came along, which seemed to fulfill all the requirements and there was actually very little to criticize about it. Then came microservices such as Quarkus or Micronaut , which are often compiled into native code for small web service applications, but which can then rarely be embedded in a more mature architecture.

Example Java Application with Embedded Jetty and a htmx Website

Fri, 21 Jun 2024 08:59:42 +0000

I was experimenting with a Java application that can act as a web server and includes the user interface HTML-files that get modified with htmx, to replace certain parts of the HTML with other ones created in Java.

I found it pretty hard to understand how to configure the embedded Jetty webserver, but as always with Java libraries, it’s pretty easy once you understand how to do it 😉 I decided to share my example, so you don’t need to go through the same search if you want to use the same approach…

Who instruments the instrumenters?

Thu, 30 May 2024 16:25:45 +0000

Have you ever wondered how libraries like Spring and Mockito modify your code at run-time to implement all their advanced features?

Wouldn’t it be cool to get a peek behind the curtains?

This is the premise of my meta-agent , a Java agent to instrument instrumenters, to get these insights and what this blog post is about.

This article is a collaboration with Mikaël Francoeur , who had the idea for the meta-agent and wrote most of this post. So it’s my first ever post-collaboration. But I start with a short introduction to the agent itself before Mikaël takes over with real-world examples.

Diagnosing user-reported issues using WireQuery

Mon, 13 May 2024 07:11:04 +0000

As a developer, I’ve often struggled with diagnosing user-reported issues, which is often caused by a lack of information to reproduce the problem. While a ticket may contain a screenshot of the problem and a description, it often does not portray the complete picture. For example: what did the user do that led up to the issue? What endpoints were called from the frontend, and how did they respond? What did the underlying systems communicate? Etc.

SQL Query Optimization: How to Identify and Optimize Slow SQL Queries

Thu, 09 May 2024 21:44:39 +0000

In this article, we want to share our experience with fellow developers and offer insights using real-life examples on how to identify and optimize slow SQL queries, especially when working with relational database management systems like PostgreSQL, MySQL, MSSQL, Oracle, etc.

If you are a developer who doesn’t use database ORMs like Hibernate that much, you are no stranger to the concept of SQL query optimization. As developers, we know that a slow SQL query can reduce our application’s efficiency and performance, leaving our users with a bad experience.

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.

Ensuring the right usage of the Java 21 new features

Sun, 14 Apr 2024 16:16:13 +0000

Last September 2023 a new version of Java was released as the latest LTS (Long Time Support). This 21st version brought lots of new features that will improve performance and clarity in our code base.

But taking advantage of these changes and new features, which we are not used to including in our code, can be a tough task. Also, it can lead to improper use or poor uptake, bugs, or basically not taking full advantage of new improvements.

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 .

12 Text Tools For Developers

Tue, 09 Apr 2024 07:31:13 +0000

As developer, you would think we would spend all our time in an IDE doing development. The reality is a bit different. We may need to analyze logs, test our web services, generate test data, do security tests, analyze data in the database, and so on. Text processing os also part of a developer job. Let’s see a few free text tools to simplify your job.

Using online tools makes me wonder if I’m leaking company data to the website, so I wrote a desktop freeware Japplis Toolbox containing a collection of text tools.

How to Detect Cache Misses Using Observability

Thu, 04 Apr 2024 07:44:31 +0000

All of us know about caching in system design and software architecture, It is applicable everywhere in the computer industry, even in hardware. Caching is a quick and shortcut solution to improve performance, of course, we need to be careful of using the cache, misusing the cache can directly affect the system’s consistency.

In this article, we will learn about cache miss and, in general, about the caching concept and how to implement it in Spring Boot. Eventually, we will see how Digma can help us detect cache misses locally during development.

Tips for reading code

Tue, 26 Mar 2024 11:46:58 +0000

As developers, we read code more than we write it. When adding new features or fixing bugs, we first need to understand existing code, so we can make the right changes in the right place.

When reading code inside the IDE, IntelliJ IDEA helps us to read and understand code by providing helpful features like syntax highlighting and inlay hints. But there are more features to help us understand a piece of code.

Multithreaded server in Java: That's easy with FEPCOS-J.

Thu, 21 Mar 2024 08:38:28 +0000

FEPCOS-J prototypically implements a Java language extension that allows the realization of a multithreaded TCP/IP server in Java without thread or network programming.

Please help me to make FEPCOS-J a Free/Libre and Open-Source Software (FLOSS).

Introduction

FEPCOS-J [1] is a Java development tool that prototypes a Java language extension for declarative programming of networked systems. See my previous posts for details [2, 3, 4] .

Firstly, this post briefly defines the term “multithreaded TCP/IP server” . It then describes how FEPCOS-J supports programming a multithreaded TCP/IP server in Java . Further, the post explains what implementing the server with FEPCOS-J looks like and provides an example . Finally, the post draws a conclusion .

You’re Invited to IntelliJ IDEA Conf 2024!

Tue, 27 Feb 2024 08:13:58 +0000

We are back and excited to invite you to IntelliJ IDEA Conf 2024 , a developer-focused, live, online event that is free for all to attend!

IntelliJ IDEA Conf celebrates the developer community and its desire to learn and improve every day.

Join us for this free, live online conference and learn from industry leaders and experts on March 6–7, 2024.

You’ll be able to learn about a variety of topics, like Core Java, Kotlin, Java and AI, Apache Maven 4, Spring Boot, Micronaut, Testcontainers, Secure Coding, and testing frameworks like JUnit, Mockito, and AssertJ.

Java top most detected issues

Wed, 14 Feb 2024 09:49:16 +0000

Using the telemetry from SonarLint after analyzing thousands of projects, these are the top most raised issues in Java projects.

We know that having clean code in our projects is important, and every developer would agree on that. But, according to what SonarLint telemetry shows, there are still lots of issues that appear in the huge list of analyzed projects.

From the SonarLint telemetry for the last 2 years, with more than 2.5 million issues, I have taken the top most common issues happening in Java projects, from the +600 rules covering the language, considering quality and security to see how we can avoid them and align our code a bit more towards having a consistent, intentional, adaptable, and responsible code.

Java Flight Recording and Analysis with Azul Mission Control

Thu, 25 Jan 2024 07:59:42 +0000

Java Flight Recording (JFR) is a Java Virtual Machine (JVM) profiling and diagnostics tool. It enables you to collect and analyze data regarding the performance and behavior of a Java application. As JFR is included in the JVM, there is no need for additional tools or installations to make recordings of your applications.

By utilizing JFR, you gain valuable insights into the runtime behavior of your Java applications. It helps you to optimize performance, identify and troubleshoot issues, and ensure better overall reliability. JFR is designed with very low overhead, allowing its use in production environments with minimal impact on the performance of your application.

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.

Using AI to Create JFR Event Descriptions

Fri, 29 Dec 2023 05:42:16 +0000

JFR (JDK Flight Recorder) is the default profiler for OpenJDK (see my other blog posts for more information).

What makes JFR stand out from the other profilers is the ability to log many, many different events that contain lots of information, like information on class loading, JIT compilation, and garbage collection.

You can see a list of all available events on my JFR Event Collection website:

This website gives an overview of the events, with descriptions from the OpenJDK, their properties, examples, configurations, and the JDK versions in which every event is present. However, few descriptions are available, and the available texts are mostly single sentences.

Profiling Maven Projects with my IntelliJ Profiler Plugin

Thu, 14 Dec 2023 10:41:34 +0000

Or: I just released version 0.0.11 with a cool new feature that I can’t wait to tell you about…

According to the recent JetBrains survey , most people use Maven as their build system and build Spring Boot applications with Java. Yet my profiling plugin for IntelliJ only supports profiling pure Java run configurations. Configurations where the JVM gets passed the main class to run. This is great for tiny examples where you directly right-click on the main method and profile the whole application using the context menu:

FEPCOS-J: Native executables of Java-coded networked systems

Wed, 13 Dec 2023 12:13:07 +0000

FEPCOS-J prototypically enables Java developers to realize networked systems without low-level network programming and to automatically build native executables by means of GraalVM. This post introduces the concept and gives you an example by rebuilding the source code explained in my previous posts.

Please help me to make FEPCOS-J a Free/Libre and Open-Source Software (FLOSS).

Introduction

FEPCOS-J [1] enables a Java developer to declaratively program networked systems and compose them like building blocks [2] . For this purpose, FEPCOS-J provides Java modules and generates code to free a Java developer from network programming [3] .

Couch to fully-observed code with Spring Boot 3.2, Micrometer Tracing, and Digma

Wed, 06 Dec 2023 10:42:46 +0000

Collecting important data about your code in dev and test has become trivial, it’s now also getting easier to put that data to use.

{#more-103351}

Tracing > Debugging

There are many benefits to being able to follow what your Spring Boot code is doing using tracing. When used effectively, traces can reveal a lot about the inner workings of complex systems, or provide early feedback when you make mistakes in introducing new code changes.

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.

Webinar: Harnessing the Power of AI Assistant in IntelliJ IDEA

Tue, 28 Nov 2023 16:38:47 +0000

AI Assistant provides AI-powered features for software development based on the JetBrains AI service. The service transparently connects you, the IDE user, to different large language models.

In this session, Anton Arhipov will demonstrate the capabilities of AI Assistant in IntelliJ IDEA. You will learn how the tool helps you explore and improve existing code as well as write new code in different scenarios.

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.

Beyond Pass/Fail- a Modern Approach to Java Integration Testing

Wed, 18 Oct 2023 15:15:14 +0000

Tests can run limited sets of assertions on your code, or reveal important insights about how your application really works!

Automated testing will assuredly go down in the annals of software development history as one of these industry-changing trends. Although few actually adhere to full-metal, OCD mode, TDD discipline (I am in awe of those that do, just to be clear), most developers make sure to prioritize and include testing in their dev cycle.

FEPCOS-J (2) – Declaratively compose networked systems in Java

Fri, 13 Oct 2023 06:07:00 +0000

FEPCOS-J implements a model-based Java language extension that provides the annotation @Part, which enables a developer to declaratively compose networked systems. This post introduces the concept and gives you an example of how to use it.

Please help me to make FEPCOS-J a Free/Libre and Open-Source Software (FLOSS).

Introduction

FEPCOS-J arises in the frame of the FEPCOS-Project [1] , which aims to simplify the programming of composed networked systems.

FEPCOS-J implements a domain-specific Java language extension whose semantic domain is based on the FEPCOS-Model [2] , which extends the composite design pattern [3] to include networking aspects.

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.

5 Ways to Identify and Manage Flaky Tests

Tue, 12 Sep 2023 03:57:12 +0000

Dealing with flaky tests is a significant challenge in software development. These unpredictable and inconsistent tests can pass or fail without any changes in code, casting doubt on the reliability of your toolchain and ultimately on the application itself. The presence of flaky tests can significantly impact developer confidence and productivity. To better understand why you need to address these flaky tests, read Seven Reasons You Should Not Ignore Flaky Tests .

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.

Ops friendly Apache APISIX

Wed, 06 Sep 2023 06:27:42 +0000

Though I always worked on the Dev side of IT, I was also interested in the Ops side. I even had a short experience being a WebSphere admin: I used it several times, helping Ops deal with the Admin console while being a developer.

Providing a single package that Ops can configure and deploy in different environments is very important. As a JVM developer, I’ve been happy using Spring Boot and its wealth of configuration options: command-line parameters, JVM parameters, files, profiles, environment variables, etc.

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.

Building High-Performance Java Microservices with EDA

Wed, 16 Aug 2023 21:34:18 +0000

Event-Driven Architecture (EDA) is a design principle focused on the creation, detection, and reaction to events.

Renowned for its resilience and low latency, EDA is a reliable choice for developing robust, high-performing microservices.

Moreover, this method can be helpful in improving productivity and making the process of cloud migration smoother.

In this article we will outline 6 key considerations and tactics for developing such services.

1) Crafting Event-Based Microservices

Within EDA, microservices interact with each other through events. An event is simply an immutable indication that something has happened. Microservices register their interest in a subset of events and perform their processing by reacting to these events when they occur. On completion of handling of an event, microservices will usually post one or more events reflecting the result of this processing, which will trigger further downstream microservices.

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.

Java on Visual Studio Code – July 2023

Mon, 31 Jul 2023 07:11:13 +0000

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

In this article, we are going to provide you an exciting update about our improved decompiler functionality.

Additionally, we are going to do a deep-dive into our code completion.

Let’s get started!

Decompiler Support Upgrade

Java decompiler is essential for understanding third-party libraries, debugging, and learning from well-written code. It helps the developer to reverse engineer compiled Java bytecode back into human-readable Java source code, enhancing the productivity and code comprehension.

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.

Building for Failure: Best Practices for Easy Production Debugging

Fri, 21 Jul 2023 15:29:09 +0000

Before going into the content of this post, check out my new book which launched last week!

Quite a few years ago I was maintaining a database-driven system and ran into a weird production bug.

The column I was reading from had a null value, but this wasn’t allowed in the code and there was no place where that value could have been null.

The database was corrupt in a bad way and we didn’t have anything to go on.

Build Rot: The Hidden Technical Debt in Maven and Gradle Builds

Fri, 21 Jul 2023 08:14:01 +0000

Discover ‘Build Rot’, the hidden technical debt in Maven and Gradle builds. This article explores the impact of Build Rot on build speed and test times, offering strategies for enhanced observability and Developer Productivity Engineering to optimize build processes.

Technical debt is a constant companion in the complex world of software development. It’s the price we pay for quick fixes and postponed refactoring—the “we’ll do it right next time” mentality.

How to Create an Open Source Pull Request (PR)

Wed, 19 Jul 2023 11:26:23 +0000

In this tutorial, we are going to take a look at contributing to Open Source Software, specifically how to do a pull request (PR).

We will look at forking and cloning the project, making the changes, committing and pushing these changes, creating the pull request, the review and hopefully merge of your PR.

The same process may apply when making contributions to a project at work that you don’t own. In this example, the project is on GitHub. Other Git code repositories may use a similar process.

Effective Coding with Java Observability

Tue, 18 Jul 2023 07:02:34 +0000

Things you can do right now to learn new and valuable things that can improve your code.

There are many common mistakes I’ve seen repeated over the years while trying to make observability initiatives successful. However, the most critical and fundamental of these organizational stumbles is the irresistible infatuation with technology and toolings themselves.

It should not come as a surprise. Many ’let’s add observability platform X’ projects start off with plenty of fanfare but also a very hazy sense of direction and extremely muddled criteria for success. The vision of what effective observability can do toactually help developers work better is suspiciously missing from the preaching of many of its commercial vendors and oracles. Ask yourself, how often do you find yourself taking your eyes off the code in the IDE to find out what you can learn from its execution data?

How to Share Your Work With a Video or Podcast

Fri, 14 Jul 2023 09:22:11 +0000

Season 2 of the Foojay Podcast has come to an end. Since September of ‘22, 22 episodes where published here on Foojay.

In this article, we want to share some of the experiences of creating such podcasts, but also more generally, how you can share your work in a video with a small (or bigger) budget…

Audio

There is one fundamental rule for the audio: “Garbage in = Garbage out.”

Yes, you can apply many filters and effects in a later phase, but you can’t make a bad recording sound good. You need a clear and good recording as a starting point!

Dissection of Joeffice: Open Source Office Suite in Java

Tue, 11 Jul 2023 09:33:30 +0000

10 years ago, I challenged myself to write an office suite in Java in 30 days . This is how the first version of Joeffice was born. This created quite some buzz, including articles on Slashdot , Ars Technica and PC World .

Last month I released a second update. Let’s explore how I did this. By levering Java libraries, I was able to create such a complex piece of software very quickly.

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.

Upgrade to Jakarta EE 10 and GlassFish 7: Easier Than You Think!

Tue, 27 Jun 2023 07:29:48 +0000

Upgrading to Jakarta EE 10 from an older version of Jakarta EE or Java EE can be a bit tricky and may require some extra attention to detail. But don’t worry, we’ve got you covered!

In this series of articles, we’ll explain everything you need to know before upgrading to Jakarta EE 10 and guide you to complete the upgrade successfully and in almost no time.

Types of challenges

The challenges with upgrading to Jakarta EE 10 or to Eclipse GlassFish 7 fall into these 3 main categories:

Foojay Podcast #26: The Future of Source Control and CI/CD

Mon, 26 Jun 2023 08:35:21 +0000

As developers, we like to automate the boring parts of our job. This automation includes the source control system, build pipelines, and code analysis tools.

In recent decades, we have seen evolutions from CVS to Subversion to Git. Is this the endpoint? Did we find the holy grail in version control? Or what evolutions are waiting for us?

Let’s find out together with these fantastic guests…

This is the final episode of season 2 of the Foojay Podcast. See you in September for the start of our new season with more JUGs, the launch of Java 21, and much more!

Building Custom Solutions vs. Buy-and-Build Software

Wed, 21 Jun 2023 14:41:33 +0000

The Challenges of Building a FIX Engine

The first day I was introduced to Financial Information eXchange (FIX) was when I worked at an investment bank in London as a developer.

I was told to write a feed handler to retrieve market data.

Bear in mind that at this time, I knew nothing about FIX, apart from Googling it for about 10 mins on the internet.

With a touch of overconfidence and slight arrogance, I set to work coding a direct socket connection to the remote FIX endpoint, “how hard could it be?”

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

Java String Templates Today

Fri, 02 Jun 2023 16:28:25 +0000

In our last article , we introduced you to the Manifold project and how it offers a revolutionary set of language extensions for Java, including the ability to parse and process JSON files seamlessly in Java.

Today, we will take a look at another exciting feature of the Manifold project: string templates.

But before we get to that, some of the feedback I got from the previous post was that I was unclear about Manifold. Manifold is a combination of an IDE plugin and plugins to Maven or Gradle.

Revolutionize JSON Parsing in Java with Manifold

Fri, 26 May 2023 17:39:19 +0000

Java developers have often envied JavaScript for its ease of parsing JSON.

Although Java offers more robustness, it tends to involve more work and boilerplate code.

Thanks to the Manifold project, Java now has the potential to outshine JavaScript in parsing and processing JSON files.

Manifold is a revolutionary set of language extensions for Java that completely changes the way we handle JSON (and much more…).

Getting Started with Manifold

The code for this tutorial can be found on my GitHub page . Manifold is relatively young but already vast in its capabilities. You can learn more about the project on their website and Slack channel.

Announcing the Digma Beta: First Runtime Linter for Java Code

Mon, 22 May 2023 13:52:34 +0000

Call for Developers

We are looking for senior Java developers who are interested in exploring how to use observability to improve their code to join the beta program for Digma: a free runtime linter plugin for Jetbrains/Java.
Digma analyzes your code in runtime, improving coding practices and confidence when working on complex Java code.

The plugin runs locally and doesn’t require sharing data.

We have 20 slots currently open for the beta.

Write Once, Run Embedded in any IDE

Tue, 16 May 2023 13:34:19 +0000

Having written many Java GUI applications, I thought it would be cool to run them embedded in IntelliJ IDEA, Eclipse and NetBeans. I didn’t want to write three plugins per application so I came up with this solution.

The embedded panel criteria

To convert my Java Swing applications to run embedded in an IDE, I had to put the user interface in a panel with minimal implementation changes. I came up with these should ideally criteria:

FEPCOS-J (1) – Description, Impression of Usage, Current State

Wed, 26 Apr 2023 06:09:41 +0000

Abstract: FEPCOS-J has arisen in the context of my work in the field of robot sensor networks. It implements a Java-language extension that frees a Java developer from network programming and supports cross-system concurrency. This article gives you an impression of using FEPCOS-J based on a simple example.

So far, FEPCOS-J is a prototype with 1629 lines of Java-code. I develop and test it on my own within a toy robot-based amd64 / x64 Linux OpenJDK 17 environment, which communicates via a private and secured IPv4-network.

Fearless Distroless

Fri, 21 Apr 2023 08:59:50 +0000

With the rise of Docker came a new focus for engineers: optimizing the build to reach the smallest image size possible.

A couple of options are available.

Multi-stage builds. A Dockerfile can consist of multiple steps, each having a different Docker base image. Each step can copy files from any of the previous build steps. Only the last one will receive a tag; the others will be left untagged.This approach separates one or more build steps and a run step. On the JVM, it means that the first step includes compiling and packaging, based on a JDK, and the second step comprises running, based on a JRE.
Choosing the smallest base image size. The smaller the base image, the smaller the resulting image.

In this post, I’m going to focus on the second point.

A Java Library’s New Approach To Observability

Tue, 18 Apr 2023 08:10:01 +0000

How a Java library is taking a completely new approach to understanding what the code does, and why it makes perfect developer sense.

A while back, I wrote about the fact that logs need an overhaul, and that practices that were relevant when logs were still text messages in files may no longer be relevant in an age when logs traces and metrics are as artifacts and observations stored in cloud platforms.

Foojay Podcast #19: Working Free For Fun Brings Fame & Fortune

Mon, 17 Apr 2023 12:35:51 +0000

Many developers spend a lot of their time on side projects. It’s an opportunity to learn new techniques and get involved in communities.

But sometimes it can also lead to a new job.

Or even starting a business based on such a project.

Today we are talking to people who achieved such a transition and became famous and rich, or at least some of each…

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

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:

Using Bots to Keep Dependencies Updated

Mon, 27 Mar 2023 15:18:33 +0000

Any real world Java project will likely use external dependencies.

As we’ve seen over the last few years, it’s important to keep these dependencies up to date. We used to have to manually check for updates, but fortunately these days there are tools available that can help us with this. Because, let’s be honest, most developers don’t enjoy maintaining applications.

We’d much rather be using cool new tools and/or language features, and solving interesting problems. Sorry, I mean: delivering business value! But we are responsible for keeping our dependencies up to date, so let’s make that as easy as possible.

Predicting Secure Java Projects on Maven Central

Thu, 23 Mar 2023 14:10:02 +0000

If you’ve searched for Maven Central components in the last six months, you may have noticed some pretty big changes to the website, including a UI facelift and some new component analysis tools like BOM Doctor and the Sonatype Safety Rating.

It’s no coincidence that many of these changes are security related. Maven Central, along with public code repositories, are the first line of defense when it comes to supply chain security.

Getting Started with IntelliJ IDEA

Mon, 13 Mar 2023 08:26:00 +0000

First up, I havecreated a tutorial on the IntelliJ IDEA Guide if you want to view the content with videos. I’ll concentrate on text-based for this article.

When someone new joins your team, it can be quite an overwhelming experience.

There are lots of people to meet, new technologies to learn, different processes to learn and of course, an IDE to learn!

It’s helpful to remember what every new starter wants, they want to make a difference, they want to add value, they want to move the needle.

DevOps for Developers - Introduction and Version Control

Sun, 12 Mar 2023 09:13:33 +0000

I start some of my talks with a joke: back in my day we didn’t have monitoring or observability. We’d go to the server and give it a kick. Hear the HD spin? It’s working!

We didn’t have DevOps. If we were lucky we had some admins and a technician to solve hardware issues. That’s it.

In a small company, we would do all of that ourselves. Today this is no longer practical. The complexity of deployment and scale is so big, it’s hard to imagine a growing company without an engineer dedicated to the operations.

Using Bookmarks in IntelliJ IDEA

Tue, 07 Mar 2023 15:07:04 +0000

In this tutorial, we’re going to take a look at using bookmarks in IntelliJ IDEA .

Bookmarks can come in handy while navigating a codebase, when you see something interesting that you want to come back to later.

You could use Recent Files (⌘E on macOS, or Control+E on Windows/Linux) to find it, but then you have to remember which file it was. This is where bookmarks come in handy.

Let’s take a look!

Making SBOMs, Threats, and Modelling Them a Piece of Cake!

Tue, 07 Mar 2023 09:15:56 +0000

The third in a series of SBOMs, software supply chains, the government and you (you too, no exceptions).

Yes, just like the previous articles, we have cake this time too - this one is a three tiered extravaganza!

So… still with us? Good!

Earlier, Steve Poole showed us his digital mixing bowl, telling us how applications and their dependencies were like ingredients to a fancy cake .

Jamie Coleman then made sure there were no soggy bottoms (one for the Mary Berry fans), by explaining how SCA tools and SBOMs can work together to prevent vulnerabilities .

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.

Is There a Best OS to Develop a Java Application on?

Wed, 22 Feb 2023 11:43:40 +0000

One subject that often evokes a lot of debate is which is the best OS to develop a Java application on. This article gives my view on the issue.

Java runs very well on Windows, macOS and Linux Distributions.

I work for Chronicle Software , and much of our software is open-source Java libraries, so we don’t, or rather we can’t, require our customers to run on a particular operating system. You may be surprised to hear that we don’t mandate which operating system our staff should use either. We let them use the one that causes the least friction, the one that they are most productive with.

Foojay Podcast #14: Debugging Tools and Skills for Fun and Profit

Mon, 20 Feb 2023 08:29:01 +0000

Let’s talk about debugging and observability.

We work with debugging all the time, but how well do we know this common practice?

Observability, monitoring, and debugging at scale for your production…

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Spotify
Apple Podcasts
And most others…

Guests

A lot of rubber ducks
Johannes Bechberger
- JVM and profiler developer
- Worked on the JDWP protocol and profiling
- https://github.com/parttimenerd
- https://twitter.com/parttimen3rd
- https://mastodon.social/@parttimenerd
- AsyncGetStackTrace: A better Stack Trace API for the JVM
- A short primer on Java debugging internals
Marit van Dijk
- Developer Advocate at JetBrains
- https://maritvandijk.com/
- https://twitter.com/MaritvanDijk77
- https://mastodon.social/@maritvandijk
Ties van de Ven
- Software Engineer @ JDriven, Coach @ Jcore
- https://www.tiesvandeven.nl/
- https://twitter.com/ties_ven
- 6 Steps to help you debug your application

Host

Shai Almog
- Author of “Practical Debugging at Scale ”
- https://debugagent.com/
- https://mastodon.social/@debugagent
- https://twitter.com/debugagent

Producer

Frank Delporte
- https://foojay.social/@frankdelporte
- https://twitter.com/frankdelporte

Content

00'00 Intro and music
00'24 About the topic of this podcast
00'58 Introduction of the guests and host
05'14 Debugging with IntelliJ IDEA and discoverability of tools
- YouTube: Debugger playlist
- YouTube: Profiling tools
- YouTube: Profiling live stream
13'27 JDWP protocol
19'43 Exception breakpoints
- Foojay: Exception Breakpoint that Doesn’t Suck and a Real Use Case for Method Breakpoints
20'34 External debugging tools
- https://rubberduckdebugging.com/
26'55 Observability
37'58 What information should you look for while debugging
45'46 Be aware of tunnel vision while debugging
49'33 What to do if you don’t know where to search for the bug
- https://git-scm.com/docs/git-bisect
- Foojay: External Debugging Tools 2: git bisect
57'05 Outro

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.

How to Find & Fix Vulnerabilities with IntelliJ IDEA Ultimate

Mon, 13 Feb 2023 09:09:39 +0000

In this article, we’re going to take a look at the Package Checker plugin , that’s bundled with IntelliJ IDEA Ultimate .

We’ll have a look at how to view known vulnerabilities in your Maven or Gradle projects, how to get more information about the known vulnerabilities in a specific dependency and how to remediate these vulnerabilities inside IntelliJ IDEA Ultimate if a new version with a fix is available.

Firefox Profiler Beyond the Web: IntelliJ plugin for JFR

Thu, 02 Feb 2023 13:13:17 +0000

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

For the impatient: Take a look at my Java JFR Profiler IntelliJ plugin to easily profile your application and view JFR files directly in your IDE.

I got involved in the Firefox Profiler development, spending significant portions of my time at SAP in the last half year on it. It has been an exciting ride. I learned a lot and contributed a few features. So I was essentially developing React code when I wasn’t working on ASGST or other OpenJDK-related tools.

Writing a Profiler from Scratch: The Profiling Loop

Thu, 12 Jan 2023 15:26:34 +0000

This is the second post in the series, building a profiler from scratch using AsyncGetCallTrace. Today, we’re covering wall-clock profiling and how to collect the obtain stack traces. If you’re unfamiliar with AsyncGetCallTrace, please check out my previous article in the series here .

Our goal today is to essentially write the primary loop of a profiler and do the following every n milliseconds (where n is our chosen profiling interval):

A Short Primer on Java Debugging Internals

Mon, 02 Jan 2023 08:14:17 +0000

I wanted to write about a small side project—a few months back, I got carried away with understanding how Java debugging works.

The following is an hors d’oeuvre, a small post in between my series on profiling, on the Java Platform Debugging Architecture .

All Java debuggers use the Java Debug Wire Protocol (JDWP) to communicate with the JVM, usually using the Java Debug Interface (JDI) abstraction Layer. The protocol can be used to remote debug, but the JVM and the debugger are commonly on the same machine.

Why Picnic picked Java

Fri, 30 Dec 2022 08:22:54 +0000

Picking a tech stack for your startup isn’t something to do lightly. It’s a choice that will shape the future in many ways: how will the tech enable your emerging product and business, what talent can you attract, and how future-proof is the tech stack?

When Picnic launched as the first app-only supermarket back in 2015 in The Netherlands, the tech landscape looked markedly different from today.

Java and .Net ruled the Dutch developer landscape for backend systems.

Writing a Profiler from Scratch: Introduction

Wed, 21 Dec 2022 15:26:44 +0000

Async-profiler is undoubtedly one of the most used open-source Java profilers out there.

Its most commonly used feature is sampling a given Java program’s stack traces and visualizing them as a flame graph. I would recommend reading the excellent async-profiler manual by Krzysztof Ślusarski or taking a look at my profiling playlist on YouTube if you’re new to this tool.

After using the async-profiler for a while, you might wonder: How does this tool work? And, of course, if you’re someone like me: Could I write a stripped-down versionto learn how it really works?

Challenges when Developing a GUI for FIX

Wed, 21 Dec 2022 08:06:18 +0000

In this article, we explore the challenges in developing a Graphical User Interface (GUI) for Financial Information Exchange (FIX) data.

FIX is both a protocol and a message format, but to create a FIX GUI we will focus just on the message format.

A FIX message is a standard message format for transmitting financial and investment banking data.

Below is an example of a FIX message, where the “|” character is sent as ‘\1’:

Foojay on Mastodon: An Update

Fri, 16 Dec 2022 06:45:03 +0000

Some weeks ago we checked here with the Java community if there was an interest to have a Java-oriented Mastodon service.

Today, Nicolas Frankel, also explained how he moved from Twitter to Mastodon and has set up a cross-posting solution (automated of course, as a true good and lazy developer).

Unusual Java: StackTrace Extends Throwable

Wed, 23 Nov 2022 12:37:13 +0000

There are things you can do in Java you rarely see, generally because there is no use for it.

However, there are some unusual things in Java that could be surprisingly useful.

Chronicle Software uses a number of different useful patterns in its low-level libraries most developers wouldn’t generally come across.

One of them is a class that extends Throwable but isn’t an Error or an Exception.

StackTrace Extends Throwable

package net.openhft.chronicle.core;
/**
* Throwable created purely for the purposes of reporting a stack trace.
* This is not an Error or an Exception and is not expected to be thrown or caught.
*/
public class StackTrace extends Throwable {
 public StackTrace() { this("stack trace"); }
 public StackTrace(String message) { this(message, null); }
 public StackTrace(String message, Throwable cause) {
 super(message + " on " + Thread.currentThread().getName(), cause);
 }

 public static StackTrace forThread(Thread t) {
 if (t == null) return null;
 StackTrace st = new StackTrace(t.toString());
 StackTraceElement[] stackTrace = t.getStackTrace();
 int start = 0;
 if (stackTrace.length > 2) {
 if (stackTrace[0].isNativeMethod()) {
 start++;
 }
 }
 if (start > 0) {
 StackTraceElement[] ste2 = new StackTraceElement[stackTrace.length - start];
 System.arraycopy(stackTrace, start, ste2, 0, ste2.length);
 stackTrace = ste2;
 }

 st.setStackTrace(stackTrace);
 return st;
 }
}

Some important side notes to get out of the way first

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.

Foojay Podcast #7: Security in Java -- what do we need to know?

Mon, 21 Nov 2022 10:22:14 +0000

For this Foojay Podcast**,** we invited security experts to dive into the fascinating world of secure coding and detecting vulnerabilities in your Java applications.

How can you make and keep your systems safe?

That’s what we want to find out…

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Foojay Mastodon Service: Here It Is!

Wed, 16 Nov 2022 08:44:02 +0000

After thinking about it , and collecting the feedback , there was only one direction forward: get a Foojay Mastodon service up-and-running!

And thanks to toot.io we don’t need to worry about the maintenance and the bill has been covered.

If you were already following me on Mastodon, you may have noticed that I moved my own account to this new instance, so you can find me now on foojay.social/@frankdelporte . Homepage of the Mastodon server on foojay.social

Java Mastodon Service: The Feedback

Tue, 15 Nov 2022 08:40:14 +0000

Yesterday we launched this idea: Let’s Start a Java Mastodon Community for Friends of OpenJDK! .

At the same time, we shared this post on Twitter (yes, the irony), Mastodon , and LinkedIn .

Let’s see what the community thinks…

TL;DR;

Yes, a lot of likes and +1, most of the reactions think this would be a good idea.
No, not everyone is convinced Twitter will disappear and an alternative is needed.
Nobody volunteered (yet) to assist (pay?) for the server and moderate 😉

Feedback

Some of the confirmations

Let's Start a Java Mastodon Community for Friends of OpenJDK!

Mon, 14 Nov 2022 13:41:06 +0000

Twitter has been my absolute “source of truth” for many years.

For me, it’s the ideal medium to pick up new technologies, learn from experts, meet new people, etc.

It even seemed I was able to “train the model” by carefully selecting the people I follow, as it has never been an abusive or hostile environment as it is perceived by many others.

Many years ago I already created an account on Mastodon, but was not very active on it, as most of the people I follow, weren’t active there either.

Java Profiling Overview

Mon, 14 Nov 2022 09:14:25 +0000

When I ask Java developers whether they do profile, the answer is usually “no”.

The few that profiled before usually used VisualVM as a student and maybe JProfiler or YourKit years ago at work.

One of the reasons for this is a lack of available information and thus knowledge for everyday Java developers.

This is a pity as profiling should be a part of the tool belt for every experienced developer (not just for Java). The problem is that most of the open-source profilers are targeted to the OpenJDK developers (or their colleagues), even if they won’t admit it. This can be seen in the lack of entry-level material on this topic and even the little that is out there is distributed across multiple conference websites, blogs, YouTube channels, and Twitter accounts.

Reducing Tail Latencies with Chronicle Queue Enterprise

Wed, 09 Nov 2022 15:07:36 +0000

Persistent queue solutions are frequently used when designing low-latency applications.

The problem is that high sustained message rates, or bursty workloads, can lead to delays caused by the OS or hardware which are challenging to mitigate.

In this article, we will describe how Chronicle Queue Enterprise solves this.

Background

When benchmarking Java low-latency persistent queue solutions, latencies tend to be excellent up to high percentiles until sustained throughput limits are reached; these sustained throughput limits are determined by disk performance, OS version, and configuration.

Java on Azure Tooling Update – October 2022

Mon, 07 Nov 2022 22:04:16 +0000

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

In this update, we will introduce our new roadmap in the next few months.

In addition, we have made improvements for developers to use deployment slots for Azure Functions in IDEs directly with our latest release.

Please download and install the Azure Toolkit for IntelliJ .

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

Observability is Cultural

Fri, 04 Nov 2022 15:23:00 +0000

I’m guilty of applying the word debugging for practically anything.

My kids’ legos won’t fit, let’s debug that.

Observability is one of the few disciplines that actually warrant that moniker, it is debugging. But traditional debugging doesn’t really fit with observability practices. I usually call it “precognitive debugging”. We need to have a rough idea in advance of what our debugging process will look like for effective observability troubleshooting.

Note that this doesn’t apply to developer observervability which is a special case. That’s a more dynamic process that more closely resembles a typical debugging session. This is about more traditional monitoring and observability. Where we need to first instrument the system and add logs, metrics, etc. to cover the information we would need as we will later investigate the issue.

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:

Handling Exceptions in Java Lambdas

Sat, 22 Oct 2022 11:36:46 +0000

Java introduced the concept of checked exceptions . The idea of forcing developers to manage exceptions was revolutionary compared to the earlier approaches .

Nowadays, Java remains the only widespread language to offer checked exceptions. For example, every exception in Kotlin is unchecked.

Even in Java, new features are at odds with checked exceptions:the signature of Java’s built-in functional interfaces doesn’t use exceptions.It leads to cumbersome code when one integrates legacy code in lambdas.It’s evident in Streams.

Low Latency Crypto Trading Systems with Java and Chronicle

Tue, 18 Oct 2022 14:59:37 +0000

Cryptocurrency trading is an emerging market with its own rules.

However, when it comes to the need for low-latency arbitrage , that is, being able to react rapidly to changing market prices and placing orders ahead of the competition, there are lessons we can learn from optimizing classic trading systems.

Chronicle Software has a successful track record of designing low-latency trading products. This background enables it to provide optimum performance solutions for Crypto trading systems.

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) .

Presenting with IntelliJ IDEA

Tue, 11 Oct 2022 07:14:30 +0000

In this article, we will take a look at ways to level up your presentation skills with IntelliJ IDEA.

Presentation Assistant plugin

Our first tip is to use the Presentation Assistant plugin. The Presentation Assistant plugin will show which shortcuts are being used.

To install the plugin, open Preferences using ⌘, (on Mac) or Ctrl+Alt+S (on Windows/Linux). Go to Plugins and search for “Presentation assistant” on the Marketplace tab. Click Install and when it’s done, click OK to apply the changes and close the dialog or click Apply to keep the dialog open.

Low Latency Microservices, A Retrospective

Thu, 06 Oct 2022 06:25:56 +0000

I wrote an article on low latency microservices almost five years ago now. Chronicle Software has worked with a number of tier one investment banks to implement and support those systems. What has changed in that time and what lessons have we learnt?

Read this article and learn what we learned after five years of developing and supporting low latency microservices.

Separation of Concerns Gives Better Testability

Microservices repeatedly demonstrated that testing and debugging business components were much easier with simple, stand-alone components with clear contracts between microservices.

Using Git Interactive Rebase

Thu, 25 Aug 2022 09:32:22 +0000

This tutorial will cover how to clean up your Git commit history with Git interactive rebase, both via the IntelliJ IDEA UI and from the command line.

Git interactive rebase allows you to change individual commits, squash commits together, drop commits or change the order of the commits. This allows you to clean up your Git commit history to make it linear and meaningful, which can make it easier to understand the history of the project in the future.

Bridge the DevOps/Dev Gap without Sacrificing Reliability

Fri, 19 Aug 2022 09:16:00 +0000

DevOps culture revolutionized our industry. Continuous Delivery and Continuous Integration made six sigma reliability commonplace. 20 years ago we would kick the production servers and listen to the hard drive spin, that was observability. Today’s DevOps teams deploy monitoring tools that provide development teams with deep insight into the production environment.

“O brave new world That has such people in’t!”

— William Shakespeare

Before DevOps practices were commonplace, production used to fail. A lot. We don’t want to go back to the time before DevOps tools were commonplace…

Secure CI/CD Pipelines with GitHub Actions for Your Java Apps

Thu, 11 Aug 2022 06:28:38 +0000

This article was originally post atSnyk.io and is used with permission

GitHub Actions has made it easier than ever to build a secure continuous integration and continuous delivery (CI/CD) pipeline for your GitHub projects.

By integrating your CI/CD pipeline and GitHub repository, GitHub Actions allows you to automate your build, test, and deployment pipeline.

You can create workflows that build and test every pull request to your repository or deploy merged pull requests to production.

Stateless, Secretless Multi-cluster Monitoring in Azure Kubernetes

Wed, 27 Jul 2022 08:36:46 +0000

Introduction

Observability is paramount to every distributed system and it’s becoming increasingly complicated in a cloud native world where we might deploy multiple ephemeral clusters and we want to keep their metrics beyond their lifecycle span.

This article aims at cloud native engineers that face the challenge of observing multiple Azure Kubernetes Clusters (AKS) and need a flexible, stateless solution, leveraging available and cost-effective blob storage for long term retention of metrics, one which does not require injecting static secrets to access the storage (as it leverage the native Azure Managed Identities associated with the cluster).

Debugging Java Collections Framework Issues in Production

Fri, 15 Jul 2022 08:49:59 +0000

The Java Collections Framework was a huge leap forward when it was introduced as part of Java 2 (JDK 1.2).

Thanks to the included collection classes we finally moved beyond the limits of Vector and Hashtable to more mature and generic solutions. With the introduction of streams and functional concepts in Java 8 the framework took everything to the next level.

One of the core principles underlying the framework is coding to the interface. As such you would use the List interface or a Collection interface instead of the concrete implementation. This is great engineering but it makes debugging the Java Collections far more challenging.

JDK 7: An Extended Hello and Farewell

Tue, 12 Jul 2022 11:03:39 +0000

On July 7^th^, 2011, eleven years ago, JDK 7 was released . In some ways, it was one of the more significant releases of Java. Indeed, there were some excellent technical features: Project Coin gave us things like try-with-resources, strings in switch and multi-catch.

However, it was two non-technical aspects of JDK 7 that made it important.

The first was that it was the first release since Oracle acquired Sun Microsystems . The Java community had been unsure how Java would fare under Oracle, so this release showed a solid commitment to the platform (which has been maintained since then).
The second was even more important: the fact that a Java SE specification was published through the Java Community Process . Due to issues around the availability of the TCK and the Apache Harmony project , new versions of OpenJDK had been stalled since December 2006. To put this into context, the time between JDK 6 and JDK 7 (one release) was one month longer at four years and seven months than between JDK 9 and JDK 18 (nine releases). Getting things moving again was vital to keeping Java relevant to developers as applications and architectures evolved.

Another significant date for JDK 7 is July 19^th^ this year. That is when the last update will be made available from Oracle , even for commercially supported users. It is the end of what Oracle terms Extended Support.

Debugging Gson, Moshi and Jackson JSON Frameworks in Production

Fri, 08 Jul 2022 07:14:01 +0000

Parsing bugs are the gift that keeps on giving in the age of APIs.

We use a service, it works perfectly in debugging, QA, etc.

Then some user input that made its way to the web request returns a result we just can’t parse.

Unfortunately, there isn’t much we can do at this stage. We need to understand why the failure occurred and how we can workaround it and fix it.

Building Project Panama's jextract tool by yourself

Thu, 09 Jun 2022 14:22:47 +0000

Absorb what is useful, discard what is useless and add what is specifically your own. – Bruce Lee

Do you want to build Project Panama’s Jextract tool by yourself? I can show you how!

If you’ve seen any of my past articles on Project Panama I’ve mentioned a really convenient tool called jextract that can generate Java binding code that represents native functions or variables (symbols) from C libraries.

This alleviates the developer’s need of creating binding code by hand. By passing in a C header file (.h extension) jextract can generate source code or compiled Java classes.

Publish a Java Project to the Maven Central Repository

Fri, 13 May 2022 06:22:58 +0000

This guide will describe how to publish the JDesk framework to Maven Central.

The project is written in Java using Maven as the build tool. So, the process will be detailed for Java projects with a pom.xml file.

You can follow this article if you need to publish a Java Maven-based library or artifact to Maven.

Get Ready for Publishing Packages

Publishing a Java artifact is not as trivial as Python or JavaScript packages can be deployed.

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.

How To Beautify Your GitHub Repo

Tue, 19 Apr 2022 08:16:37 +0000

Whether you like it or not, GitHub has become the primary provider to host one’s code.

You or your company are probably using GitHub.

In this article, I want to highlight some files that you can use to beautify your GitHub repository and make it welcoming and inspiring to those who stop by.

README

I hope that by now, everybody is familiar with READMEs. If you place a README file at the root of your repo, GitHub will display its content on the repo’s homepage.

Logging Best Practices: MDC, Ingestion, and Scale

Mon, 11 Apr 2022 12:16:37 +0000

I don’t care about religious wars over “which logger is the best”. They all have their issues. Having said that, the worst logger is probably the one built “in-house”. So yes, they suck, but re-inventing the wheel is probably far worse.

Let’s discuss making these loggers suck less with proper usage guidelines that range from the obvious to subtle. Hopefully, you can use this post as the basis of your company’s standard for logging best practices.

Use git bisect to Pinpoint a Bug

Wed, 23 Feb 2022 14:44:51 +0000

During some recent work on Maven, I found a very specific bug. The error message wasn’t that clear, and I couldn’t make a guess what might’ve caused it.

I had read about git bisect a few times and figured that this time, I would use that tool to find the bug.

So what does git bisect do? It helps you find the exact commit that introduced a bug, using binary search.

Hand Ground Coffee: Command Line Tools for Java

Mon, 21 Feb 2022 16:04:15 +0000

In the book “97 Things every Java Programmer should know ” (I contributed 2 of the 97 tips) there is a chapter about some command line tools in the JDK.

Since I make heavy use of such helpers myself, I wanted to briefly introduce them in today’s article.

Personally I prefer the command line for my daily work, using the combination of git, sed, grep, bash commands etc. makes recurring tasks easier.

What is Debugging in 140 Seconds

Mon, 14 Feb 2022 12:50:58 +0000

I’m launching a new twitter video series that will focus on teaching the concepts of debugging (and other concepts) in small video bites.

This is the first video in the series. I hope to publish a new video every week. It starts with the very basics of debugging and builds up. I think debugging is a powerful tool that even experienced developers don’t leverage enough.

See the video here:

🦆 Duckling the 1st:

Detect and Fix Memory Leaks in Managed Languages

Thu, 10 Feb 2022 08:45:27 +0000

In the previous installment , I talked about the Java garbage collector. In this part, I’ll discuss the most common memory issue: the memory leak. I focus on managed languages, specifically Java, but I will mention some native code tools which are interesting. A memory leak contributes to heap size, which isn’t the most pressing bug in most cases. But when left alone, memory usage can become a problem and, by that point, finding the issue is hard. Unlike a crash dump, where we get a reference to a specific line, a memory leak can remain hidden.

Polyglot Cloud Native Debugging: Beyond Logs/APM

Tue, 18 Jan 2022 07:55:51 +0000

I’ve done quite a few conference talks since I became a developer advocate for Lightrun . One of my most popular talks has a title similar to the title of this article. In this article I’ll try to cover the gist of the talk.

Cloud-Native Applications

There’s practically an alphabet soup of terms covering public cloud, hybrid cloud, etc. There’s also a lot of overlap between the various terms. The nice thing about this topic is that it applies, regardless. You will run into problems with microservices, architecture and monolithic applications or serverless.

A Tentative Comparison of Fault Tolerance Libraries on the JVM

Tue, 11 Jan 2022 09:31:19 +0000

If you’re implementing microservices or not, chances are that you’re calling HTTP endpoints. With HTTP calls, a lot of things can go wrong.

Experienced developers plan for this and design beyond just the happy path. In general, fault tolerance encompasses the following features:

Retry
Timeout
Circuit Breaker
Fallback
Rate Limiter to avoid server-side 429 responses
Bulkhead: Rate Limiter limits the number of calls in a determined timeframe, while Bulkhead limits the number of concurrent calls

A couple of libraries implement these features on the JVM. In this post, we will look at Microprofile Fault Tolerance, Failsafe and Resilience4J.

JDKMon 17.0.17 Released

Wed, 08 Dec 2021 09:11:22 +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 only enable you to download them to a place of your choice.

At the moment the following distributions are supported: