quixoticaxolotl

The game tries to make the case that the problem with the rule "no vehicles in the park" isn't underspecification, but I feel it misses some important dimensions when it does that. Specifically, it only looks at specifying the subject of the rule i.e. what constitutes a vehicle. It doesn't consider the intent behind the rule, or the balance of interests affected by the rule's application.

Replace the rule with its intent - the grass shouldn't be damaged - and its balance of interests - the grass's short-term wellbeing should take less precedence than a person's - and you get a claim that is pretty straightforward to evaluate.

Instead of defending blanket propositions, perhaps content moderation should defend predicates - does X harm property Y? - and weights - does X injure Z?

Is this variation still subject to ambiguity? I don't know - I think it's subject to bias, but it's pretty much unambiguous.

> And we're heading toward a world where software companies let their users change the product themselves, since with an LLM that's easy. So if a company builds a good opinionated domain language for its product, everything its users build on top of it will be much better, because they start from the company's opinions and not from scratch.

This is a bold assertion, and one I think undermines the merits of the argument.

"Change the product themselves" - I haven't seen any software company or discussion propose doing this. I'm not sure how it'll work. It sounds like it blurs the line between configuration (letting the user toggle certain classes of existing behaviour) and forking (the user now owns the contract with the product).

Perhaps the idea is something like an embedded scripting language as used in some games, where users can write custom snippets to glue together what they want. Or a relational language to generate custom visualizations from raw data. These are the only forerunners of the concept that have found actual market fit to date that I'm aware of.

It's hard to generalize where else this would be useful outside of these domains, and in any domain I can think of - UI interfaces, data analysis, procedural generation - there is already a dominant language runtime bound to the environment (Javascript in browsers, C# in Unity) exposed to customers. Would Common Lisp be able to displace them? If so, why and how would it improve?

Merits on the basis of the runtime itself are meaningful, but the runtime needs to be popular for the value of the PL to be seen.

Note that the Shakespeare quote in the beginning is an example of antimetabole, not a pun.

They are already solving the problem with search engines, they're just using an LLM as a first pass to create better embeddings to run a similarity match on first. The difference in latency is likely made up for in accuracy.

Why? What purpose does it serve? Who benefits from it?

I think this is a false equivalence. Cloudflare doesn't espouse the position that ethnic cleaning is good, and afaik nothing it does in China enables that.

Further, DHH isn't calling for the deportation of illegal immigrants in parks. He's calling for the deportation of all people tagged with a specific label with no discrimination. The blog post talks about exactly that difference.

I agree that we live in an ecosystem where, in some industries, all options are terrible. That doesn't mean that, among those bad options, you can't exercise discernment and good judgment. I'm similarly a pragmatist from a different angle - I do believe the marginal dollar value I add to a company's bottom line doesn't change much of anything, and that voting with your wallet only works with collective action to be more than theater - but I also think that makes OP's conscientiousness admirable. Pragmatism isn't apathy or agnosticism, and shouldn't be conflated as such.

People claiming Andrew Kelley's remarks in this thread can't possibly be personal attacks surprise and sadden me.

If someone insults your ability to do your job, paints you as an opportunistic sellout, and thanks the stars for your riddance, saying someone shouldn't feel hurt because "we can separate personal from professional lives" says more about your inability to perceive your own hurtfulness than it does of that person's benevolence.

The minimum bar for tactful communication is to be courteous and empathetic. None of this had that.

Helping a mega-corporation make an extra buck is not "service to society".

If you meant doing a service job at a small business, where you can have real ownership over how it treats its customers, I would agree with you.

One benefit is that this can run in serverless / sandboxed containers where OS primitives are not exposed or heavily limited. I immediately thought of Cloudflare Workers, which runs on V8 and exposes WASM-only interfaces, using Workers AI.

Further, servers still have hosting value, but any business running agents is almost certainly going to want a sandbox that limits what code runs for agentic work, so targeting _sandbox_ environments is probably the better bet long-term. And, yes, you could implement your proposal in any chroot jail or gvisor, but nobody wants to get their hands dirty finnicking with that - programmatic access control beats file-based access control for the simple reason it's managed for you.

If anything, my critique of OP's implementation is actually the opposite of yours: they've chosen the right primitive and layer, but people really need contextual access control rather than RBAC. Sort of like ongoing zero trust. If it was possible to inspect the context, decide if it was a bad idea to allow the tool call, without exposing the decider to untrusted context, you could have something that really changes things.

How does one measure unique users here in a way different from classic p99? I usually associate p99 with an SLO of some kind, and each request as a "unique user" for the service, so at first it seems like the same thing - measuring p99 with a SLO would say 1% of users are allowed to experience a time longer than our acceptable minimum T, and you're measuring the percentage of requests ("users") experiencing T and trying to keep it below 1% (e.g.).

Is the difference more about measuring a request "across services"? That is, the total cumulative p99 across services must be small i.e. linking all requests to a user and then measuring that? Or is the difference elsewhere?

If the former: are you taking traces and graphing that? What's your methodology?

I'm from India too. It's disingenuous to say things like "Bangladeshi Muslims are not desired" and not mention the massive backlash the Citizenship Amendment Act received. It's almost as if people recognize arbitrary discrimination is the opposite of just.

Attitudes like yours - justifying entitlement without holding its corruption accountable - is why people have to leave their home countries: their own insufferable countrymen.

The effort here is laudable, and this is cool! But your real competition isn't regexes, but parser combinator libraries. For cases where readability and matching matter, parser combinators are the go to. It's a bit difficult to see how this improves on that front.