airhacks.fm podcast with adam bien

An airhacks.fm conversation with Donald Raab about:

the relation between Clipper and FoxPro,

Smalltalk blocks with Square brackets and a vertical pipe separating the parameters,

the knights of the square bracket,

the pipe replaced by the arrow in Java,

block context template as the single type for every SmallTalk block,

anonymous inner classes used as block substitutes before Java 8,

the Smalltalk hierarchy with object as a subclass of nil,

nil as an instance of the undefined object class that still responds to messages,

a blog post about null as an object in Java,

metaclasses and the endless class of the class chain,

nominal types and functional interfaces versus one type for all blocks,

single abstract method (SAM) and the disappearance of the term,

the combinatorial explosion of function types over primitives and generics,

naming generic type parameters T and V,

single character type variables and collisions with variable names,

var and local variable type inference in everyday Java,

var for expected values in unit tests,

postfix completion in IntelliJ IDEA with dot var and dot out,

changing a running Smalltalk image and porting IntelliJ IDEA key bindings back to VisualAge for Smalltalk,

control Y to delete a line in WordStar and in IntelliJ IDEA,

JetBrains MPS and custom DSLs,

Clipper code blocks with curly braces and double square brackets around the parameters,

blocks for sorting and for T-Browse columns in Clipper,

Clipper visual objects compiling to native Windows executables,

the Classy library for classes without inheritance in Clipper,

the Smalltalk collection protocol select,

collect,

reject,

detect and inject into,

filter as an ambiguous method name compared to select and reject,

transforming behaviours map,

flat map and collect,

String.transform in Java,

the missing reject in the Java Streams API,

Alice's Restaurant by Arlo Guthrie as the claimed origin of the Smalltalk method names,

Smalltalk popularity in Europe and Argentina,

Newspeak,

OS/2 Warp and REXX,

duck typing and does not understand errors in Smalltalk,

Ruby as a Smalltalk dialect with select,

reject and inject,

asciidoctorj running on JRuby,

blocks versus closures and captured state,

effectively final captured variables in Java lambda expressions,

Groovy closures and Grails before Java 8,

the joint Groovy and Java compiler,

Apache Groovy and the Gradle DSL,

blog exchanges with Groovy committer Paul King,

the Scala and Kotlin adoption waves,

Java 25 shipping enough out of the box,

the origins of Eclipse Collections in 2004 as Caramel (collection array map enumeration library) at Goldman Sachs,

open sourcing as GS Collections to share use cases with the JSR 335 expert group,

the ten year quest to get lambdas into Java,

the BGGA prototype,

lambdas in the JSR 341 expression language before Java 8,

memory consumption and code duplication rather than performance as the motivation for Eclipse Collections,

procedure instead of consumer and extending consumer for JDK interoperability,

select with and predicate two to keep lambdas stateless and static,

method references preferred over multi line lambdas,

refactoring anonymous inner classes to lambdas for 10 to 20 percent less code,

the commercial JGL collections framework,

early access testing in the OpenJDK quality outreach program,

a new Collectors.toList instance created on every call,

Brian Goetz and the constraints of the Java language architect,

composing records,

patterns and switch expressions into data oriented programming,

the book Eclipse Collections Categorically and its method categories,

custom folding regions in IntelliJ IDEA to simulate method categories

Donald Raab on twitter: @TheDonRaab

An airhacks.fm conversation with Andy Damevin about:

Texas Instruments TI-BASIC calculator with GOTO and GOSUB,

programming games including a trading game on the calculator,

sending programs from a computer to the calculator,

building viral Facebook games with the social graph API,

PHP and MySQL with iframes and OAuth for Facebook authentication,

earning revenue with ads and paid credits,

a first serious Java project simulating cars moving across lab screens over TCP/IP sockets with threads and shortest-path routing,

comparison with Java mobile agents and Aglets,

JBoss Seam and Java EE,

moving to Spring then quarkus,

founding a company and building the Wazzam events app with Java,

Spring,

Angular and PhoneGap,

joining Red Hat and the Quarkus team,

building the code.quarkus.io launcher,

creating Quarkus Quinoa to integrate NPM front-end builds into the Quarkus lifecycle with a dev proxy,

the Quarkus Web Bundler for bundling web applications without NPM using WebJars and Maven NPM dependencies,

minification and hashed asset versioning,

Deno as a faster and lighter Node alternative delivered as architecture-dependent Maven and Gradle dependencies,

Roq the Quarkus static site generator exporting a running Quarkus application as HTML snapshots,

the Qute template engine with compiled type-safe templates CDI access and iteration,

static site publishing via Git to GitHub Pages or Netlify,

using a scheduler and CDI events or jgit to regenerate and push pages offline,

the RoqGenerator application-scoped bean with a generate method,

dev mode versus prod mode differences,

Roq as suitable for developers and AI with MCP integration and Playwright for iterative design,

AI for processing content into summaries and translations from Markdown asciidoc JSON and YAML,

an integrated WordPress-style editor for writers with Git sync,

and devoured.fyi a static AI and developer NeWS site built with Roq using Tailwind and plain Vanilla JS

Andy Damevin on twitter: @ia3andy

An airhacks.fm conversation with Gunnar Morling about:

returning guest discussion four years after episode "#174 Kafka Connect CLI,

JFR Unit,

OSS Archetypes and JPMS",

the One Billion Row Challenge (1BRC) as a Java community coding challenge,

aggregating a 13 gigabyte semicolon separated file of one billion temperature measurements per weather station,

baseline single threaded idiomatic Java at five minutes versus a 1.5 second winning entry,

two orders of magnitude speedup,

parallel processing scaling near linearly across cores,

memory mapped files via the Foreign Function and Memory API for arbitrarily large files,

reading eight bytes at once into a long,

_multiple_data" rel="noopener noreferrer">SIMD parsing via the incubating Vector API,

GraalVM native binaries,

no third party libraries and single source file rule,

results on par with C,

Thomas Würthinger and the GraalVM team participation,

HTMLDB a Java 25 executable shebang script storing records as semantic HTML pages using the built in XML parser,

agents reading XML better than JSON,

Hardwood a minimal dependency multi threaded Java library and CLI for reading and writing Apache Parquet files,

columnar versus row based formats,

efficient encodings including delta encoding and bit packing,

trading CPU for disk size,

range requests to read specific columns from object storage like S3,

the dependency heavy Parquet Java library pulling in the Hadoop stack,

zero mandatory dependencies with optional modules,

a hand written AWS Signature Version 4 signer using the JDK HTTP client instead of the AWS SDK,

verifying the signer against the AWS TCK test suite,

owning code with LLMs,

optional dependency for IAM instance profiles,

Zstandard and Snappy compression as domain specific dependencies,

Java LLM code generation quality and import handling,

AIRails.dev skills based on Boundary Control Entity,

spec driven development storing the spec in package-info Java Doc using EARS notation,

the code review pyramid as a review skill,

GraalVM WebAssembly web image compiling a Java text user interface to analyze Parquet files in the browser,

an agent skill for Parquet analysis in natural language,

Apache Iceberg and S3 Tables,

Apache Flink integration,

the shift in the reuse versus own trade-off with LLMs,

Agent zSmith a zero dependency Java agent harness,

var over explicit types

Gunnar Morling on twitter: @gunnarmorling

An airhacks.fm conversation with David Kral about:

Helidon JSON and Helidon JSON Binding,

compile-time JSON binding with annotation processors generating readable Java source code,

no bytecode manipulation and no reflection,

debuggable generated converters,

comparison with Micronaut compile-time generation,

why Helidon avoids the JSON-B API and its reflection overhead,

a proposed bridge to the JSON-B API for stable standards-based code,

serializing Java Records with the @Json.Entity annotation,

a package-info annotation idea for processing an entire package,

Boundary Control Entity (BCE) structure for entity records,

JSON-P style JsonParser and JsonGenerator entry points,

HashMap-like dynamic JSON objects for versioned and evolving APIs,

a single centralized entry point for discoverability,

grounding LLMs with Jakarta EE and MicroProfile standards to avoid hallucinations,

reducing dependencies by letting LLMs generate helper methods,

Java 25 source-mode scripting and simplified main replacing python scripts,

zero-dependency JSON parsing with a forked org.json,

JMH benchmarks showing Helidon JSON around 400% faster than Jackson and faster than yasson,

energy and cost savings from faster serialization,

object pooling and virtual-thread-friendly design with Scoped Values

David Kral on twitter: @VerdentDK

An airhacks.fm conversation with Simon Ritter about:

Azul Zulu as a straight build of openJDK versus Azul Zing/Prime as the commercial high-performance JVM,

improving Java performance without changing application code,

C4 the Continuously Concurrent Compacting Collector,

fully concurrent and compacting pauseless garbage collection,

reaching a global safe point and millisecond-level pauses,

a loaded-value read barrier intercepting every object read with a two-instruction test-and-jump,

using bits in the object header limiting heaps to 20 terabytes,

the one and a half day garbage collection pause anecdote on a terabyte-scale heap,

latency-sensitive workloads like high-frequency trading and ad brokering,

ZGC as a garbage collector heavily based on the published C4 work,

Falcon a JIT compiler based on LLVM replacing HotSpot's C2,

contributing the JIT wrapper and garbage collector integration back to LLVM,

speculative optimizations and deoptimizations,

throughput gains around 53 percent for Kafka and 30 percent for Cassandra,

doing more with less to reduce cloud costs,

ReadyNow capturing a profile of loaded classes,

initialized classes,

profiling data and compiled methods to reach about 98 percent of steady-state performance at startup,

the Cloud Native Compiler offloading JIT compilation to a centralized cloud service,

the Optimizer Hub storing profiles locally or centrally,

soft real-time versus hard real-time JVMs,

the Real-Time Specification for Java and immortal memory,

garbage-collector-less programming,

tiered compilation with C1 client and C2 server compilers,

virtual threads and platform threads in relation to garbage collector threads,

Azul Vega hardware history,

Log4Shell as a potential security check in the compiler service

Simon Ritter on twitter: @speakjava

An airhacks.fm conversation with Ian Rogers about:

Java's early API design strengths versus verbose C++/STL manuals,

the Java 7 String.substring behavior change from an O(1) view over the character array to an O(n) copy,

substring performance regressions at Google,

implementing a custom substring as a workaround,

designing APIs without knowing future customers,

the SPEC JVM98 jack parser generator throwing an exception per matched token,

exceptions used for control flow violating the exceptions-are-exceptional principle,

JVM benchmarks skewed toward fast exception throwing,

ANTLR and JavaCC as later parser tools,

class loaders pairing a type with a runtime notion,

ClassNotFoundException thrown from nested jar files,

the DaCapo benchmark as a test of exception-throwing speed,

Effective Java advice to return interfaces such as Map instead of HashMap,

why substring should have returned CharSequence,

the argument that String should be an interface and CharSequence the concrete type,

CharSequence length limited to int and capped at 2GB,

Guava Rope as a collection of CharSequences unable to implement CharSequence because of the int length limit,

signed versus unsigned sizing of arrays and strings,

byte signed and char unsigned inconsistencies,

StringBuilder versus StringBuffer,

the race condition avoided by StringBuilder cloning its array in toString,

StringBuffer passing array ownership under a lock,

biased locking making uncontended locks cheap,

the Attack of the Clones problem of defensive cloning,

optimizing clones away in the JVM,

transactional memory as an alternative to locking,

copy-on-write and CopyOnWriteArrayList,

Swift copy-on-write,

Linux kernel read-copy-update and epochs,

writing the Azul C4 garbage collector,

the C4 read barrier now used in ZGC and Shenandoah,

moving Azul from custom hardware read-barrier instructions to x86,

the two-space invariant in concurrent copying collectors,

IBM Metronome fixups versus two-space invariants,

detecting same-page references by XOR of two pointers,

trading computation for memory accesses in read barriers,

the Transitive Corporation binary translator,

Rosetta for Apple and a Sparc-to-Power translator behind IBM's planned Sun acquisition,

writing Android Runtime ART,

ahead-of-time compilation of Dex replacing Dalvik,

disk-size constraints of AOT compilation,

Hans Boehm and sticky mark bits for generational marking without moving objects,

ART generational concurrent garbage collection in Android KitKat,

HashMap interface dispatch replacing LinkedList iteration from JikesRVM,

alphabetically sorted interfaces putting AbstractCollection first,

Google Maps interface dispatch consuming half the frame time,

frame-rate and pause-time gains from ART,

WhatsApp broken by an unbalanced-lock bytecode obfuscator,

balanced locks required for biased locking,

thread safety annotations in Clang/LLVM guarding the Java heap,

the mutator lock and stale pointer risks,

a reader-writer lock model of the Java heap,

managing risk when replacing an operating system runtime,

CyanogenMod as a delivery path for ART,

Project Valhalla value types,

current work on the Linux perf tool and observability,

OProfile origins,

GPU versus CPU visibility in system tools

Ian Rogers on linkedin: irogers

An airhacks.fm conversation with Steve Hannah about:

meeting Steve Hannah at JavaOne years ago via Codename One,

the Apple IIGS as a first computer,

floppy disk games and Bob Whitehead's Hardball!,

starting web development in 1997 with Perl and CGI,

the O'Reilly Perl camel book,

CGI security issues and the parallel to LLM tools,

choosing Java Servlets over CGI for startup-time performance,

moving to PHP for quick and dirty web development,

PHP evolving toward enterprise patterns with Zend,

Symfony and Laravel,

PHP at Cloudbeds as a serious enterprise language,

Facebook compiling PHP with HipHop,

connection pooling and data sources impressing PHP developers,

convergence of ideas across Java,

JavaScript classes and React moving from object orientation to hooks,

web components as JavaScript classes with properties,

TypeScript versus JavaScript with JSDoc types in VS Code,

LLMs reducing the importance of web frameworks that follow standards,

porting React to Java on TeaVM using Claude,

Flash and ActionScript for rich interfaces before HTML5,

key frames hiding the full code base in Flash,

VisualAge for Java showing only methods and

_CLS,

_and_END" rel="noopener noreferrer">printing source to understand it,

the Xataface open-source PHP/MySQL CRUD framework started in 2005,

the Dataface to Xataface rename,

FileMaker as a low-code database tool and its licensing constraints,

joining Codename One as the first hire in 2012,

front-end Java versus back-end Java culture at JavaOne,

the extreme GUI makeover Swing session,

coding with LLMs in 2026 using Claude Code and Codex,

building a personal Swing-based IDE for multi-repo multi-branch agentic workflows,

work trees and terminal-organized agent sessions,

a possible Swing and JavaFX revival because they ship with Java and LLMs know them,

Java 25 source-mode shebang scripting replacing Python scripts,

Java shipping more built-in functionality than Python for regular expressions and dependencies,

Ruby versus Python popularity,

LLMs understanding Java (~87%) better than JavaScript (~60-70%),

type safety enabling LLM self-correction,

grounding LLMs with MicroProfile and Jakarta EE normative specifications,

the JSR normative language read by LLMs,

business annotations and rich JavaDoc and package-info improving LLM output,

reducing external dependencies so LLMs avoid decompiling JARs,

token savings from standards-based Java,

AWS Bedrock for stable and private Claude access with Claude Code,

Quarkus on AWS Lambda with cold starts and Provisioned Concurrency,

pinging a AWS Lambda every minute within the free tier to avoid cold starts,

cost calculation for Quarkus on Lambda with 2 GB RAM,

constructions.cloud Quarkus serverless CDK examples,

Google Cloud Run versus AWS App Runner,

AWS Lambda and Azure Functions,

AWS CDK as infrastructure as code in Java,

JDeploy for packaging and distributing desktop apps,

the AIRails.dev skills site and the microprofile-server skill,

zero-dependency Java scripts and agents,

migrating a WordPress blog to a Jekyll static site with Claude

Steve Hannah on twitter: @shannah78

An airhacks.fm conversation with Donald Raab about:

the Epson HX-20 as the world's first laptop and learning Basic,

an acoustic coupler modem,

the Atari 2600 and Pitfall,

Montezuma's Revenge,

Apple II clones and the Franklin Ace,

running a bulletin board system,

learning BASIC,

Pascal,

fortran,

COBOL,

Turbo prolog and Turbo Pascal,

dBASE III Plus as language and database management system,

DBF file format by Ashton-Tate,

Clipper by Nantucket as a dBASE compiler with Blinker linker,

T-Browse and cursor-based table access,

FoxPro and the x-based language family,

NDX/NTX/CDX index formats,

SQLJ embedded SQL,

Paradox and Delphi,

learning Smalltalk at IBM Object Technology University,

Alan Kay and pure object orientation,

blocks as lambdas in Smalltalk and Clipper (via the Classy library),

ENVY version control with method-level editions,

VisualAge for Smalltalk and VisualAge for Java,

method categories for organizing methods,

migrating a Clipper application to Java using interfaces and static methods in a procedural style,

transparent persistence with TopLink and EclipseLink,

memory constraints in 32-bit Java on Solaris,

building a custom caching framework,

the origins of Eclipse Collections in 2004,

waiting ten years for lambdas,

the JSR 335 expert group with Brian Goetz,

select/collect/inject versus filter/map/reduce,

eager methods on collections versus lazy streams,

code folding regions in IntelliJ to simulate method categories,

the book "Eclipse Collections Categorically",

JRuby and Asciidoctor,

meeting Yukihiro Matsumoto at OOPSLA 2002

Donald Raab on twitter: @TheDonRaab

An airhacks.fm conversation with Olimpiu Pop about:

discussion about the Java Advent calendar 2025,

running AI inference in the enterprise with Java versus python,

why inference needs a mature ecosystem,

the confusion between machine learning,

inference and LLMs,

HTTP clients for remote models,

TornadoVM for local model acceleration,

avoiding premature optimization for LLM-generated code,

grounding LLMs against normative Java and Jakarta EE specifications,

the separation between API and SPI to eliminate hallucinations,

Boundary Control Entity (BCE) structure with self-contained packages for scalable LLM code generation,

maximal cohesion and minimal coupling,

standards as an effective technique for LLM code generation,

MDN web components and custom elements for dependency-free front-ends,

reducing context and inference cost with short prompts,

AIRails skills site,

agents and skills across Copilot and other tools,

Eclipse Collections,

WebAssembly for Java with Chicory and TornadoVM,

pattern matching,

Java in industrial and IoT systems at ASML,

Legionella water-temperature monitoring with wireless sensors,

Apache IoTDB and Apache NiFi,

migrating Java Advent to Roq static site generator

Olimpiu Pop on twitter: @olimpiupop

An airhacks.fm conversation with Johan Haleby about:

discussion about the Occurrent event sourcing library for Java,

motivation behind building Occurrent as a set of building blocks for event sourced applications,

using higher-order functions instead of distinct framework concepts,

the library approach for gradually introducing event sourcing into regular projects,

CloudEvents as the serialized event format and its evolution into CNCF,

real use cases including querying the event store for consistent reads and per-user logs,

using the CloudEvents subject attribute to index a user,

enforcing unique constraints such as one email per person,

dynamic consistency boundary,

event sourcing fundamentals of storing a list of events instead of mutable state,

basing decisions on prior events,

the distinction between event sourcing,

CQRS and CQS,

materialized views and different read and write models,

subscriptions to events after they are persisted,

the difference between domain events and integration events for decoupling teams,

auditing versus event sourcing and why intent matters,

Hibernate Envers,

Transaction Script pattern,

folding events into state with Java Gatherers fold,

modelling domain logic with sealed interfaces and records,

static decision methods returning new events,

the Redux analogy,

snapshotting and closing the books for long streams,

Kafka and Kafka Streams for event-driven architecture,

cascading enriched events,

ksqlDB materializing streams as tables,

DynamoDB Streams and on-demand tables,

storing state alongside events in one transaction,

tractors and fitness trackers as event sources

Johan Haleby on twitter: @johanhaleby