edflsafoiewq

Static-assert the machine is little endian.

That's a serialization format.

Perhaps these two roles shouldn't be conflated into a single position?

Here is the article's text, extracted from the .js source: https://pastebin.com/5uguB0bs

Examples?

What about page size?

What makes you think this is going to stave off that world? More likely you'll get both, since I doubt this API is going to satisfy other states' age verification requirements.

Of course. Arch for example ships packages that use a shared system electron. But you'll often end up need multiple electron versions.

There's also stuff like lorca which shells out to an installed Chromium browser.

You also need the group structure, ie. a(bG) = b(aG) = (ab)G.

But AFAICT, elliptic curve groups really are the best known groups where DH is hard. The "Why curves win" section talks about it terms of key size, but the reason other groups require larger keys is they have some kind of structure which can be exploited to attack the "hard" direction (eg. in a finite field, the ability to factor over primes can be used to solve discrete logs), so the group size has to go up to compensate.

Such as?

O(1) just means "a bounded function (on a neighborhood of infinity)". Unlike f(x), which refers to some function by name, O(1) refers to some function by a property it has. It's the same principle at work in "even + odd = odd".

Programmers wringing their hands over the meaning of f(x)=O(g(x)) never seem to have manipulated any expression more complex than f(x)=O(g(x)).

My immediate thought was combining characters eg

  934 = CISTERCIAN STAFF + 
        COMBINING CISTERCIAN 900 +
        COMBINING CISTERCIAN 30 +
        COMBINING CISTERCIAN 4

Would require allocating (1 staff) + (9 digits) * (4 places) = 37 code points.

Were you thinking

  934 = CISTERCIAN 900 +
        ZWJ + 
        CISTERCIAN 30 +
        ZWJ +
        CISTERCIAN 4

?

Oh, ding ding! Opening in a hex editor, there's the string "Added imperceptible SynthID watermark" in an iTXt chunk. SynthID is apparently a watermark Google attaches to its AI-generated content. This is almost certainly the noise.

What is that noise actually? It's clearly not JPEG artifacts. Is it dithering from converting from a higher bitdepth source? There do appear to be very subtle gradients.

I believe the main interest in recompilation is in using the recompiled source code as a base for modifications.

Otherwise, yeah, a normal emulator JIT basically points a recompiler at each jump target encountered at runtime, which avoids the static analysis problem. AFAIK translating small basic blocks and not the largest reachable set is actually desirable since you want frequent "stopping points" to support pausing, evaluating interrupts, save states, that kind of stuff, which you'd normally lose with a static recompiler.

You can download a precompiled yay/paru from their Github pages btw.

I've never used perl. What's the difference?

AFAIK browsers do not reuse any VP8 codepath for WebP, they just use libwebp, which decodes lossy images in software. WebP has a non-VP8 lossless mode too. The concern about image format attack surface is also probably because of the recent exploit in libwebp.

Just call it JXL.

That is typical in most languages, but Haskell's Data.Array is actually parametric over both the index type and the element type, with the index type required to provide a mapping to contiguous integers. This makes it similar to eg. a hashmap which is parametric over both key and element types, with the key type required to provide hashing.

May be interested in https://floooh.github.io/2018/06/17/handles-vs-pointers.html

You might use placement new though.

The hard parts are things like deploying artifacts, publishing releases, caching, etc. that are CI-specific and can't be run locally.

Link: https://arxiv.org/abs/2512.24880

Here's the relevant diff: https://github.com/python/cpython/pull/137968/files#diff-966...

Search is limited to 20 attributes and non-descriptors only to avoid arbitrary code execution.

I assume constructing AttributeErrors isn't highly performance sensitive.

Can definitely think of some places I should use bytearray.take_bytes.

Can screen readers emit their narration as text instead of / in addition to audio?

The error from Rust's File::create basically only contains the errno result. So it's eg. "permission denied" vs "failed to create file: permission denied".

Python's

    f = open('foo.txt', 'w')

is even more succinct, and the exception thrown on failure will not only contain the reason, but the filename and the whole backtrace to the line where the error occurred.

Marginal gains over AVIF.

(Also I am highly skeptical of the importance of these generation loss tests.)