You can try this yourself: GODEBUG=asyncpreemptoff=1
Also platforms like Wasm still do Mx1 scheduling without async preemption, where Gosched is required at places.
E.g.: my "transpiled" SQLite driver takes special care to make sure long running SQL queries (and the busy handler) can be canceled with contexts even on platforms without async preemption.
Indeed, probably for the best, even. You don't know what systems Claude will have changed in the code especially as these days people aren't even reading the code and Anthropic has a history of trying to sabotage others' code such as during the Fable release debacle where they outright said they'd do so if you're working on frontier AI for example. I wouldn't let any sort of company like that anywhere near critical systems.
The point is: using Claude to design a website, do accounting, run a marketing campaign, is not a supply chain risk for the DoD, but taken literally and given the scale of the DoD "no DoD supplier can use Claude for anything" clearly is punitive.
It is, because the DoD doesn't know what the contractor is doing with Claude, or what Claude is doing itself. Like I said Anthropic could just as maliciously sabotage if they detect they're being in autonomous systems, why do people seem to believe they couldn't?
How do you know the contractors will follow that and not mix information or systems up? Hasn't there been recent news of rogue agents breaking out of sandboxes? Maybe pre AI I would've agreed with you but the world is different now.
This is bananas. I've seen 25 year old software systems that haven't broken the 100k commits barrier. It feels like that ought to be enough for entire product lifecycles. What's going on that isn't simply wheelspinning?
This happens. I catch claude and codex committing broken code all the time, and then stacking micro fixes on top, still broken. You can go very long if you're in a harness until you realize it's just committing everything. Sometimes if you give it a goal, or a long task, this happens too, every little argument with itself, every finding, adjustment, is a new commit. None of them make sense, they happen anyway. One line nonsensical change, 20 line reassuring comment, committed.
My teammate insists that prompt and "context" engineering solve this. You just have to tell the agent "don't make any mistakes" and "keep it simple" and "don't add fixes on top of already broken code"
Article makes it look like nothing happened in the embed/low-memory/single-threaded malloc space in decades since Doug Lea's malloc.
I just implemented TLSF for my minimal Wasm libc: fragmentation is just as good, performance is a lot more consistent (and on average better), for a significant reduction in code size.
Interesting! I have also implemented a version of TLSF for my (currently single-threaded) programming language. I also found it to be good for my use case (embedded / minimal code size). I'll compare it against yours. One improvement I did is some kind of preallocation for small blocks.
https://github.com/thomasmueller/bau-lang/blob/main/src/main...
This is true, but I'm not sure if I trust users to preserve case in case-insensitive filenames when copying files around, possibly at some point passing through something like a web server that may apply case normalization. Sort of like timestamps on files, they're handy for things like synchronization, but I hesitate before relying on them as a primary source of truth for anything mission critical.
Also platforms like Wasm still do Mx1 scheduling without async preemption, where Gosched is required at places.
E.g.: my "transpiled" SQLite driver takes special care to make sure long running SQL queries (and the busy handler) can be canceled with contexts even on platforms without async preemption.
reply