fweimer

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?

Comment · 9 days ago

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.)

Comment · 10 days ago

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.

Comment · 11 days ago

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

(Obviously those are already pretty significant gaps.)

Comment · 1 month ago

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).

Comment · 1 month ago

Where in Italy would you put reactors?

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

Sardinia?

Comment · 1 month ago

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

Comment · 1 month ago

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.

Comment · 1 month ago

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.

Comment · 1 month ago

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.

Comment · 1 month ago

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