Developer Tools on foojay.io - Friends Of OpenJDK

BxPlaywright 1.0: Real Browsers, Fluent BoxLang, Built for AI Agents

Wed, 21 Oct 2026 00:00:00 +0000

Ortus Solutions today announces the general availability of bx-playwright 1.0, fluent browser automation and testing for BoxLang, powered by Microsoft Playwright. It ships alongside TestBox 7.2 and ColdBox 8.3, which bring real-browser testing straight into your specs. Drive Chromium, Firefox and WebKit, test full user journeys, render PDFs and images, and give your AI agents a real browser to verify the BoxLang applications they build.

playwright().browse( ( page ) => {
	page.visit( "/login" )
		.fill( "Email", "luis@ortus.com" )
		.fill( "Password", "secret" )
		.click( "Sign in" )
		.assertPathIs( "/dashboard" )
		.assertSee( "Welcome back" )
		.screenshot( "dashboard.png" )
} )

That’s a full login check. It reads like the steps you’d write on a sticky note, and every line runs in a real browser. 🚀

What I Learned Building an AI Code Reviewer with Java and Spring Boot

Wed, 14 Oct 2026 00:00:00 +0000

AI-assisted coding has changed how quickly developers can write software.

But that creates another question:

How do you review all that generated code effectively?

That question led me to build CodeGuard AI, a self-hosted AI code-review application for GitHub Pull Requests using Java and Spring Boot.

At first, the architecture seemed simple:

GitHub Pull Request
 ↓
 LLM
 ↓
 Review

In practice, that wasn’t enough. The interesting engineering work was everything around the model: collecting useful Pull Request context, defining review instructions, structuring the model response, assessing findings, and integrating the result back into the GitHub workflow. This article explains what I learned while building that workflow.

Introduction to Error Prone: How to Catch Bugs at Compile Time

Tue, 13 Oct 2026 00:00:00 +0000

The Java compiler’s job is to check whether code follows the rules of the language. Trying to remove an element from a collection that can never contain it, or using the wrong letter in a date pattern, does not break those rules, so nothing stops the code from compiling. In short, any code that follows the rules compiles, even when it does not do what its author intended.

What is Error Prone?

Error Prone is an open source static analysis tool that Google built to fill this gap. Unlike most static analysis tools, it does not run as a separate step; it plugs into javac as a plugin. Using the information the compiler produces while analyzing the code, it looks for patterns that follow the rules of the language but are most likely wrong, and reports them as compiler warnings or errors.

How to Create Agent Skills: Tools, Testing, and Installation

Fri, 09 Oct 2026 00:00:00 +0000

In short. Start with a task that keeps coming up and turn it into a Skill with superpowers:writing-skills. While creating it, test scenarios with and without the Skill, and validate the structure of SKILL.md. Then use the Skill on several real tasks. If it consistently helps, share it with your team through a Skills repository or a Plugin.

Creating your first Agent Skill is easy. Make a folder, put a SKILL.md file in it, and write a few instructions.

Introducing cbGenesis: The AI-Native ColdBox Starter for BoxLang

Fri, 09 Oct 2026 00:00:00 +0000

Ortus Solutions today announces the general availability of cbGenesis 1.0, a production-ready ColdBox HMVC starter template for BoxLang, and the first one designed from day one to be built with an AI coding agent, not just by one.

For twenty years, ColdBox has been one of the most battle-tested HMVC frameworks in the CFML and BoxLang world. cbGenesis takes that foundation and ships the part every team rebuilds by hand: authentication, permissions, security hardening, an admin panel, tests, and the guidance an AI agent needs to extend all of it correctly.

Introducing Jenesis: You Already Wrote the Build Script

Thu, 08 Oct 2026 00:00:00 +0000

Over the last decade, Java has changed considerably. The language gained modules, records and virtual threads, and the platform moved to a release every six months. The way we build Java applications, however, has barely changed. A pom.xml or a build.gradle.kts still restates what the code already declares, such as the project’s name, its dependencies and its main class. On top of that, every step beyond the defaults adds a block of configuration and typically another plugin, until the build has become a second program that needs to be maintained beside the first. And before a single line of code is compiled, a wrapper first downloads the build tool itself, which in the case of Gradle are 152 MB. This article introduces Jenesis, a build tool that I have written to approach this problem from a different angle.

try.boxlang.io Now Runs Every BoxLang Version, With or Without CFML

Thu, 08 Oct 2026 00:00:00 +0000

The BoxLang playground now lets you choose among released BoxLang versions and switch CFML compatibility on or off without installing a runtime or setting up containers. Choose a version, enter a snippet, and run it in the browser.

Behind the editor is a serverless implementation on AWS Lambda. Each combination of BoxLang version and compatibility mode is built from one repository and deployed as an isolated function. Here’s what changed and how that arrangement works.

Green Build, Wrong Task: A Working Agreement for Java Teams Using AI Coding Agents

Wed, 07 Oct 2026 00:00:00 +0000

You open a pull request. ./gradlew check is green, the diff is 400 lines, the description says “added tests as requested”. You scroll and see a dozen unit tests for one service class. What you asked for, in a two-line Jira comment, was end-to-end coverage of the checkout flow.

Nobody lied. The agent filled a gap in the request with the most likely reading and got to work. This is the first of three failure modes our team went through in a webinar on September 28. I am writing it up because the fixes turned out to be boring and mechanical, and they work with whatever agent your team has already installed.

Run Java in the Browser with TeaVM

Tue, 06 Oct 2026 00:00:00 +0000

There’s something satisfying about editing a line of Java on a web page, clicking Run, and seeing the result appear right there in the browser. I use this approach for the live Java snippets at nablatensor.com/learn and for source code used to bootstrap nablatensor.com/quantlab. In this article, I’ll explain how the pieces fit together and walk you through a React app you can run yourself.

From Java source to a result

TeaVM compiles Java bytecode into JavaScript or WebAssembly for the browser. To let readers edit and compile the examples, I use teavm-javac, which brings a Java compiler into the browser as well. Compilation happens directly in the reader’s browser: the edited source is sent to a Web Worker in the same tab, without sending a compilation request to a server.

Foojay Podcast #102: Why Foojay Walked Away From WordPress for Static Sites

Mon, 05 Oct 2026 00:00:00 +0000

Foojay.io quietly moved off WordPress and onto Hugo, a static site generator. No more CMS login, no database, no admin panel — just Markdown and AsciiDoc files, built and deployed straight from GitHub. In this episode we dig into why that move happened, and into the bigger question behind it: is a traditional CMS still the right way to run a content site in 2026, or has static tooling caught up? Along the way we go through the real security numbers behind WordPress’s plugin ecosystem — more than 10,000 vulnerabilities found in WordPress plugins since 2025 alone — and put very different static site generators head to head: Hugo and Jekyll, the veterans, versus Roq, the Java-and-Quarkus-based newcomer.

Lathe: A Java Language Server That Works Straight From Your Maven Build

Thu, 01 Oct 2026 00:00:00 +0000

I have written Java in many editors and IDEs over the years, and they all seem to struggle with the same thing.

For me, the hard part of a Java IDE or language server was never the code intelligence. It was getting the project structure right. The IDE reads your build files and then tries to guess the module structure from them. And over time, Java’s compiler and runtime configuration has become more and more complex: annotation processors, the module system, and more. So you often end up in a familiar place: the code compiles and runs in the build, but not in the IDE. Even the best ones tend to break the project setup after an upgrade.

My love-hate relationship with Java formatters

Wed, 30 Sep 2026 00:00:00 +0000

Disclaimer: I don’t want to turn this into “Java formatters week”, but I started my own project a while ago, and I think it’s time for it to come out of stealth mode.

I’ve been writing Java for many, many years, and the Sun Code Conventions were my favorite bedside reading. I’ve seen plenty of variations over the years, and even after they became the Oracle Code Conventions, they were still the same few-page guide on how to write a hello-world app with the standard class library. For some reason I never took to the Google conventions: too C-flavored, with tiny indents, too few columns on the screen, and so on.

BoxLang AI 3.4.0: Gateways, Human-in-the-Loop, and a Full Security Stack

Fri, 25 Sep 2026 00:00:00 +0000

BoxLang AI 3.4.0 is a major release centered on a single theme: trust. AI agents operating in real applications need ways to involve people in consequential decisions and manage potentially untrusted inputs. This release introduces gateways, a restructured Human-in-the-Loop subsystem with durable decisions, layered security controls, batched approvals, normalized provider reasoning, and broader AWS Bedrock support.

The sections below follow the original BoxLang AI 3.4.0 release announcement and preserve all its code examples. For the complete change log, see the BoxLang AI 3.4.0 release history.

BoxLang 1.17.0 Released: Module Inception, CLI Checker, Jar Loading and much more!

Thu, 17 Sep 2026 20:20:32 +0000

BoxLang has always been an extensible language. As of 1.17.0, it is a hierarchically extensible one.

Modules can now contain other modules; aka Module Inception . Recursively. To any depth. Each nested module gets its own class loader, chained to its parent’s, and BoxLang’s own ModuleService discovers, registers, activates, and unloads that entire tree itself. No package manager. No build tool. No install ordering. Drop in one artifact and everything it depends on comes with it, already wired up and already isolated. Not only that, you can now package modules into a single jar.

Community Spotlight: BoxLang Express Brings Node-Style HTTP to the JVM

Tue, 08 Sep 2026 11:25:18 +0000

If you’ve spent years in Spring Boot, Micronaut, or Jakarta EE, “web framework” usually means a servlet container, an embedded Tomcat or Netty, a build step, and a fat jar before anything answers a request. What if you could skip all of that and still be on the JVM?

BoxLang Express , a new community module built entirely by developer Robert Zehnder of KISDigital, does exactly that. It’s built directly on com.sun.net.httpserver.HttpServer, a class that’s been sitting in the JDK since Java 6, so there’s no embedded server to configure and nothing extra on the classpath for the HTTP layer itself. boxlang server.bxs is the whole deployment story.

From OpenTelemetry to DuckDB

Tue, 08 Sep 2026 08:29:37 +0000

Observability platforms generally expect you to do your analysis inside them, using their query language and their dashboards. That works for the questions you already know you have. It works less well for the ad-hoc ones: a quick percentile , a pivot by status code , or “which service is actually eating the latency budget?” once the data is in front of you.

This article describes a small pipeline for that kind of question. On one side is DuckDB, the in-process analytical database that reads CSV, JSON and Parquet directly. On the other is the Dash0 CLI, which pulls OpenTelemetry spans, logs, metrics and traces out of Dash0 and prints them as CSV or JSON.

From Spec-Driven Development to Living Specifications in Java Projects

Fri, 04 Sep 2026 05:51:45 +0000

From Spec-Driven Development to Living Specifications in Java Projects

Coding agents have changed the speed at which we can produce software. But producing code faster does not automatically mean producing better software.

As I started using agents more frequently in real-world software development, one question became increasingly important: how do we give an agent enough freedom to be useful without losing engineering intent?

Trying to control every line of code generated by an agent removes much of the value it can provide. At that point, it might simply be faster to write the code ourselves.

No Database Operations Found: What Writing a Spring Boot Analyzer Taught Me About Spring

Thu, 03 Sep 2026 06:26:00 +0000

I spent months building a static analyzer that answers one question about a Spring Boot codebase: if I change this endpoint, what does the change reach?

Every serious bug I found in it had the same shape.

Not a wrong edge in a graph. Not a missing feature. A confident absence — the tool stating, definitively, that an endpoint touched no database, opened no transaction, published no message, when it did all three.

Announcing BX-WORD: Native Microsoft Word Automation for BoxLang

Tue, 01 Sep 2026 11:31:16 +0000

Every enterprise runs on Word documents. Contracts. RFPs. Proposals. Board reports. Offer letters. HR handbooks. Compliance policies. Invoices. Statements of work. Legal memos. Today, we are incredibly proud to announce bx-word 1.0.0, a first-class, fluent, production-ready module for creating, populating, and transforming Microsoft Word documents natively in BoxLang. This is not a wrapper. This is not a converter. This is a real document builder designed for the way enterprise teams actually work.

NetBeans DataWrangler: Query, Convert, and Edit Data Analytics Files

Sun, 30 Aug 2026 10:25:43 +0000

Apache NetBeans DataWrangler brings the file formats of data analytics into Apache NetBeans 31: CSV, Apache Parquet, JSON and Excel, the formats exchanged with pandas, Spark, R, dbt, Power BI and Excel itself.

You can query, convert, inspect, edit and analyze them without leaving the IDE. They open as documents with their own views and you can query them with SQL, join, aggregate and pivot them, convert them between formats, load them into tables and export the results. The SQL editor is enhanced with code completion, documentation, error checking and quick fixes for analytical SQL.

Running DuckDB's JDBC Driver in a GraalVM Native Image

Sat, 29 Aug 2026 16:22:10 +0000

DuckDB is an in-process analytical database. You add one JAR to a Java project and get a SQL engine that reads CSV, Parquet, and JSON files directly, with no server to run.

GraalVM Native Image compiles a Java program ahead of time into a standalone executable that starts in milliseconds and needs no JVM on the target machine.

Combining the two produces a data tool that is distributed as a single binary, like a Go or Rust program, while using Java libraries.

BoxLang 1.16.0 Released!

Tue, 25 Aug 2026 13:57:47 +0000

BoxLang 1.16.0 is here, closing 50 issues across new features, improvements, and bug fixes. The theme running through this release is control: control over how HTTP clients are created and reused, control over what happens when a request fails, control over how much data a response is allowed to buffer, control over when Java classpaths reload, and tighter alignment with CFML behavior in the edge cases when doing migrations.

Offline Crypto Address Validation in Java

Sat, 22 Aug 2026 08:43:04 +0000

Backend validation often starts with simple questions.

Is the input empty? Does it have the expected shape? Can it be parsed? Does it belong to the selected domain?

Crypto wallet addresses are no different, except the formats vary across chains and simple regular expressions are rarely enough.

If a Java backend accepts crypto withdrawal addresses, address-book entries, CSV imports, support-tool input, or transaction preflight requests, it should reject clearly invalid addresses before calling RPC nodes, explorers, exchange APIs, or internal money-movement systems.

Introducing BoxLang AI Explorer: A Local Catalog for Every AI Pattern

Tue, 18 Aug 2026 14:15:48 +0000

Learning a new AI API usually means jumping between scattered documentation pages, guessing at imports, and copy-pasting code that may or may not still work. We wanted something better for BoxLang AI, so we built the BoxLang AI Explorer : a local, browser-based catalog of runnable BoxLang AI examples, organized by category and difficulty, each with guidance, source code, and sample output. You can also try it online at https://ai.boxlang.io/explorer/

Build Secure AI Chat Applications with BoxLang, RAG, Ollama, and Amazon Bedrock with Dan Card

Thu, 13 Aug 2026 14:52:13 +0000

Build Secure AI Chat Applications with BoxLang, RAG, Ollama, and Amazon Bedrock

AI demos are everywhere. Building an AI-powered feature that can securely work with your documents, databases, and real application data is a very different challenge.

How do you give an AI model access to the right information without exposing sensitive data? Should you use a locally hosted model or a cloud service? How do you move beyond a basic chatbot and build something genuinely useful for your users or organization?

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!