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,
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