dinosaurdynasty

Package size is unique enough that just seeing the size of the transfer will usually be enough to tell.

from the OP

APT can use HTTPS, but often doesn't, making a MITM attack easier (also the idea for a long time has been signatures are enough, and/or TLS certs used to be a lot harder to get, but at this point you should really be using both).

There is no way to, for instance, only allow updates to a PWA from files signed by an offline key.

If I search for battery stuff shows up, but they only ship bare batteries to the 48 states and Canada.

Contacting support should be able to help you too.

Cache-control immutable the code and assets of the app and it will only be reloaded on changes. Offline-first and/or stale-while-revalidate approaches (as in the React swr library) can hugely help with interactivity while (as quickly as possible) updating in the background things that have changed and can be synced. (A service worker can even update the app in the background so it's usable while being updated.) HTTP3/QUIC solves the "many small requests" and especially the "head of line blocking" problems of earlier protocols (though only good app/API design can prevent waterfalls). The client can automatically redo bad connections/requests as needed. Once the app is loaded (you can still use code splitting), the API requests will be much smaller than redownloading the page over and over again

Of course this requires a lot of effort in non-trivial cases, and most don't even know how to do it/that it is possible to do.

But I'm forced to write in Go which has a lot of boilerplate (and no, some kind of code library or whatever would not help... it's just easier to type at that point).

It's great because it helps with stuff that's too much of a hassle to talk to the AI for (just quicker to type).

I also read very fast so one line suggestions are just instant anyway (like non AI autocomplete), and longer ones I can see if it's close enough to what I was going to type anyway. And eventually it gets to the point where you just kinda know what it's going to do.

Not an amazing boost, but it does let me be lazy writing log messages and for loops and such. I think you do need to read it much faster than you can write it to be helpful though.

(This is a big advantage of open weight models; even if they're too big to host yourself, if it's worth anything there's a lot of competition for inference)

Also barely anyone can actually run the real R1 locally.

If they aren't lying because they have hardware they're not supposed to have, which is also a possibility.

Also port forwarding in Docker (and Podman!) still bypasses ufw/other firewalls, which is really annoying and surprising (though it doesn't in rootless).

They are expensive though...

Much harder to create bad/poisoned data if the DB has a constraint on it (primary, foreign, check, etc) than if you have to remember it in your application (and unless you know what serializable transactions are, you are likely doing it wrong).

Also you can't do indexes outside of the DB (well, you can try).

Not that the leaderboard isn't useful, I think "is in the top 10" says a lot more than the exact position in the top 10.