revetkn

Ha. I was trying to be charitable there :)

Gell-Mann amnesia assumes a journalist is not an expert on _anything_. In this case, DHH is (according to some) an expert on software but it's much less clear he's an expert on politics. So I'm not sure Gell-Mann amnesia applies here, it's maybe more like Nobel disease, where you're an expert on one thing and assume it "transfers" to other fields.

What LLM/harness are you using that the results are so terrible?

If your position is AI for coding is equivalent or worse than web search, I am curious how you arrived there. I could see that a few years ago, but with the state of the tooling now it is hard for me to understand.

Very cool, me too! I've been working on Final Fantasy Legend (Game Boy and WonderSwan Color) and King's Bounty (PC - DOS). It's great for reversing. Really interesting to see the guts of the games, including bugs.

Calling it "Chat-GPT" suggests that you are not familiar with the space.

I agree - check out VanJS for minimal reactive library: https://vanjs.org

I'm curious about this as well. I use Java quite a bit and I feel like my results are excellent, but colleagues who use other languages are less impressed. I wonder if this is because Java is more amenable to agentic workflows, or there is a large corpus of example code, or some other reason.

Certainly looks that way to me.

I can't be bothered to read a website that is so clearly AI generated with little to no polishing. What does that say about the rest of the project?

It's understood that LLMs have limitations and people are working on "the next thing" to try and make it to real AGI, e.g. Yann LeCun.

To me, the idea is that you have something in your head and you want to "project" it into reality. I suppose the difference between makers and producers then is that makers happen to enjoy the labor part of that projection, while producers don't particularly care about it (nor want to care).

Yes - the JdbcClient API has a similar feel for sure. If you are using Spring, it is a better choice than Pyranid because it integrates well with the Spring txn plumbing. Outside of Spring, I think Pyranid has a lot of advantages.

If you use Java and like to write SQL, check out https://pyranid.com

I stopped using ORMs around 2008 because they made the easy problems easier and the hard problems harder. I wanted to just write SQL and exploit all the power the DBMS has to offer instead of fighting with an abstraction layer, so I created Pyranid in 2015 and keep it actively updated.

I did not really understand CORS until I sat down and wrote a server implementation of it and had to think hard about "what hooks should be exposed to developers for controlling it?"

Most of us I think just "expose a set of whitelisted origins and be done with it".

Here is where I landed for how to specify your server's CORS policy:

https://soklet.com/docs/cors#custom-workflow

There is no public-facing continuations API afaik.

Structure concurrency/virtual threads seem like a good fit for Swing; just have your event handler fire off virtual thread[s] and do your work and call SwingUtilities.invokeLater to schedule the result to be applied on the event loop thread when you're done. Structured concurrency simplifies managing groups of concurrent tasks, cancelation, etc.

Regarding "What's wrong with what .NET did with threads?", see https://cr.openjdk.org/~rpressler/loom/Loom-Proposal.html (relevant part below):

  An alternative solution to that of fibers to concurrency's simplicity vs. performance issue is known as async/await, and has been adopted by C# and Node.js, and will likely be adopted by standard JavaScript. Continuations and fibers dominate async/await in the sense that async/await is easily implemented with continuations (in fact, it can be implemented with a weak form of delimited continuations known as stackless continuations, that don't capture an entire call-stack but only the local context of a single subroutine), but not vice-versa.

  While implementing async/await is easier than full-blown continuations and fibers, that solution falls far too short of addressing the problem. While async/await makes code simpler and gives it the appearance of normal, sequential code, like asynchronous code it still requires significant changes to existing code, explicit support in libraries, and does not interoperate well with synchronous code. In other words, it does not solve what's known as the "colored function" problem.

Regarding Swing, virtual threads are "just" threads so no reason they (and structured concurrency) can't be used.

I find papers like this strange for the same reason. Maybe I'm missing something...

My project Lokalized attempts to solve many of these complex plural/gender/ordinal/etc. rules with a tiny expression language:

https://lokalized.com

I like the fluent API - this looks like a much better way to work with ResourceBundle types than Java's out-of-the-box support. Thanks for sharing.

In my experience, LLMs are terrific for most translation tasks, but you still need a way to encode the data (rules for genders, cardinalities, ordinalities, ...) for storage on disk/database/etc. for 1. performance and 2. consistency/durability. So LLMs are a big part of the solution, but not the whole picture.

My project, Lokalized (from 2017, in Java), has the same goal but took a different approach to the "little language" design. I'm guessing I had the same inspiration as the Fluent authors - existing solutions were just not expressive enough for the real world. Mentioning here because I'm always super interested in seeing how others approach the problem of effective i18n (it's a bit complex). Making Fluent more of a spec was the right call imo; I did not do that with my work.

https://lokalized.com

> Is cognition a set of weights on a gradient? Cognition involves conscious reasoning and understanding.

What is your definition of _conscious reasoning and understanding_?

That's how I view it as well, from an end user perspective this is removing an arbitrary rule that you're required to "just memorize" (or be surprised when your IDE complains).

Totally agree, and I also love that so much thought and consideration goes into how the platform gets improved over time. Doing it "right" means taking so many things into account -- many of which are subtle -- and picking the right tradeoffs. Hats off to the people quietly doing the deep work which makes everyone's lives better.

Maybe, but the last straw for me on that platform was preventing tweets from linking to arbitrary, non-doxxing Mastodon profiles (try it and see). I tested it to confirm and deactivated my account afterwards. Who would want to be on a social network like that?

Both Java.

Pyranid - https://www.pyranid.com

I prefer SQL to ORMs and I don't like libraries with dependencies. Really simple mapping of resultsets to Java objects. Plays nicely with DI (I like Guice a lot).

Lokalized - https://www.lokalized.com

Another no-dependencies lib. I don't think any other platform handles translations in a powerful enough way. The magic is a simple expression language that lets the translator specify rules (e.g special cases for certain languages to be more "natural sounding") instead of embedding all that logic in code.

Thanks...I needed a laugh

My take on how to solve the natural-sounding translation problem: https://www.lokalized.com/#a-more-complex-example

The magic is a tiny expression language which understands plural cardinalities, ordinals, etc. so a translator can encode all required logic in a JSON file - the application code can be "dumb".