I assume you're some sort of programmer and I genuinely wonder how in the world can someone in good faith downplay non-determinism and ambiguity when talking about a programming language.
High-level languages can certainly yield inefficient code when compiled, or maybe different code among different compilers, but they're always meant to allow their users to know exactly what to expect from what they put together in their programs. I've always considered this a hard fact, I simply cannot wrap my head around working in a way that forces me to abandon this basic assumption.
> These models are alien intelligences that could occupy an unimaginably vast space of possibilities (there are trillions of weights inside them), but which have been RL-ed over and over until they more or less stay within familiar reasonable human lines.
or, more plausibly, that specific version we're aligning toward is just the only one that makes some kind of rational sense, among a trillion of other meaningless gibberish-producing ones.
Do not fall for the idea that if we're not able to comprehend something, it's because our brain is falling short on it. Most of the time, it's just that what we're looking at has no use/meaning in this world at all.
> that specific version we're aligning toward is just the only one that makes some kind of rational sense, among a trillion of other meaningless gibberish-producing ones.
Oh, the space of possibilities is unimaginably vaster than that. Trillions of weights. But more combinations of those weights than there are electrons in the universe. So I think we could equally well speculate (and that's what we're both doing here, of course!) that all these things are simultaneously true:
1) Most configurations of LLM weights are indeed gibberish-producers (I agree with you here)
2) Nonetheless there is a vast space of combinations of weights that exhibit "intelligent" properties but in a profoundly alien way. They can still solve Erdos problems, but they don't see the world like us at all.
3) RL tends to herd LLM weights towards less alien intelligence zones, but it's an unreliable tool. As we just saw, with the goblins.
As a thought experiment, imagine that an alien species (real organic aliens, let's say) with a completely different culture and relation to the universe had trained an LLM and sent it to us to load onto our GPUs. That LLM would still be just as "intelligent" as Opus 4.7 or GPT 5.5, able to do things like solve advanced mathematics problems if we phrased them in the aliens' language, but we would hardly understand it.
Just reading the name I wouldn't have been surprised if it had nothing to do with rockets whatsoever - I was half expecting it to be some kind of "agentic platform to accelerate your product development" etc.
Generative AI iterating on design is being done with satellites in production already (and given that there's limited scope for real world testing so you're solving complex optimization problems against a set of models, actually represents one of the better use cases for generative design). Don't think the foundation models and physics based constraints solvers involved look much like LLM "agents", mind you..
Since I've never used them, how could API keys for Firebase or Maps be safe for embedding in client side code?
I mean, I get that authentication to the service is performed via other means, but what's the use of the key then?
I'm guessing it's just a matter of binding service invocations to the GCP Project to be billed, by first making sure that the authenticated principal has rights on that project, in order to protect from exfiltration. That would still be a strange use case for what gets called an "API key".
> That would still be a strange use case for what gets called an "API key".
The problem that you, and many people are having in this thread, is that you are typing "API key" but, in your head, you're thinking "private API key". API keys can be secret or public, and many services have matching pairs of secret and public keys (Stripe, Chargify, etc. etc. etc.)
That is true, at least for laptops that came to market after the respective Debian release.
You can however get all stability of a released version with newer packages if you use stable+backports. This would give you a stable system, and allow you to upgrade selected packages to newer versions. This can be tedious, so running testing is also possible.
And well, overall, you can also install other distributions that are bleeding-edge (Arch based?). That's why I like about the distro ecosystem :)
If you want Arch that's easy to setup, and manage, try EndeavourOS. Its the first time I've tried Arch and stuck with it. I tried Manjaro but it was a nightmare for me, I had just installed it and ran an update command, and it broke everything. I think it was my lack of understanding Pacman. I have to wonder if people just break Arch mostly because of Pacman nuances.
Protip: don't use Pacman directly, just use 'yay' which comes with EndeavourOS. Yay is an interface to Pacman, now while it may sound silly, its totally worth its salt. I'm probably still on Endeavour because of yay.
In order to update your system just type 'yay' into a terminal and it does the work prompting you for confirmation.
If you want to install anything its as simple as 'yay packagename' and then it gives you options, including from the User repos (AUR) which are like Ubuntu's PPAs.
I spent probably 15 years on Debian / Ubuntu (though it mostly became Ubuntu even for servers, I got too used to Ubuntu over the years). I installed Arch this past year because I wanted more up to date packages, I didnt want bleeding edge, but it hasn't been so much bleeding so I'm okay with it. I update every few days, or when Discord decides to tell me to download the DEB package or it wont open.
It's not only that they're stupid, it's the fact that maybe they don't really need it.
Do they really need an iPhone? in a sense, yes, since the alternative still means spending a good amount of money and in no way they can do without a phone.
High-level languages can certainly yield inefficient code when compiled, or maybe different code among different compilers, but they're always meant to allow their users to know exactly what to expect from what they put together in their programs. I've always considered this a hard fact, I simply cannot wrap my head around working in a way that forces me to abandon this basic assumption.
reply