I'm not an expert here but I have to say this feels like a very weak objection.
p points to P1. One thread reads through p. Another thread races with that and mutates p to point to P2. The result is the first thread reads from either P1 or P2 (but no other object).
This seems totally fine and expected to me? If there's a data race on a pointer, you might read one or the other values, but not garbage and not out of bounds. I mean, if it could guarantee a panic that's nice, but that's a bonus, not required for safety.
The inelegance to me isn't in the definition of the operation, but that it's doing a huge amount of brute-force work to mix every part of the input with every other part, when the answer really only depends on a tiny fraction of the input. If we somehow "just knew" what parts to look at, we could get the answer much more efficiently.
Of course that doesn't really make any sense at the matrix level. And (from what I understand) techniques like MoE move in that direction. So the criticism doesn't really make sense anymore, except in that brains are still much much more efficient than LLMs so we know that we could do better.
The problem is that "should" is papered over a system not designed that way from the start, and in a heterogeneous world which operates in its own way, not Nix's way.
So it's just an eternal battle between the real world and the fantasy Nix world, built on an army of thousands of volunteers writing up .nix files and contributing packages, and trying to tame the beast of Unix complexity.
Except most of us are just trying to get things done and now I work in a shop where I can't even run a development setup with my favoured IDE, or just "cargo run" my package, because Nix has been placed in the middle of everything.
Clearly in a sincere effort to tame complexity, but in the process creating a whole new world of it, with a lot of normative lifestyle assumptions.
To me... in my experience... Nix promises a lot more than it can realistically deliver, comes with a totalizing world view, and in practice ends up making life more complicated unless you completely and totally buy into its way of doing everything, and are willing to leave many of your old tools and practices behind.
The right way to tame complexity is not that much of a hassle. This is why virtualization and containers have been so successful. Make the OS immutable by converting into a nested Russian doll of OSes with specific instances being mutable but also disposable.
It’s ugly in its own way but it has the virtue of not exchanging one ugly complexity tax (OS rot and manual admin) with another (a complicated “manager” that wants to get in the way).
I kind of dig the idea of a unikernel world where there's just a hypervisor and applications running directly on top of it shipping only the bits of the OS they need.
Lazy build sounds tricky: you don't know the contents of the package before you build it, so you don't even know what to symlink into /run/current-system/sw. I guess you'd have to have some kind of wrapper. Maybe similar to comma.
I just solved that part by setting up CI for most of my system config (integrated with the above).
Temporal can also run on Cassandra, which scales much larger than Postgres (if you put in enough effort). It can also be replicated across regions for high availability. It's already running some pretty huge use cases.
You're looking at the docs for "visibility". Visibility is a separate eventually-consistent data store off to the side that's used for certain queries so it can be scaled independently of the main data store, and indexed in fancier ways. The main data store for all the stateful and transactional stuff has always, and probably will always, support Cassandra. For visibility, the recommendation for high scalability is currently Elasticsearch.
Temporal may have properties that make it not a good fit for a particular use case, but scalability is really not one.
I'm also using NixOS and working on Go projects, and had to deal with out-of-date Go releases. Nixpkgs generally does get the latest Go versions pretty quickly, but only in the unstable channels, they're not backported to NixOS releases. You can just grab that one package out of nixpkgs-unstable or nixos-unstable, like:
It wasn't quite immediately, it would take a few hours to detect+revert. And that was only the root fs, there were other places to hide things if you really wanted. But then there were other detection systems too. (Probably fairly different now, I left in '11 too)
The idea that the capabilities of LLMs might not exceed humans by that much isn't that crazy: the ground truth they're trained on is still human-written text. Of course there are techniques to try to go past that but it's not clear how it will work yet.
> The idea that the capabilities of LLMs might not exceed humans by that much isn't that crazy: the ground truth they're trained on is still human-written text.
This is a non sequitur.
Even if the premise were meaningful (they're trained on human-written text), humans themselves aren't "trained on human-written texts", so the two things aren't comparable. If they aren't comparable, I'm not sure why the fact that they are trained on "human-written texts" is a limiting factor. Perhaps because they are trained on those instead of what human babies are trained on, that might make them more intelligent, not less. Humans end up the lesser intelligence because they are trained less perfectly on "human-written texts".
Besides which, no one with any sense is expecting that even the most advanced LLM possible becomes an AGI by itself, but only when coupled with some other mechanism that is either at this point uninvented or invented-but-currently-overlooked. In such a scenario, the LLM's most likely utility is in communicating with humans (to manipulate, if we're talking about a malevolent one).
Get a fresh cap! The caps only last about a year of heavy use. You can find replacements on amazon and elsewhere. It doesn't even matter if it's really oem, a fresh third party one will still be much better than a worn oem one.
p points to P1. One thread reads through p. Another thread races with that and mutates p to point to P2. The result is the first thread reads from either P1 or P2 (but no other object).
This seems totally fine and expected to me? If there's a data race on a pointer, you might read one or the other values, but not garbage and not out of bounds. I mean, if it could guarantee a panic that's nice, but that's a bonus, not required for safety.