HN user
Yeah that's pretty much what gwern argues here[0]. Or to adapt another proverb: to predict the next token you first need to model the universe.
[0] https://gwern.net/scaling-hypothesis#gwern-difference--effic...
That argument says very little, emergent behavior is a thing in complex systems with billions of parts. Humans can also be reduced to voltage potentials propagating along of tubes of fat and synapses getting rewired.
Many of those assumptions are standards such as the filesystem hierarchy (granted, that's an xkcd 927 situation), nix is a bit of a special snowflake that breaks things in subtle ways (e.g. [0][1]) and needs workarounds in various places. Those workarounds are not necessarily onerous, but they would be unnecessary if it didn't deviate.
[0] https://github.com/NixOS/nixpkgs/issues/420513 [1] https://github.com/NixOS/nixpkgs/issues/94228
Those are humidifiers at best, the amount of CO2 they extract is negligible during the day and it goes negative during the night, they need to breathe too.
ACLs aren't even the issue here, first you need an entity separate from "the current user" to grant that access to. That's what jails, sandboxes or capability-based systems bring to the table. But you have to use them, most of those AI tools and their IDE integrations don't. Once you have those you can think about which access to grant that entity.
even if you explicitly set up permissions for read tools.
Part of problem is that "permissions" here are managed by the tools themselves as if filesystem access control hasn't been invented yet. Even a half-assed sandbox container would be better than that.
s3fs doesn't provide posix semantics. It's good enough™ for some uses, but not comparable to what this one is ostensibly providing.
Think of the models making progress on CIFAR-10, ImageNet, CelebA, etc. 15 years ago. They had issues too and weren't just scaled-up as is to the architectures we have today.
OIDC can be relatively straight-forward (that is just a few JSON REST calls) if the provider isn't configured in a restrictive way. The .well-known/openid-configuration endpoint is quite helpful. Exchanging username+password (optionally with OTP) for a token is an option in the standard. The issue is that lots of deployments are quite restrictive "for security".
Depending on how the system distributes work such users can interfere with random with requests from other users through shared resources, so to that cohort these will look like a random latency distribution.
Crawling has been somewhat simplified with BEP 51
If your frontend fires hundreds of requests (which isn't uncommon) then the p99 is merely what most users will experience. Ideally you want cumulative distribution chart that goes up to the max. And then that's just for the requests you measure. If something takes too long the user might do something that cancels the requests which means the backend never completes its response and won't get the time-to-response sample, so you need to account dropped requests too.
A different framing would be things moving from a high-trust equilibrium to a low-trust one due to a few bad actors and no other way to stop their activities.
Security part reasonable code robustness, part Red Queen's race. Attackers expend ongoing effort for new exploits, defenders expend ongoing effort to get back into a secure place, everyone ending up where they started.
If world were a nicer place we wouldn't have to "fix that shortly".
If you have add a "easily releasable" clause then the game companies could just do something that makes it not-so, e.g. a shell company that owns the code and they only "licence" it without permission to release it or whatever would fly under that law.
For me opening huge datasets, e.g. many gigabytes worth of profiling data, combined with other stuff running on the system, can end up pushing things to swap.
linux has P2P-DMA for this. The drivers, devices and bus topology need to support it though.
Humans come vaguely prealigned due to whatever is encoded in genes and also due to limitations of human bodies that put important constraints on individuals (e.g. no infinitely copyable trusted subagents). Even if you made them superhuman in some aspects a lot of that would still remain. It seems unlikely that minds constructed by a different process would end up humanlike because they lack the evolutionary path-dependencies that shaped humans. Current models appear somewhat human due to imitation learning/pretraining, but A) this could be deceptive as we don't know what's going on inside B) history has shown that that imitation learning becomes unnecessary once RL becomes good enough (e.g. AlphaGo -> AlphaZero), meaning we might end up with minds created from random initialization.
But they're gaining more and more formerly exclusively human capabilities, increasingly advanced ones. The future isn't here yet, but good policy requires extrapolating and considering predictable consequences before they happen.
I guess top mathematicians are also mere word generators?
https://openai.com/index/model-disproves-discrete-geometry-c...
./deploy.sh
Giving up on robustness is capitulation on a social-technical interface. "users can't be trusted, we can't have any fallbacks, ever" is a problem that needs to be solved.
The equivalent bar in this domain would be human intelligence, and we already have growing lists of tasks where machines outperform humans. We even known of natural systems that outperform humans on some metrics, e.g. bird-brains have higher neuron density than ours because evolution had to optimize more for weight.
Some of the paranoia has been proven correct. For example both Intel and AMD had RDRAND bugs so not relying on it as sole source was the correct choice.
it's both, futex_waitv can also be dispatched via io_uring so you can wait on file descriptors and futexes simultaneously.
ability to make some filesystems case-insensitive was also added for wine
https://www.collabora.com/news-and-blog/blog/2020/08/27/usin...
For gaming and desktop use AMD is great, though for raytracing you'll need newer cards. If you want to run local AI models too then AMD is quite shaky, rocm only supports a few cards with each version and their software stack just isn't as polished as nvidia's.
I don't know if YT can, but browsers do handle variable-AR videos.
Latest has no known security flaws.
There are plenty of AIs that are immune to this because they're trained on something that won't be flooded with slop. E.g. robotics, self-driving cars (both trained on real camera/sensor inputs) or programming/proof-assistant stuff (trained on things that are verifiable).