Chu4eeno

No, that's not how anything works.

You can finetune an LLM to a new tokenizer by nudging just a few layers (even wildly different kinds of tokens), and there's nothing stopping a lab from using someone else's tokenizer.

Something seems to 404:

    GET https://rorz.io/_next/static/chunks/link-CKkD60iF.js 404
    Loading module from “https://rorz.io/_next/static/chunks/link-CKkD60iF.js” was blocked because of a disallowed MIME type (“text/html”).
    TypeError: error loading dynamically imported module: https://rorz.io/_next/static/chunks/link-CKkD60iF.js index-ConxhaY_.js:2:49967
    The above error occurred in a React component:
    Lazy@unknown:0:0
    div@unknown:0:0
    div@unknown:0:0
    div@unknown:0:0
    body@unknown:0:0
    html@unknown:0:0
    Eo@https://rorz.io/_next/static/chunks/vinext-B9_QPQZC.js:32:16818
    [...]

Don't mind the web designers calling themselves engineers.

There's a lot of annoying issues with Python, but compared to the billions of dollars and thousands of man hours that has been spent trying to fix Javascript and how horrible it still is, it's a perfectly cromulent language.

Probably that british professor who killed himself after getting exposed for fraud.

Yes, it was invented by an anonymous user on 4chan in the early 2020s, then sanitized by a Google paper some years later as CoT (chain of thought) or thinking tags, where the model iterates on its own before writing a final response.

All models do it now.

No, they are correct, residential proxies behind a big ISP's CGNAT is much more valuable for miscreants because you can't block the individual who installed a free android flashlight with a residential proxy SDK embedded.

But the overall latency will be longer than expected because you add the latency from the proxy connection as well. If you're able to ping back to the connecting IP in combination with some clientside js to help measure total latency I think you should be able to reliably detect proxy users in general?

Arch actually has testing repos (and has had for as long as I can remember), plus other project-specific testing repos like kde-unstable when upstream is taking a very long time to push out a new actually stable release. It also has lts packages for projects that offer those (like the kernel), and sometimes stays on old versions and backports fixes if the upstream definition of stable is too out of whack.

People seem to believe arch is much more yolo than it actually is (though forks of arch have tended to be pretty yolo, and I assume cachyos is a bit yolo as well based on the issues people have).

It has to be a pain, everything depends on them (or rather, should, you still have holdouts like go fucking up things like NSS, holding back posix_spawn etc.).

In their defense the people working on glibc and gcc are pretty intelligent and spend a lot of time thinking about how everything they do affects their users, though they make mistakes like all humans (and LLMs I should say by now).

Last I tried that (because everyone claimed it was magically better at everything) sound just randomly broke (I had no idea why, debugging pipewire is a nightmare), and since I switched back to pulseaudio everything just works again (and seems to use less CPU, but that could be selective memory).

Maybe I'm just old and grumpy, but we spent decades hammering out all the incorrect (for pulseaudio) assumptions in every layer of the stack and papered over impedance mismatches, and then people decide to rewrite from scratch again (though I'll admit I was a vocal pro-dmix anti-pulseaudio hater for a long time).

Norway seems like an obvious counter example? If the unions and state grow enough power before resources start to get extracted it seems like they can keep the curse in check.

It has also been protecting politics from capital in various ways; public funding of political parties, strict bans on various forms of political adverts, forced disclosure laws, essentially forcing capital into a single visible chair (NHO), etc.

OWS showed that you don't even need drones and robots.

Try looking at the SVG code for one of those converted from bitmaps, and I think you'll understand why even a massive LLM has trouble generating it on the fly (the pelican SVGs are always one-shot single API calls, so no iterations and verifications).