An airhacks.fm conversation with Daniel Terhorst-North (@tastapod.com) about:

first computer experience with the ZX81 and its 1K memory,

the 1K chess game on ZX81,

the ZX Spectrum with 16K and later 48K memory,

the Amstrad 128K,

typing in game listings from computer magazines,

Dan's brother John hacking ZX spectrum games using a hardware freeze device and memory peeking/poking,

cracking game encryption and copy protection on 8-bit tape cassette games,

the arms race between game publishers and hackers,

cracking the Star Wars game security before its release,

ZX Spectrum fan sites and retro gaming communities,

classic games including 3D Monster Maze and Manic Miner and Jet Set Willy,

sprite graphics innovation on the Z80 chip,

first internship at Domark publishing Empire Strikes Back on ZX Spectrum and Commodore 64,

second internship at IBM Hursley Park working on CICS in PL/1 and Rexx,

the contrast between casual game studio culture and IBM corporate culture in the 1980s,

IBM's role as a founding partner of

_Enterprise_Edition" rel="noopener noreferrer">J2EE Enterprise Java,

JMS wrapping MQ Series,

the reliability of MQ Series compared to later messaging technologies,

finding and reporting a concurrency bug in MQ Series with JUnit tests and IBM's rapid response with an emergency patch,

IBM alphaWorks portal and experimental technologies,

IBM Aglets mobile Java agent framework compared to modern A2A agent protocols,

Jini and JavaSpaces from Sun Microsystems with leasing and self-healing,

JXTA peer-to-peer technology,

IBM Jikes Compiler performance compared to javac,

IBM's own JVM,

JVM running on Palm Pilot around 1999,

VisualAge for Java as a port of VisualAge for SmallTalk with its image-based architecture and no file system exposure,

Java's coupling of class and package names to files and directories as a design weakness,

the difficulty of refactoring without IDE support,

Eclipse as the first IDE with proper refactoring,

NetBeans IDE performance compared to Visual Studio Code,

third internship writing X-ray machine control software in Turbo Pascal doing digital image processing,

the pace of technological innovation slowing from kaikaku (abrupt change) to kaizen (continuous improvement),

Douglas Adams quote about technology perception by age,

DEC Alpha 64-bit Unix performance,

commodity Linux hardware replacing exotic RISC machines,

Apple M series chips rediscovering RISC Architecture and system-on-chip design,

innovation fatigue and signal-to-noise ratio in modern tech,

LLMs and the trillion-dollar bet on the wrong technology,

electric cars as an example of ongoing innovation,

Tailwind CSS shutting down due to AI-generated code replacing paid expertise,

Stack Overflow in trouble due to AI summarization,

open source innovation continuing with tools like Astral's uv replacing the python toolchain,

cross-community collaboration between rust and Python and Ruby ecosystems,

first graduate job at Crossfield (Fuji/DuPont joint venture) doing electronic pre-press and color transformation through 4D CMYK color cubes,

writing a TIFF decoder from scratch in C,

Raster Image Processor technology and its connection to Adobe,

transition from C++ to Java feeling quirky,

joining ThoughtWorks in 2002 for enterprise Java work

Daniel Terhorst-North on twitter: @tastapod.com

An airhacks.fm conversation with Thorsten Hoeger (@hoegertn) about:

first computer experience with an IBM 8086 and learning programming by modifying the QBasic Gorilla game,

early programming journey from QBasic to Visual Basic and the discovery of event-driven programming,

building a password security script for autoexec.bat as a childhood project,

transition from Visual Basic to Java around 2005 starting with Java 1.4.2,

working at a small bank in Stuttgart building a core banking system,

experience with Eclipse RCP rich client platform and the overhead of plugin architecture in business software,

migration from Swing to Eclipse RCP frontend with JBoss application server backend,

building a custom Spring-based microservice framework called Dwallin (Icelandic for dwarf) before Spring Boot existed,

using Apache CXF for REST and RPC over messaging with ActiveMQ,

comparison of Java development trajectories between annotation-based and XML-heavy approaches,

discussion of the infamous Java and XML O'Reilly book that popularized XML configuration,

xdoclet as a precursor to Java annotations,

contrasting approaches of JBoss-based thin WAR deployments versus Spring-based embedded server microservices,

university experience learning Ada programming language and its strict compiler as excellent for learning programming,

PL/SQL's Ada-based origins,

brief experience with OSGi and strong criticism of its complexity and poor developer experience,

comparison of OSGi with Java Platform Module System (JPMS),

founding Taimos consulting company 10 years ago originally building BlackBerry enterprise software,

pivoting to AWS migration consulting for regulated industries including banks and insurance companies,

strong preference for serverless architecture with lambda Step Functions API Gateway and DynamoDB,

criticism of running kubernetes on AWS versus using native services like ECS Fargate,

the distinction between running "in the cloud" versus "on the cloud",

detailed discussion of why GraalVM native images are unnecessary on AWS Lambda due to compliance overhead and memory allocation model,

quarkus and SnapStart as solutions for Lambda cold start problems,

Java's cost efficiency on Lambda due to fast execution times,

involvement with AWS CDK since 2018-2019 including building L2 constructs for EC2 and AppSync,

shift from code contributions to community organizing and prioritization work with the CDK team,

launching CDK Terrain as successor to CDK for Terraform,

nuanced discussion of open source economics when the project primarily benefits a paid cloud provider,

using GitHub as a personal index and dashboard for reusable project templates,

consulting perspective on contributing to open source for code reuse across multiple clients,

teaser for a future deep-dive episode on CDK internals and promoting Java usage with CDK

Thorsten Hoeger on twitter: @hoegertn

An airhacks.fm conversation with Kabir Khan (@kabirkhan) about:

Discussion about the A2A (Agent-to-Agent) protocol initiated by Google and donated to the Linux Foundation,

the A2A Java SDK reference implementation using quarkus,

the Java SDK development accepted by Google,

comparison of python and Java expressiveness and coding practices,

the concept of an agent as a stateful process versus a tool as a stateless function call,

the agent card as a JSON document advertising capabilities including supported protocols and descriptions and input/output modes and examples,

the three wire protocols supported: JSON RPC and HTTP+JSON (REST) and grpc,

the proto file becoming the single source of truth for the upcoming 1.0 spec,

the facade/adapter pattern for the unified client across protocols,

the agent executor interface with request context and event queue parameters,

the distinction between simple message interactions and long-running multi-turn tasks,

tasks as Java Records containing conversation history with messages and artifacts,

message parts including text parts and data parts and file parts,

task lifecycle with task IDs and context IDs for stateful conversations,

the event queue as internal plumbing for propagating task updates,

the separation between spec package (wire protocol entities) and server package (implementation details),

the task store as a CRUD interface with in-memory default and database-backed implementations in extras,

replicated queue manager using microprofile reactive messaging with Kafka for kubernetes environments,

building A2A agents without any LLM involvement for simple use cases like backup systems,

the role of LLMs in creating prompts from task messages and context,

the agentic loop and the challenge of deciding when an agent's work is complete,

the relationship between MCP (Model Context Protocol) for tool access and A2A for agent-to-agent communication,

the possibility of wrapping agent calls as MCP tools,

memory management considerations with short-term and long-term memory and prompt size affecting LLM quality,

the distinction between the bare reference implementation and Quarkus-specific enhancements like annotations and dependency injection,

upcoming 1.0 release with standardized Java records for all API classes and improved JavaDoc,

protocol extensions including the agent payment protocol and GUI snippet extensions using template engines,

authentication support with OAuth2 tokens and API keys and bearer tokens,

the authenticated agent card containing more information than the public agent card,

authorization hooks being discussed for task-level access control,

the API and SPI segregation suggestion for better clarity between spec and implementation

Kabir Khan on twitter: @kabirkhan

An airhacks.fm conversation with Francesco Nigro (@forked_franz) about:

break dancing and basketball including meeting Kobe Bryant in Italy during a dunk competition,

using AI coding assistants like Claude Opus 4.5 and GitHub bots for infrastructure setup and CI/CD pipeline configuration,

limitations of LLMs for novel performance-sensitive algorithmic work where training data is scarce,

branchless IPv4 parsing optimization as a Christmas coding challenge,

CPU branch misprediction costs when parsing variable-length IP address octets,

converting branching logic into mathematical operations using bit tricks for better CPU pipeline utilization,

LLMs excelling at generating enterprise code based on well-documented standards and conventions,

providing minimal but precise documentation and annotations to improve LLM code generation quality,

the Boundary Control Entity BCE architecture pattern and standards-based development,

the core problem of thread handoff between event loops and ForkJoinPool worker threads in frameworks like quarkus Vert.x and Micronaut,

mechanical sympathy implications of cross-core memory access when serialized data is allocated on one core and read by another,

CPU cache coherency costs and last-level cache penalties when event loop and worker pool run on different cores,

the custom virtual thread scheduler project (netty-virtual-thread-scheduler) enabling a single platform thread to handle both networking I/O and virtual thread execution,

approximately 50% CPU savings demonstrated by Micronaut when using unified Netty-based scheduling,

collaboration with Oracle Loom team including Victor Klang and Alan Bateman on minimal scheduler API design,

the scheduler API consisting of just two methods onStart and onContinue plus virtual thread task attachments,

work stealing algorithms and their complexity including heuristics similar to Linux CFS scheduler,

the importance of being declarative about thread affinity rather than automatic magical binding to avoid issues with lazy class loading and background reaper threads,

thread factory based approach for creating virtual threads bound to specific platform threads,

stream-based run queues with graceful shutdown semantics that fall back to ForkJoinPool for progress guarantees,

thread-local Scoped Values as a hybrid between thread locals and scoped values for efficient context propagation,

performance problems with ThreadLocal including lazy ThreadLocalMap allocation overhead on virtual threads and scalability issues with ThreadLocal.remove() and soft reference queues,

the impact on reactive programming where back pressure and stream composition still require higher-level abstractions beyond Basic Java concurrency primitives,

structured concurrency limitations for back pressure scenarios compared to reactive libraries,

deterministic testing possibilities enabled by custom schedulers where execution order can be controlled,

the poller mechanism for handling blocking I/O in virtual threads in a non-blocking way,

observability improvements possible through virtual thread task attachments for monitoring state changes,

cloud cost implications of inefficient thread scheduling and unnecessary CPU wake-up cycles,

the distinction between framework developers and application developers as different user personas with different abstraction needs

Francesco Nigro on twitter: @forked_franz

An airhacks.fm conversation with Kabir Khan (@kabirkhan) about:

first computer was a ZX Spectrum 48K with rubber keys,

playing Bomb Jack as a memorable early game,

growing up in Norway near Oslo with lots of outdoor activities including skiing and swimming in warm fjords,

discovering multimedia kiosks at Tower Records in Piccadilly Circus as career inspiration,

writing a Java applet dissertation visualizing Motorola 68000 CPU instruction processing with animations,

early programming in Basic on the ZX spectrum including a hardcoded cookbook application,

learning Pascal and the revelation of understanding what files actually are,

first job writing an HTTP server in C++ on Windows NT using Winsock,

implementing Real-Time Protocol streaming for multimedia content,

working at a consultancy learning multiple programming languages including Active Server Pages ASP and Microsoft Transaction Server MTS,

going freelance and building a Java-based exhibition industry booking system,

using JBoss with EJB3 for the second version of the exhibition system,

getting JBoss support and being impressed by their expertise,

contributing to JBoss Mail and JBoss AOP as open source contributions,

meeting Sacha Labourey at a JBoss partner event in Norway who advised focusing on AOP,

joining JBoss in September 2004 when the company had only about 50 people,

meeting Marc Fleury and having pizza at his house in Atlanta,

the Red Hat acquisition of JBoss in 2006,

leading the JBoss AOP project and standardizing interceptor chains,

working on the JBoss microcontainer for JBoss 5 which was over-engineered and slow,

joining the team that rethought the server architecture leading to Wildfly,

working on WildFly core server management and domain management,

the recent move of the runtimes division from Red Hat to IBM,

current work on Agent-to-Agent (A2A) protocol,

quarkus being the Java reference implementation for the A2A specification published by Google,

Agent-to-Agent Protocol as a standardized protocol for agent-to-agent communication using JSON-RPC REST and grpc,

agent cards as capability advertisements similar to business cards,

benefits of smaller specialized agents over monolithic AI applications including better traceability smaller context windows and flexibility with different LLMs,

comparison of agent architecture to microservices where smaller agents are preferable unlike traditional services where monoliths can be better,

upcoming episode planned to deep-dive into A2A with Quarkus and opentelemetry for agent traceability

Kabir Khan on twitter: @kabirkhan

An airhacks.fm conversation with Simon Ritter (@speakjava) about:

first computer experiences with TRS-80 and mainframe ALGOL68 programming via punched cards in the 1970s UK,

one-week turnaround times for program execution,

writing battleship games on mainframes,

bbc micro with color graphics and dual floppy drives,

father's influence as a tech enthusiast with a PDP-8 in his chemistry lab,

early fascination with robotics and controlling machines through programming,

writing card games and Mandelbrot set fractal generators in Basic,

transition from BASIC to C programming through sponsored university degree,

working at Rocc Computers on Unix device drivers and kernel debugging,

the teleputer,

memory leak debugging requiring half-inch mag tape transfers and two-week investigation periods,

AT&T Unix source code license access and kernel modifications,

Unix System V Release 4 and Bell Labs heritage,

Motorola 68000 processor's flat memory model versus Intel's near/far pointers,

Novell acquisition of Unix from AT&T in 1993,

Unixware development and time spent in Utah,

SCO's acquisition of Unix IP and subsequent IP trolling,

joining Sun Microsystems in 1996 as Solaris sales engineer,

transition to Java evangelism in 1997,

working under Reggie Hutcherson and Matt Thompson for nearly 10 years,

building Lego Mindstorms blackjack-dealing robot with Java speech recognition and computer vision,

using Sphinx for voice recognition and FreeTTS for speech synthesis,

JMF webcam integration for card recognition,

JavaOne 2004 robot demonstration,

Glassfish application server evangelism and reference implementation benefits,

Sun's technology focus versus business development challenges,

CDE desktop environment nostalgia,

Oracle acquisition of Sun in 2010,

Jonathan Schwartz's acquisition announcement email,

Oracle's successful stewardship of Java through openJDK,

praise for Brian Goetz Mark Reinhold John Rose and Stuart Marks,

six-month release cycle benefits,

Project Amber Loom Panama and Valhalla developments,

OpenSolaris discontinuation leading to docker adoption for server containerization,

Oracle's 2015 pivot to cloud focus,

career-defining conversation in Japan about cloud versus Java evangelism,

layoff during vacation in September 2015,

joining Azul Systems after three-and-a-half-hour interview with Gil Tene,

ten years at Azul working on high-performance JVM Platform Prime garbage collection and CRaC technology,

comparison of Azul culture to Sun Microsystems innovation environment,

commercial Java distribution value propositions and runtime inventory features

Simon Ritter on twitter: @speakjava

An airhacks.fm conversation with Holly Cummins (@holly_cummins) about:

first computer experience with her dad's Kaypro CPM machine and ASCII platform games,

learning Basic programming on an IBM PC clone to build a recipe management system,

studying physics at university with a doctorate in quantum computing,

self-teaching Java to create 3D visualizations of error correction on spheres during PhD research,

joining IBM as a self-taught programmer without formal computer science education,

working on Business Event Infrastructure (BDI) at IBM,

brief unhappy experience porting JMS to .net with Linux and VNC,

moving to IBM's JVM performance team working on garbage collection analysis,

creating Health Center visualization tooling for J9 as an alternative to JDK Mission Control,

innovative low-overhead always-on profiling by leveraging JIT compiler's existing method hotness data,

transitioning to WebSphere Liberty team during its early development,

Liberty's architectural advantage of OSGi-based modular core enabling small fast startup while maintaining application compatibility,

working on Apache Aries enterprise OSGi project and writing a book about it,

discussion of OSGi's strengths in protecting internal APIs versus complexity costs for application developers,

the famous OSGi saying about making the impossible possible and the possible hard,

microservices solving modularity problems through network barriers versus class loader barriers,

five years as IBM consultant helping customers adopt cloud-native technologies,

critique of cloud-native terminology becoming meaningless when everything required the native suffix,

detailed analysis of 12-factor app principles and how most were already standard Java practices,

stateless processes as the main paradigm shift from JavaServer Faces session-based applications,

joining Red Hat's quarkus team three and a half years ago through Erin Schnabel's recommendation,

working on Quarkiverse community aspects and ecosystem development,

leading energy efficiency measurements confirming Quarkus's sustainability advantages,

current role as cross-portfolio sustainability architect for Red Hat middleware,

writing Pact contract testing extension for Quarkiverse to understand extension author experience,

re-architecting Quarkus test framework class loading to enable deeper extension integration,

recent work on Dev Services lazy initialization to prevent eager startup of multiple database instances across test profiles,

fixing LGTM Dev Services port configuration bugs for multi-microservice observability setups,

upcoming JPMS integration work by colleague David Lloyd requiring class loader simplification,

the double win of saving money while also reducing environmental impact,

comparison of sustainability benefits to accessibility benefits for power users,

mystery solved about the blue-haired speaker at European Java User Groups years ago

Holly Cummins on twitter: @holly_cummins

An airhacks.fm conversation with Christofer Dutz (christofer-dutz) about:

first computer was a Commodore C64 from Hannover Messe,

early programming in Basic,

playing Wizards of War game on cassette tape,

growing up in Melbourne Australia until age ten,

visiting Ayers Rock and seeing prehistoric armored fish in puddles,

learning C and C++ at Volkshochschule around 1992,

memory management challenges with DOS gaming like X-Wing vs TIE Fighter and Wing Commander,

starting Java at Technical University of Darmstadt in 1998 with version 1.0.7,

appreciating Java's simplicity compared to C++ and no system crashes from memory errors,

early involvement with Apache Cocoon for XML and XSL transformations,

contributing to eXist-db XML database as committer number two,

working with XML XSL and XSLT for data transformation,

frustrations with YAML compared to XML,

transition from Cocoon to Adobe Flex after Cocoon switched to Spring and Maven,

becoming co-maintainer of Flex Mojos Maven plugins,

Adobe donating Flex to Apache Software Foundation,

attending ApacheCon in Sinsheim and connecting with Apache committers,

committer and PMC member of 12 active Apache projects,

firefighting role fixing Maven builds for stuck projects,

retiring Apache Cocoon project,

strong focus on industrial IoT projects,

Apache IoTDB as best time series database,

Apache StreamPipes for cloud IoT orchestration,

Apache Camel and Apache NiFi involvement,

founding Apache PLC4X in 2017 at codecentric,

Apache PLC4X as JDBC-like interface for industrial equipment communication,

spending 80-90 hours per week on PLC4X for nine years,

challenges with industrial automation industry not understanding open source,

anecdote about steel melting plant operator expecting free enterprise support,

Germany being a difficult market for industrial automation consulting,

founding ToddySoft company end of last year,

building installable products and plugins for industrial solutions,

ethical approach to open source by only selling products from projects he contributes to,

real-time definitions varying from tens of milliseconds in cloud to nanoseconds in industrial systems,

ToddySoft named after PLC4X mascot Toddy the palm civet (toddy cat),

plans for future episode discussing IoTDB StreamPipes PLC4X and NiFi use cases

Christofer Dutz on LinkedIn: christofer-dutz

An airhacks.fm conversation with Thomas Wuerthinger (@thomaswue) about:

clarification of GraalVM release cadence changes and decoupling from openJDK releases,

GraalVM focusing on LTS Java releases only (skipping non-LTS like Java 26),

GraalVM as a multi-vendor polyglot project with community edition and third-party vendors like Red Hat BellSoft and microdoc,

increased focus on python support due to AI popularity,

GraalVM team alignment with Oracle Database organization,

Oracle Multilingual Engine (MLE) for running JavaScript and Python in Oracle Database,

MySQL MLE integration,

native image support for stored procedures in Oracle Database,

shipping lambda functions from client applications to database for temporary execution,

treating Oracle Database as an operating system for running business logic,

serverless workloads directly in Oracle Database,

application snapshotting similar to CRaC but running in user space without kernel privileges,

efficient scale-to-zero capabilities with native images,

Oracle REST Data Services service generalization for serverless execution platform,

database triggers for workflow systems and application wake-up,

durable functions with transactional state storage in Oracle Database,

comparison to AS400 architecture with transaction manager database and operating system in same memory,

memory price increases making GraalVM native image more attractive,

lower memory consumption benefits of native image beyond just startup time,

CPU-based inference support with

_multiple_data" rel="noopener noreferrer">SIMD and Vector API,

TornadoVM for GPU-based inference built on Graal compiler,

WebAssembly compilation target for native images,

edge function deployment with WebAssembly,

Intel memory protection keys for sandboxed native image execution,

native image layers for shared base libraries similar to docker layers,

profile-guided optimizations for size reduction,

upx binary compression for 3x size reduction,

memory savings from eliminated class metadata and profiling data not garbage collector differences,

32-bit object headers in serial GC smaller than HotSpot,

polyglot integration allowing Python and JavaScript embedding in Java applications,

Micronaut framework compile-time annotation processing,

quarkus framework best alignment with native image for smallest binaries,

GraalVM roadmap focused on database synergies and serverless innovation

Thomas Wuerthinger on twitter: @thomaswue

An airhacks.fm conversation with Alvaro Hernandez (@ahachete) about:

discussion about LLMs generating Java code with BCE patterns and architectural rules,

Java being 20-30% better for LLM code generation than python and typescript,

embedding business knowledge in Java source code for LLM context,

stackgres as a curated opinionated stack for running Postgres on kubernetes,

Postgres requiring external tools for connection pooling and high availability and backup and monitoring,

StackGres as a Helm package and Kubernetes operator,

comparison with oxide hardware for on-premise cloud environments,

experimenting with Incus for system containers and VMS,

limitations of Ansible for infrastructure automation and code reuse,

Kubernetes as an API-driven architecture abstracting compute and storage,

Custom Resource Definitions (CRDs) for declarative Postgres cluster management,

StackGres supporting sharding with automated multi-cluster deployment,

13 lines of YAML to create 60-node sharded clusters,

three interfaces for StackGres including CRDs and web console and REST API,

operator written in Java with quarkus unlike typical Go-based operators,

Google study showing Java faster than Go,

GraalVM native compilation for 80MB container images versus 400-500MB JVM images,

fabric8 Kubernetes client for API communication,

reconciliation cycle running every 10 seconds to maintain desired state,

pod local controller as Quarkus sidecar for local Postgres operations,

dynamic extension installation without rebuilding container images,

grpc bi-directional communication between control plane and control nodes,

inverse connection pattern where nodes initiate connections to control plane,

comparison with Jini and JavaSpaces leasing concepts from Sun Microsystems,

quarter million lines of Java code in the operator mostly POJOs predating records,

PostgreSQL configuration validation with 300+ parameters,

automated tuning applied by default in StackGres,

potential for LLM-driven optimization with clone clusters for testing,

Framework Computer laptop automation with Ubuntu auto-install and Ansible and Nix,

five to ten minute full system reinstall including BIOS updates

Alvaro Hernandez on twitter: @ahachete