I haven't looked up the history, but I would imagine that the "XL" is for the fact that it can handle images up to 1B x 1B pixels (1 exapixel).

Chrome just added it a couple days ago. I guess that must mean an upstream library was finally deemed production ready. Also presumably MS Edge will get it within the next few days downstream of chromium.

Both lossy and lossless, and so much more.

It's this.

And on the compression side, there's a lot of really cool stuff that lets it happen. For example, it dynamically resizes the blocks from 2x2 to 256x256, and they don't even have to be square. It may apply DCT in one, AFAS in another, etc - whatever is most efficient. It uses edge preserving filters to keep the edges of features clean. It can draw in splines and clone regions from one part of an image to another. Where it has to throw away high frequency noise (film grain, noisy textures, etc), it statistically samples the properties of the noise and saves that, and then regenerates equivalent noise. In "busy" areas, like say tree bark or whatnot (where the human eye isn't good at discerning changes), it throws away more precision there, and instead allocates it to details located in fragile flat areas, such as skin and shadows, that the eye is attracted to. It works in default in XYB colour space, based on the actual interactions of the cones in the eye, so it can aggressively quantize things which the brain cannot detect. And in the choice between fast but not-great Huffman coding vs. better but slow and patent-encumbered arithmetic coding, they instead use rANS, which is nearly as fast as Huffman but as efficient as arithmetic coding, and faces no patent challenges. Which is also why you can take a legacy JPEG and rapidly losslessly reincode as JPEG-XL and get a file that's ~20% smaller - you're swapping Huffman for rANS.

(That's the lossy mode - there's also a dedicated lossless mode)

Why even ask someone whose business is hurting people with desperately banal web tech how risky he thinks his new product is?

Their servers go down because they DDOS themselves demanding more cert renewals than they can support. The blog certificates expire and browsers refuse to load your cat memes.

If you're not shipping code with AI faster than ever, it's 100% a skill and/or organizational problem.

In fact, it might be the organizations themselves which are the problem. Plenty of solo devs are doing amazing work with AI.

Have they found a solution to the problem where a rouge CA (e.g. one controlled by a bad actor nation-state) can generate a bogus certificate for a major site and use that to man-in-the-middle traffic to that site?

Oh and no matter which side of politics you support, anyone who wants elections in the US to be free, fair and democratic should be opposed to foreign governments and entities using social media bots to influence the outcome of those elections.

This is a good thing for the US since it seems that these data centers hosted bot farms spreading all kinds of lies in an attempt to influence the upcoming US elections.

Though already CI/CD pipelines were choking on the unit tests. So they aren't *free*.

Had an LLM generated request that was pretty straightforward, and the LLM generated 272 unit tests for a very simple function. Can't really afford that.

Also, despite the 272 unit tests, when I tried to try it out in the way a human would, it immediately failed. All the mocking the AI generated never actually properly imitated the real world. However, the submitter was *quite* proud of having hundreds of unit tests, despite them being, in this scenario, utterly worthless.

Like always, more code != more valuable software behavior.

So you have the AI doing overtly silly things. Someone asked to adjust layout to fix a gap in a webpage. Eventually they submitted their pull request, hundreds and hundreds of lines of CSS. Often the exact same rule repeated 5 times, which I'm guessing is how many rounds the operator went with the system before the gap actually closed. The lines were *mostly* just '!important'ing already existing rules, which had no impact, but hey, worth a shot right? Ultimately I discarded the merge request and made the one-line css tweak that was actually relevant.

Then you have the AI doing... well arguably slightly silly things. Like protecting against an invalid value redundantly throughout a call stack. Arguably defensible, as maybe one day the deep function will be called from somewhere else and passing through the error might not present it with the most informative context.

Finally the AI doing... well things the human should have been doing. With the advent of a lot of code scanning, this is less likely, but things like calling functions in C and charging ahead without ever checking the status of the call. functions that, practically speaking, will likely never fail, however you really *should* be being more defensive about the possibility.

The 'human review as a bottleneck' isn't really the angle I would fixate on. Completely unfettered AI usage also stalls out in many situations. If the AI can't get there on its own trivially, then it's going to leave an almost-correct looking mess that isn't quite there but is very hard to get across the finish line. If the AI can get it, then it's probably not 'software being shipped', because while perhaps slightly better than a generic off-the-shelf existing procedure, probably not worth the trouble to 'ship' a solution that largely overlaps with a lot of generic stuff.

Also it less liability to merely cover them. Flock cannot claim that their tech was "damaged" during the removal by the college if they were not removed.

Everyone knows that pretty much by definition volumes are low, that's the whole definition of a shortage.

The vendors may still be happy, perhaps even happier if the sky high prices produce at least as much revenue at high margin.

Ahem