wrs

Yes. "`@reduce(.And, ...)` combines every boolean using `and` and returns a single boolean."

If it's true (the common case here) then you proceed to look at the next 8 bytes.

If it's false, you apply a @bitcast (turn the booleans into bits) and @ctz (find the first 0) to get the index of where it was false.

You left out the hyphen in human-like, and the final period, so now we know you aren’t human. Nice try though.

Chromium supposedly implemented Knuth-Plass for CSS's "text-wrap: balance", but reading the end of the tracking bug [0] it seems it stops at six lines? (Design doc: [1])

[0] https://issues.chromium.org/issues/40270471 [1] https://docs.google.com/document/d/1jJFD8nAUuiUX6ArFZQqQo8yT...

I’m responding to the “quietly disbanded” part. Neither is true; they continue to loudly come up with new initiatives. I don’t even know that they “decided it’s true”, as that’s irrelevant to the strategy, which is just to maintain a continuous atmosphere of loud uncertainty.

Indeed, this is a much more realistic and useful framing of what to do with the current capabilities of LLMs. They work so fast, at such a high level, that you can speedrun the co-evolution process and end up with a spec and code that works. You can actually use second-system (fourth? fifth? I lost track) syndrome to your advantage because it’s so cheap to throw things away. And they don’t just write the system, they also write the test harness, the benchmarks, the failure simulation, the statistics…all the stuff that seems like “overhead” but lets you drive that evolution with data.

I’ve kind of drifted into this mode a bit at a time over the last year, but hadn’t stepped back to make such a coherent explanation of it.

Are you not counting the SAVE Act as an “initiative”? Even if it doesn’t pass, it’s certainly keeping the idea of election uncertainty front and center going into the midterms. Which gives cover to the local officials who have been inserted all over the country to mess things up.

My main point was not about the implementation stage, but the verification stage. Letting the smarter agent verify the work of the cheap agent finds a lot of little oversights and sloppiness that I used to have to find myself. So I’d be interested in that cost comparison.

It wasn’t clear to me (and still isn’t, after slogging through the inhuman article again) that the verification here is done by a separate agent from the implementation. That’s a second trimming step, but in reverse: at that point you want the new code in the context, but not the implementation reasoning.

This just sounds like the standard playbook for this crowd (by which wide brush I mean authoritarians and their enablers). They really hate being called on their lies, and their immediate response is to attack with whatever comes to hand (press release, xeet, the DoJ…depends on the person).

Then you would expect the implementation to be structured the same as SQLite, and having glanced at the result, it looks like at least some things aren't. For example, it seems to use an operator-tree executor rather than SQLite's bytecode interpreter.

Lately I'm trying a variation on this: Have the main agent make a phased implementation plan, then for each phase, have it start an implementation subagent with a focused prompt, then review that agent's work in the main session. The theory being that the main session still contains all the research, but it can review just the diff rather than have the entire implementation session in context as well.

The post doesn't include a review in the cost comparison, but I find that immediately doing a review catches lots of mistakes.

Are these answers and visualizations accurate? How accurate? How do you know?

Here are some recent examples from Russia, Turkey, and Egypt. [0]

[0] https://www.hstoday.us/featured/how-autocrats-exploit-the-de...

To be precise, he thinks they're anti-authoritarian, for which "terrorist" is the long-established authoritarian code word.

Assuming this description is accurate, if they were all like this then none of them should have won. They should have all been disqualified and the organizers should have looked at themselves in a mirror for a long time.

Exactly as well as C does, it seems.

    func newPerson() *Person {
        p := Person{Name: "Alice", Age: 30}
        return &p
    }

    static main_Person* newPerson(void) {
        main_Person p = (main_Person){.Name = so_str("Alice"), .Age = 30};
        return &p;
    }

So saying you get the "safety of Go" is a bit of a stretch.

In my experience, mathematicians are attracted by over-simplified/lightweight versions of programming. I think "just tell me what I need to do my job" is a universal human principle.

OK yeah, that does sound fine once you say it, but since the only stated rule is “one more letter”, I don’t think it’s obvious enough.

Four

It seems to disallow valid words made with the same letters, which doesn't feel fair. (I don't want to spoil an answer, but -- especially when the word it insists on is arguably French!)

OK, these folks have way too much money. This is like peak-Google vibes.

This was Chase, in WA. Part of the problem may be that I used an address on the account application that didn't match the one on the state company registration. Rather than let me update the application, they required that I update the state registration to match it ($50 fee btw). (To be clear, both addresses were current and valid.) That may have set some kind of risk flag that increased scrutiny later.

But they were specifically worried about the transfers being scams -- at least, that's what they said. They insisted on calling my other bank to verify that I was in fact the owner of the other business account. And I know there's been a big increase in things like fake real-estate scams, so paranoia is understandable.

However, the way bank fraud/risk departments work is generally completely opaque. I've previously had Bank of America refuse to open an account, with no reason given and no possible recourse. And I can't imagine a much more vanilla, boring, good-credit person than me, so I have no idea what set them off!

Everyone suffers from this, not just the scam victims. I opened a bank account for a new business this year, and the friction for doing perfectly normal things was ridiculous due to the bank’s paranoia about scams. I couldn’t even make an initial deposit from my previous business, or transfer money to my personal account, without triggering a fraud alert and freezing the entire account (couldn’t even log into the bank website) until I could call and verify that it really was me on both ends of the transaction.

Yeah, that’s not sustainable. Presumably they’ll come up with a guardrail (followed by an exploit, followed by another guardrail, repeat forever…).

The gun is not smoking; it’s an honest footgun that will be load-bearing when it lands.

The first polished no-systemd distribution

Surely not. There were no polished Debians before 2014?

People say this about everyone who calls something a bubble, right up until it pops.

That is what he said.

When the AI bubble bursts, there will be stellar bargains on GPUs…

these standalone models can do amazing things

The things these open source standalone models can do will only expand, and they will become a given for our computing applications.

I think of the “big” foundation models as the “fossil fuel” of AI. Once the bubble pops and we can’t afford to train any more of them, we’ll be distilling and remixing the ones we managed to make during this weird period where they were feasible.

Also, the stakeholders decided the epidemic was a hoax in the first place.

Claude Code and Opus 4.8 love to describe changes in comments (perhaps because that’s what’s on its “mind” at the time), like “this used to do A but that did a bad thing so now it does B”. I’ve almost convinced it that changes go in the commit message, not the comments.