that this article is no.1 on HN right now shows that media could successfully use this framing when reporting on security incidents. i.e. readers will generally accept that framing and engage with the story (i.e. drive views/impressions).

so "the more evil stuff these agents do the more capable and impressive it makes them look" is not true in any deep sense. that there are perverse incentives driving the media to choose that framing instead of the framing espoused by this article is real, and probably far more perverse than you're acknowledging. i.e. "trace the money" type of perversion; just offhand I know that OpenAI has purchased at least one media outlet that reports on AI happenings: of course that outlet is going to run the "OpenAI's LLM is so powerful it escaped containment" narrative. that this effect might exist across much larger scales used to be a reasonably controversial claim: just observationally, that idea seems to be received with less skepticism with each passing year.

so this is just a go binary that exec's `llama-server --model $MODEL_PATH ...`? there's room for llama wrappers, sure, but the readme only shows features that are already exposed directly from llama-server. it doesn't seem to do anything besides rename the CLI arguments: i don't get it.

if you're concerned about this and not on x86, i encourage you to extend this to other platforms! i believe it's possible to generalize this to every linux platform musl itself supports, in time.

Anubis has a fairly capable "policy" system. you can place something like this in your policy.json:

``` { "bots": [ { "action": "WEIGH", "expression": "path.startsWith(\"/expensive/endpoint\")", "name": "scrutinize-expensive-endpoints", "weight": { "adjust": 20 } } ] } ```

another thing smaller sites benefit from -- where the load induced by crawlers tends to be bursty (e.g. as they discover new expensive endpoints to crawl) -- is to adjust the difficulty up/down to maintain a steady system load.

``` { "bots": [ { "action": "WEIGH", "expression": "load_15m <= 16.0", "name": "sustained-low-load", "weight": { "adjust": -10 } }, { "action": "WEIGH", "expression": "load_5m >= 24.0", "name": "intermittent-high-load", "weight": { "adjust": 10 } }, ] } ```

when a system was designed for 100 req/s and bots hit it with 5000 req/s, nobody entering that queue is having a good time. Anubis is the trade those operators make just to ensure your request gets serviced at all.

30s load time is already a sign that the Anubis approach is breaking down. if there's nothing else ready by the next order-of-magnitude increase in crawler load, those sites quite likely will just disappear from the public internet. hate Anubis all you want: for most of us, the realistic alternative is strictly worse.

> What is the cost of 20% and is that cost worth “mildly annoying” everyone?

from the articled:

> With a bunch of generous assumptions, legitimate requests are only about 2% of git.kernel.org traffic — everything else are scrapers.

this is not some "CPU use is 20% higher than baseline" situation. it seems that people still do not understand the scale of these bad actors.

i helped somebody get Doom running on an old embedded system running some 4.x kernel. we just built everything, including mesa, statically and deployed that. imagine building everything static but loading the system's libgl.so instead (which was probably just a symlink or abstraction over mesa's own implementation). what's the benefit: we'd get older, less optimized graphics routines from 5 years ago?

if you're statically linking, then just bring your own graphics "driver". the kernel interfaces are stable enough. it's not conceptually different than embedding `syscall`s directly into your application the same way you do when statically linking libc.

i don't leave my home without earplugs anymore. if there's no opportunity for you as a recipient to put back pressure onto whoever's making the announcements, it seems any broadcast system will just inevitably degrade. they work in smaller situations, like individual buildings and such, but if you really want a message to reach everyone in society, then tell your neighbors: person-to-person remains the only workable structure for that "last mile", so to speak.

i can't not read this as "you didn't complain when we did the first bad thing, so you're wrong to complain when we do the next bad thing". that's an argument i hear presented way too often today, and it's just so dishonest.

problem for me was that they vendor like 30 different dependencies in a totally bespoke way that's largely incompatible with any modern package management: it downloads them as part of ./configure (IIRC) and with no way for the OS to provide its own. so you're either stuck using the prebuilt releases without any means to patch/improve the software, or if you do want to make improvements then it's a full-time job to keep the package in a buildable state. in the end that was too much work for me and i switched to Foliate: it's noticeably slower (webkitgtk) and lacking, but it's way simpler to develop on.

maybe they've improved the build system in the last couple years, though a quick peek shows that the nixpkgs expression is still using the binary release. if it becomes practical to build from source in the future i will 100% switch back to it.

i also expect you'll see markedly different results if you constrain yourself to small models. there even trivial harness improvements like Codex's /goal feature, and more capable basic tooling (e.g. semantic code grep, js-capable `fetch` tooling) make or break the actual task success rate.

at some point the conversation has to go past this reflexive "USA uses tech abusively -> but look at how abusive China is with tech -> ..." back-and-forth to acknowledging that neither party is your savior -- and then (hopefully) acting upon and coordinating around that understanding.

it gives "rewrite it in rust" vibes in the way they rush in to re-do everything without understanding why things were the way they were or if, in fact, anyone was using that obscure feature. maybe they'll sort it all out in time; maybe not. wish they could at least take less of a "we don't care if we break your shit" attitude in the meantime.

/rant

https://www.soundtransit.org/sites/default/files/documents/2...

page 11 has the $ figures. "link" is the commuter rail system: $408M operating expenses but only $51M revenue from fares, i.e. fares cover 12% of op ex.

the "average fare per boarding" is $1.34 (page 3; this is ticket price multiplied by the proportion of trips where the rider pays that ticket). throw that together: even with 100% payment compliance the average ticket price would be $11 per boarding for that to be a complete funding source. $11 would force more riders onto the subsidized fare programs, plus other knock-on effects from raising fares (e.g. reduced ridership in general) means the sticker price would have to be higher yet.

the commuter rail here was never designed for ridership fares to cover its operating costs. it just wasn't. the recent focus on fares in the face of all this is misinformed, that's the kindest way i can phrase that.

(apologies to hijack much of this with what turns out to be more of a Seattle-specific issue).

i posted the transcript as a reply to you, and HN automatically flagged it.

but go on.

my instinct is to step up and defend Andrew: to say that truly, he has strong opinions -- which is to say he _cares_ about doing things right -- but that he's more patient and accommodating than you're judging him to be from this 10,000ft view.

that's kinda weird: you might view this as a personal attack _from_ Andrew against Bun and i might view the reactions as personal attacks _against_ Andrew. viewing it through this lens without our preconceptions ought to make either both parties or neither party look bad, i think? i don't know the solution except to highlight the outsized impact that our individual preconceptions play when judging a situation from 10,000ft away.

1. do nothing: everyone gets page loads of 30s if not worse.

2. put the content behind anubis -> load drops by 80% and page loads are back to "a couple of seconds" (including the client-side challenge).

3. take the content offline -> load drops to 0.

which of these would you prefer?