kzemek

Fair enough! My comment is about agentic-focused libraries in general, it’s inaccurate of me to call all such libraries “LLM-focused”

Speaking of inaccuracies, BEAM does provide pretty good location transparency - but resource migration between nodes in particular is not part of the built-in goodies that OTP brings

I really like the focus on “data and pure functions” from the beginning of the post.

I’ve read a lot on HN about how BEAM execution model is perfect for AI. I think a crucial part that’s usually missing in LLM-focused libraries is the robustness story in the face of node failures, rolling deployments, etc. There’s a misconception about Elixir (demonstrated in one of the claw comments below) that it provides location transparency - it ain’t so. You can have the most robust OTP node, but if you commit to an agent inside a long running process, it will go down when the node does.

Having clear, pure agent state between every API call step goes a long way towards solving that - put it in Mnesia or Redis, pick up on another node when the original is decommissioned. Checkpointing is the solution

We also had a similar use case, so I built Snex[0] - specifically for Elixir-Python interop. Elixir-side spawns interpreters with Ports managed by GenServers, Python-side has a thin asyncio runtime to run arbitrary user code. Declarative environments (uv), optimized serde with language-specific objects (like `%MapSet{}` <-> `set`), etc. Interpreters are meant to be long lived, so you pay for initialization once.

It's a very different approach than ex_cmd, as it's not really focused on the "streaming data" use case. Mine is a very command/reply oriented approach, though the commands can flow both ways (calling BEAM modules from Python). The assumption is that big data is passed around out of band; I may have to revisit that.

[0]: https://github.com/kzemek/snex

There’s a setting for that:

Cursor Settings -> Agents -> Applying Changes -> Auto-Accept on Commit

These are spoofed packets for SYNACK reflection attacks. Your response traffic goes to the victim, and since network stacks are usually configured to retry SYNACK a few times, they also get amplification out of it

It might be from me being so used to it, but I do like Elixir’s `def`/`defp` second best to Rust’s `pub`

Oh nice, I didn't know about that one! It's interesting how many solutions are in this space; aside from Destructure[0] and shorter_maps[1] I also know about shorthand[2] and synex[3].

[0] https://github.com/danielberkompas/destructure [1] https://github.com/meyercm/shorter_maps [2] https://hex.pm/packages/shorthand [3] https://hex.pm/packages/synex

There was also a relatively popular fork shorter_maps [0], mentioned in the blog post above. My motivation for implementing es6_maps instead of using/updating shorter_maps was (I'm copying from my post in the Elixir forums [1]):

1. I do firmly believe this is a good language feature and a very natural extension of map literals syntax;

2. at the same time, being a language feature it should be simple - es6_maps works only with atom keys and has no extra features over the key expansion.

Point 1 is additionally reinforced by how easy it was to introduce to the compiler - I’m injecting just 9 lines of simple code, while parser and lexer already accept short-form maps without modifications.

[0] https://github.com/meyercm/shorter_map [1] https://elixirforum.com/t/es6-maps-ecmascript6-style-shortha...

> I think the formatter plugin is going to give someone insane amounts of regret one day

The formatter plugin features a "reverse" flag exactly to prevent any kind of regret like that. You can reformat your code automatically to remove all shorthand maps and remove the dependency in a couple simple steps.

> I’d really encourage you to put a note at the top of the readme that this shouldn’t be used in production code.

Noted, although I do think it's production ready. I'm going to keep updating the library if or when a new version of the Elixir compiler breaks it, and it does feature an easy way out in case I disappear.

Yes it does!

> There have never been a single 4K monitor under 27”.

There's a few 24", Dell has at least a couple.

And why does it seem fair enough? The garage door is mine, not Chamberlain's (although that starts to be more and more debatable the farther into enshittification we go).

I'm pretty sure we're also allowed to discuss and even criticise it to our hearts' contents.

TFA does mention some points that address your "why"; the ones that most speak to me the most are:

> WordPress’s minimum requirements would be a simple PHP server, without the need for a separate database server.

> SQLite support enables lower hosting costs, decreases energy consumption, and lowers performance costs on lower-end servers.

This can be translated to lower operational overhead and faster loading times for small-database sites, and that equals money.

Are you saying that SQLite is weakly adopted in general or weakly adopted in WordPress? The former is rather far from the truth[1], while the latter is rather obvious given that WordPress doesn't support it yet...

[1]: https://www.sqlite.org/mostdeployed.html

Firefox quarantines Facebook sites in a separate container (with its own cookies and browsing history, etc.), losing back button is an unfortunate side effect.

I don’t think calling Erlang esoteric is fair. Niche, sure, but it powers multiple big services and well known enterprises

Except when that's an alarm clock time, and the user takes a trip on Friday that moves him -4h worth of timezones.

Or if their local legislature suddenly decides to cancel the DST change that was supposed to happen Friday night.

But servers in upstream block don't have a 'resolve' setting in non-plus versions.

'resolver' still does something in the open source version, but requires some configuration contortions.

For a given value of "zero"; the packets are still copied from NIC buffers and wrapped in sk_buff.

Airpods connected to an Apple device have uncanny range compared to what I'm used to with other bluetooth pairings

Or you can have the browser cache the CORS header for up to 2 hours (cross-browser), for the same performance effect - but it will also work for third party website consumers of your API that you can't just put on your domain.

> I always like to ask for what kind of task one needs GILless python?

> CPU bound? If you are using native python code for CPU bound tasks you are already in a bad place.

While I think you may have misread my comment for a value judgement on Python's GIL, I don't see as particularly useful dismissing major potential (multithreaded) performance gains for a slow language just because there's faster languages. Languages that are better in some way - like speed - should stand as a benchmark and a goal, not a reason to give up improvements.