fweimer

Allen AI imposes further restrictions on their model releases, I think: https://allenai.org/responsible-use

If the user is held accountable when the AI goes wrong, it discourages too many applications. Blaming people is incompatible with the business goals, I think. That's very different from weapons and other dual-use tools.

The most charitable interpretation: The new wording includes all forms of covert advertisement (say embedded in the content itself). All their plans always had that.

Not sure if the Stratus reference is correct. Big-endian x86-64 is a real thing on HPE NonStop:

“ The executable format that works on HPE Nonstop Compute's OSS is ELF64-bit, Big_Endian, X86_64. ”

https://inbox.sourceware.org/gcc-help/AM7PR02MB6483A12F6B98D...

Does the 16 come from maintenance_io_concurrency, which is also used to limit the prefetch depth?

I still think some details are missing for a true explanation of what is going on. Where does the random access pattern come from? Is prefetch unnecessarily performed for full-page images?

It's not a press embargo in the sense that the whole package of information becomes public once the embargo expires. There will be a published record on the cve.org, but often those who initiated the embargo insist that key details related to the vulnerability remain private even after the existence of the vulnerability and its remediation have been published.

Consider this example:

https://www.cve.org/CVERecord?id=CVE-2026-113119

At this time, the corresponding Chromium bug tracker entry is still private:

https://issues.chromium.org/issues/557075191

(I just picked this one at random, I haven't checked if the information is publicly available from another source.)

I thought that C# does not have escaping interior pointers, unlike Go. Last time I looked at the CLR, I couldn't find support for interior pointers.

Is the support gap mostly related to weak references and finalizers? Or is something else missing?

(Obviously those are already pretty significant gaps.)

I think with CLOS, you can go back to using single verbs for function names. However, this has a performance cost. Encoding the receiver type in the function names makes the call much easier to optimize.

What remains is field access. Curiously, first-edition K&R C actually required similar type-encoding in field names because field names were global:

https://usenet.trashworldnews.com/?thread=288637

Same for ML, which is roughly of the same age, except that it took much longer for ML-derived languages to lift this restriction.

On the other hand, every time I wrote down examples that I think should look really bad in prefix notation, like this one:

    p3.x := (p1.x + p2.x) / 2;

It is actually not so terrible with a sufficiently streamlined prefix syntax:

    (setf x p3 (/ (+ (. x p1) (. x p2)) 2))

But maybe there should be a mechanism that the reader transforms p1.x to (. x p1), in the same way that it transforms 's into (quote s). Then we get this:

    (setf x p3 (/ (+ p1.x p2.x 2)))

Or if there is a concept of a place:

    (set p3.x (/ (+ p1.x p2.x 2)))

But that probably needs static typing for an efficient implementation (or set needs to deconstruct its first argument during compilation).

Where in Italy would you put reactors?

https://maps.eu-risk.eucentre.it/map/european-seismic-risk-i...

Sardinia?

When emulated on today's hardware. But the hardware actually available at the time was pretty unreliable by modern standards, I think.

Exfiltrating many binaries gives you the right to their source code, or at least triggers attribution requirements for licensing compliance.

But perhaps Meta did the smart thing and put the source code into the VM, too. That would be a very reliable indicator that they expected exfiltration, and this is in fact working as intended.

I'm pretty sure people said this about the early COBOL compilers, too. They were buggy, the API had terrible uptime, and was slow to respond.

Overall, this whole approach to programming seems to align really well with the original premise of COBOL. I wonder when people will start putting

# Identification Division

into their Markdown files.

There's probably still value (if you want to call it that) in it as a proxy, both to bypass IP address rate limits and to add necessarily credentials.

There's also another aspect Quite a few API providers provide automatic renewal for MCP server registrations, but not for personal access tokens. This may be less relevant when models just drive the user's browser.

Likely a reference to ELIZA: https://en.wikipedia.org/wiki/ELIZA

It's just a compiler barrier (signal fence), not a memory barrier that concerns the CPU. The CPU is free to reorder loads and stores.

Was the public key directory even operational in 2012? What about revocation checking?

I think processing that information is mandatory now, but probably was optional/largely unimplemented in 2012. But maybe I'm off by five years or so?

I expect that UD2 stops instruction fetching (beyond the current block) and conversion to µops. A software interrupt or supervisor call should probably do neither because most of the time, these instructions eventually return and continue executing the next instruction.

The leakage wouldn't be from training, but from other uses of Personal Data.

As far as I understand it, users can opt out from the training aspect, but they cannot stop their conversations (“User Content”) being used “[t]o improve and develop our Services and conduct research, for example to develop new features”.

If it actually exists, the protection would like go into the other direction: prevent playback of arbitrary MIDI files on the digital piano, instead of protecting the MIDI data against playback on other devices.

Public email and IRC archives/logs usually work just fine without Javascript.

ihtabs preserve iteration order and have performance competitive with swiss tables (while not requiring as high a load factor): https://github.com/vnmakarov/ihtab

As far as I understand it, the other efforts have not reported most of their findings to upstream developers, focusing on critical findings only.

This is understandable because upstream interactions at scale are difficult.

It's still beneficial on some x86-64 implementations to rewrite indirect jumps (as used in PLT stubs) to direct jumps when feasible. For example, AMD says this about the Zen 4 architecture:

> Only a limited number of indirect targets that cross a 64MB aligned boundary relative to the branch address can be tracked in the indirect target predictor. Software should limit the number of indirect branch targets that cross such a boundary.

And one way doing this is to replace the indirect branch with a direct branch, which supports a 32-bit signed displacement.

Why do you think these volunteers supported the attack? I don't think there's a published statement to the effect. Even the U.S. government does not claim that (at least not in its written communication).

The perpetrators very likely used Apple and Google services, too, and no one views that as some sort of endorsement by the companies.

> It doesn’t fully explain why Congress has allowed the expansion of executive power for nearly a century, resulting in more and more major issues being pushed to the Supreme Court.

It's not just about executive power. In recent times, Congress failed to adjust the written law when societal consensus shifted, and the discrepancy was resolved the courts, and ultimately the Supreme Court. I don't think Congress would pass something like the Civil Rights Act under the current circumstances. This isn't good for a democracy because the political debate that is part of the regular legislative process is lost.

The TUI version of Claude Code just isn't very good, though. The default keybindings do not work in the majority of terminals (because they generate the same byte sequences for key sequences assigned to different commands). Editing large prompts is rather painful because there doesn't seem to be in-prompt search commands. There is no source code browser, so source code references cannot checked by the users without a separate tool. Diffs cannot be copied directly because they are indented by spaces (even though some tools strip indentation from patches, it's still ugly). Switching between conversations is somewhat discouraged by the interface, which makes it harder to keep the context clean.

I think it's possible to have a better TUI, with something that isn't modeled after a shell prompt. Apparently, recent updates move in that direction. The GUI version of Claude Code seems to be coming to Linux, too.

These builtins of course exist, it's how compilers keep track of the behavior of these functions.

For GCC, there is -minline-all-stringops:

https://gcc.gnu.org/onlinedocs/gcc-16.2.0/gcc/x86-Options.ht...

It does what it says, but the results may not be what you expect.

Cases are infrequent, but not extremely unlikely. There's even a term for it, airport malaria:

https://www.eurosurveillance.org/content/10.2807/1560-7917.E...

Are you sure this is actually makes a difference in your build?

Mine doesn't have the SB-INTERPRETER package, so I doubt binding the variable has an effect.