Skip to main content

J-Fall: a NLJUG conference

PRECONFERENCE WORKSHOPS

Pre-conference Workshops

Preconference tickets

On Wednesday, November 11th, 2026 at Hotel van der Valk Veenendaal, NLJUG will be hosting expert-level pre-conference workshops as part of J-Fall 2026. 

These 4-hour sessions will offer deep insights into the latest Java technologies and trends, providing a unique opportunity to learn from top industry experts. Details about the location and speakers will be announced soon, so make sure to stay tuned and follow our socials for the latest updates!

Don’t miss out on this fantastic opportunity to enhance your Java knowledge and connect with the community ahead of the main event.

 

 

Asynchronous Programming in Java: From Callbacks, to Completable Futures, to Virtual Threads

Venkat Subramaniam

Languages like Java, C#, and C++ predominantly focused on multithreading whereas some languages including JavaScript kept their eyes on asynchronous programming. As it turns out, with modern computing needs, programming asynchronously takes a center stage.

Thankfully, Java has evolved to provide fairly good options for creating asynchronous applications. Depending on the version of Java your team is using, there are a few different options. This workshop will help you to learn in depth the various options, when to choose each, and the pros and cons of using them.

Crafting your Agentic Harness: Hands-On Harness Engineering for AI Coding Agents

 

Maik Kingma

AI agents promise to write your code, ship your features, and close your tickets before standup. In practice? They hallucinate files that don’t exist, refactor things you never asked them to touch, and confidently break your build while telling you everything looks great.

It’s time for an intervention.

 

In this workshop, we’ll explore the full spectrum of agentic software development. From overly cautious agents that won’t act without hand-holding to reckless ones that rewrite your entire architecture on a whim.


You’ll learn where the levers are and how to pull them without everything catching fire. We start at the foundation: context engineering. What an agent knows determines what it does, and what it forgets (context rot) determines what it destroys. Get this wrong and nothing else matters.

Once the agent sees clearly, you need it to behave. That’s where skills, instructions, and hooks come in. Repeatable workflows, hard boundaries, and audit points that let you intercept before damage is done.

 

Then we go structural. The Agent OS workflow introduces spec-driven development: structured feature specs that turn vague intent into verifiable, shippable work. No more hoping the agent guesses right.

 

By the end, you’ll be crafting custom commands and skills tailored to your codebase, your conventions, your way of working, until the agent does exactly what you tell it. Every time. You’ll leave with working code, battle-tested configurations, and the confidence that when you say “ship it,” it actually ships what you meant.


Taming Non-Determinism: From Probabilistic Testing to Resilience Patterns

 

Iryna Dohndorf & Mike Mannion

How to turn pressure into performance? How can guarantees and reliable tests be achieved for software systems with stochastic components that exhibit non-deterministic behaviour?

LLM integrations and ML-powered services are being adopted on a large scale in production Java stacks, yet the tools that teams rely on, like deterministic unit tests were not designed for stochastic systems. Despite their growing complexity and inscreasing size, AI-enriched software applications must satisfy strict quality requirements that impose short defect fixing and release cycles. Fast-moving, profit-hungry capital won’t wait; regulations and laws are also catching up, and dependencies are intensifying, thereby increasing the pressure on software developers. To reduce the developers teams workload, and pressure to produce high-quality software on time, suitable software engineering tools and concepts are subject to continuous extensive development and improvement. In this workshop, we present architecture concepts, and tooling that make fragibility visible, measurable, and progressively eliminable. Probabilistic Testing with Punit covers the statistical tooling that lets teams measure, enforce, and version-control the resilience properties of non-deterministic systems like LLM-integrations, ML components, and distributed services that traditional binary pass/fail were never designed to handle. We will also be tackling resilience patterns, like write-ahead-logs, fault injections, fallbacks, retries, and bulkheads. In the workshop, we will develop an AI-enriched Java chatbot application and work through the full arc from writing probabilistic test specifications to implementing and verifying the resilience patterns that make those specifications pass. In addition, we will test the app’s security and safety, like fingerprinting and systemic bias, by applying various adversarial probes directly in Java code, e.g., application specific adversarial attacks, like prompt injections and jailbreaks. Participants leave with a concrete vocabulary, a proven pattern catalogue, and running JUnit 5 tests that express and verify resilience.