Geertjan Wielenga: An Introduction to the Java Visual Recognition API
Geertjan Wielenga has published article introducing JSR 381, the Java Visual Recognition API, and demonstrates a nearest-neighbor image classifier built on DuckDB.
Geertjan Wielenga has published article introducing JSR 381, the Java Visual Recognition API, and demonstrates a nearest-neighbor image classifier built on DuckDB.
Protonβs CTO wrote a memo that nearly eulogized writing code by hand. Lars Faye points out that expertise comes from experience, and the memo doesnβt say where the next generation gets any. Hereβs what used to teach it, and three ways to keep teaching it.
The PHP2Shell story has reached the people who sign the checks in the same week it reached the people who file the patches. Are we seeing anything actually happen for once? Are people trying to row the boat instead of just rocking it?
Compute power can reproduce almost anything; it can't imagine anything. "Learn to code" pointed people at what AI is able to automate, and we should have been asking for imagination, not lines of code.
Alberto Denia's artisan and engineer are a good lens on agentic coding: an artisan keeps his fingers on the code, and an engineer relies on the factory to make bricks. Both work, at different scales.
Kristen Maevyn's essay "The Decoherence Trap" names the cost a system accrues when it holds several valid but mutually incompatible models, so every change becomes a job of translating between them and guarding against side effects.
Nate Meyvis takes up a question AI skeptics keep raising: if AI-assisted coding is so powerful, where is the wave of new, good software? Several of his answers hold up well, particularly that approval chains donβt speed up and that much new software is private. What he doesnβt address is the question itself.
Alex Martsinovich argues that agentic coding causes four unavoidable harms - slop, alienation, deskilling, and team breakdown β but these aren't technological inevitabilities, they're the results of specific choices about how to use AI coding tools.
Kerry Ivan Kurian's 'Exponential Failure' says AI agents multiply parts faster than they improve them, so projects fail by arithmetic. He's right about the math and wrong about the fix: the answer isn't fewer parts, it's parts you can describe.
A recent discussion on how AI was used effectively made me wonder what "effective" or "better" meant, because there's no way to test the alternative any more to compare. I still don't know how to characterize my own results, but I think it makes me better because it gives me a chance to work out who I am and what I mean to say, but not really how to say it.
Sean Goedecke argues that domain expertise is the real prompting skill. He's describing two quantities as one: a floor, available to anyone who can describe what acceptance looks like, and a gain that multiplies whatever you bring.
There's no standard for marking AI contribution, and there can't be, because contribution isn't a scalar. What readers actually want is attestation, and that's what a byline always was. The question was never whether a machine touched the text. It's whether anyone was behind the controls.
Baldur Bjarnason argues that development tools win by making developers replaceable. The JVM ran that experiment three times, against Visual Basic's precedent, through EJB's committee, and into Spring's reversal, and the results say his theory is exactly half of a whole.
Reader Hideki Idoru argues that AI is a decent information distiller and a bad tool for nearly everything else in software, because no one can cheaply verify that generated code is correct. The deeper claim is that most programming was already trivial, unabstracted busywork, and AI has only torn the mask off. It's worth reading and thinking about.
Ray Myers wrote up the Bun rewrite and the fight around it. It's emotional in places, but there's real signal in it about how agentic work is sold versus how it's done, and one review technique worth stealing.
A Reddit user on r/SaaS is looking forward to the consulting rates he'll command once the wave of projects trying to dig out from under AI slop hits. He's not wrong, but he's dated the pattern to 2010 offshoring when it's older than that, and the lesson never sticks: coding was never typing.
Sven Reinck wants dependency diagrams that nudge you toward clean architecture by looking wrong when the code is wrong. The instinct is sound, the history is unkind, and the difference between expressing complexity and measuring it is where the whole idea lives or dies.
Bun was ported from Zig to Rust by an LLM and passed nearly all its tests - while shipping more than ten thousand unsafe blocks. Memory safety is the main reason you'd pick Rust. So what did the rewrite actually accomplish?
Christian Ekrem's 'The Tacit Dimension' carries Polanyi's 'we can know more than we can tell' into software engineering. He's right that experience works that way. Knowledge doesn't, and the essay never separates the two.
This is a working example of using red/green testing to fix a bug - one that starts in the issue description and lives in the code. You can fix the issue, but the bug remains because it's part of an unexamined specification. Testing - and caring - are the fix.