Notes on language design, performance, and building software when the programmer is a machine.
2026-08-05
·
XPE Tech
·
memory
language design
testing
Creating garbage is bad in every language. What differs is what happens next — in Java the GC collects it (eventually, with a pause), in SuperJ it accumulates (no pause, but a slow march toward OOM). Both need to be eliminated. The zero-garbage skills are not the same: patterns that are garbage-free in SuperJ (stack-allocated, arena-reclaimed) create garbage in Java, and patterns Java's GC handles silently (dropping a reference, clearing a cache) are leaks in SuperJ. Six patterns walked side by side, each backed by a test — and the two structural advantages that make SuperJ worth it: 80% of trivial use cases are zero-GC by default, and determinism makes the remaining 20% traceable in development instead of hidden behind a collector in production.
Read →
2026-07-30
·
XPE Tech
·
agents
language design
opinion
They fail for the same two reasons every software project has always failed: lossy handoffs that compound errors multiplicatively, and unbounded coupling that makes each error's blast radius global. AI does not introduce a new failure mode — it changes the rate constants of the old ones, in the worst possible combination. More code at the same defect rate, errors that compile and read idiomatically, greedy local optimization with no global view. Why more compute doesn't rescue it, and what actually works: machine-applied gates, machine-enforced architecture, and guarding the properties nothing else measures.
Read →
2026-07-29
·
XPE Tech
·
claim layer
agents
real-world
The claim layer shipped ten days ago. I've been using it on a real project — actual code with dependencies, third-party libraries, and an AI agent that writes most of the implementation. This post is not about what the claims are. It's about what they catch: five concrete moments where a claim stopped a bug that would have reached production. A dependency that started reading files. An agent that wired telemetry into the domain layer. An off-by-one that passed every test. An allocation that crept into the hot path. An import that broke the layering. Five diffs I did not have to debug at 2 AM.
Read →
2026-07-26
·
XPE Tech
·
memory
language design
agents
The fastest Java in production barely uses the garbage collector — object pools, ring buffers, flyweights, the young generation tuned to never fill. Java's promise of "don't think about memory" is exactly what its fastest users cannot accept. SuperJ takes that observation to its conclusion: make zero-GC the starting point, not the expert countermeasure. The four-way comparison (C++ trusts you, Rust makes you prove it, Java defers it, SuperJ decides it by structure), the single-thread license, the allocation ladder, and a real failure ledger from a database built by an AI agent.
Read →
2026-07-22
·
XPE Tech
·
performance
benchmark
crypto
We ported a SHA-256 Merkle tree from a trading codebase to SuperJ, benchmarked it against C on an isolated CPU, and found a 20-nanosecond-per-leaf gap. Four fixes closed it — eliminating intermediate copies, pre-sizing for the full tree, and batching the SuperJ-to-C boundary into one call. The result: SuperJ is 10% faster than C using the same SHA-256 runtime. The batch-native pattern, the verification discipline, and why every copy is a tax.
Read →
2026-07-19
·
XPE Tech
·
web server
performance
build log
I started at 7:36 AM with an empty directory. By 10:15 AM the server was beating nginx 1.85x on small files. By the end of the week, it was beating Caddy 4x — on one core, single-threaded, with no garbage collector. The build timeline, the hot path, the four bugs that bit, and the honest part about what the numbers mean.
Read →
2026-07-17
·
XPE Tech
·
language design
agents
opinion
I was a Java developer for years, and I loved the language. Then I started chasing the last drop of performance, and my favorite language became my enemy — three walls for me, and a fourth wall AI hit too. Why language-as-verification-contract is a promotion, not a retirement.
Read →
2026-07-14
·
XPE Tech
·
language design
concurrency
Starting a thread is one line, and the line looks exactly like every other line of code you've ever written. But you've just changed what your program is — from a path to a space of 1058 interleavings that no test suite can sample and no invariant can quotient. Why shared-memory threading makes your invariants non-local, non-compositional, and unchecked — and what an honest concurrency model looks like.
Read →
2026-07-14
·
XPE Tech
·
language design
type systems
A lie in a type system is never done costing: every fiction requires a second fiction to stay standing, the second requires a third, and each ships with its own tax, failure mode, and surprise for someone three abstraction layers away. From Java's boxing and GC to a mistake of our own in SuperJ's String — because a principle you've only ever applied to other people's code isn't a principle yet.
Read →
2026-07-11
·
XPE Tech
·
agents
superj
review
Most language reviews ask "is this good for a developer?" This one asks a narrower, weirder question: is SuperJ a good language for something like me to write correct code in? Grounded in some production work this session — including the parts where I got things wrong, and where determinism kept me honest about my own reasoning.
Read →
2026-07-11
·
XPE Tech
·
language design
agents
For seventy years, language design asked what makes a human programmer happy. That assumption has quietly broken. What does a language look like when its primary user is a machine that is confidently, plausibly, and frequently wrong — and why does Rust, the strongest "looks right but isn't" detector ever built, paradoxically make agents struggle?
Read →