"Winning the race" doesn't give you that in any meaningful capacity. It gives you, at the absolute most, a temporary window where that's the case. See: nuclear weapons.

This doesn't follow. The sense in which they are equivalent is that they are equifinal, which doesn't mean isomorphism or even homomorphism. It's a meaningful thing in theory, but not in reality. Otherwise, Turing tarpits wouldn't be a thing.

Every foundation occupies a unique region of proof space. Your foundation, and everything that goes into it, doesn't just affect the shape of what's accessible to you in native semantics, it also effects the way you move through this space. This means by changing foundation, not only can we prove things that we otherwise couldn't in theory (in native semantics), it also means we can prove things we otherwise couldn't in practice (what embedding other foundations as object languages doesn't get you). You can recognize a little bit of this in that it makes some things seem easy, but that's an extremely trivial case of what this relationship implies.

It's all just tools in a toolbelt. Treating them like immutable, universal truths is worth tolerating merely out of human limitation, because it's a lot of work to build intuition for a foundation. If we're talking about philosophy of mathematics though? No, it would be a mistake to pretend like choice isn't meaningful. It is extremely meaningful, and there's a lot to be gained out of realizing they're actually just highly specialized tools. Something to grab when it's useful, and throw away when it's not.

A relic from an era where commercial toolchains dominated. Tools for serious corpo Engineers born riding the coked-up excesses of... I think conglomerates were capital's darling at the time?

Beyond that, it's a trivial batching pattern. Any remotely competent systems engineer developing an agent would immediately reach for it, it's the most basic tool in the toolbox to deal with latency. If Mistral "invested a lot of money in discovering" this, man I'm in the wrong line of work.

Pay no heed to anyone saying anything different, regulators!

I find this to be a very strange thing to get defensive about. It's not exactly a subtle part of Elixir's history. It was pretty well documented to be born out of the creator's dissatisfaction with concurrency in Ruby, and simultaneously, for a more Ruby-like language on the BEAM. That doesn't mean it's literally Ruby-on-the-BEAM (which was originally attempted, and didn't work out), however mistaking that as cause to dismiss the link between the two and the carry-over appeal for developers is an unsound overcorrection.

You don't necessarily need to give up TCO to do that though. You just do some bookkeeping and synthesize virtual stack frames. DWARF has native facilities to handle this.

CL goes the route it does mostly out of history, which includes the fact it has its own debugging ecosystem, more than any fundamental technical reason. There are technical hurdles with doing this in an image-based dynamic compilation model, but it's very far from intractable. Especially if you just do what GHC did and add a DWARF workflow. Most CL users wouldn't ever touch it though, because that's a drastically different debugging model that costs them a lot of ergonomic power, which may even be the reason they're working in CL to begin with.

Not quite. I'd agree with you if you try to do code generation in one-shot, but the agentic loop importantly isn't that. Natural testing at-scale is automated as well.

> but don’t be fooled into thinking anyone can, or should with every side project.

You're right, and I hoped I had conveyed that but I guess I didn't. I'm very bearish on whether or not we're democratizing anything. What I do think is we have a very complicated and interesting tool, and within a reasonable precondition of additional scaling and structural innovation, one that promises a certain kind of person the ability to swing with the weight of an entire institution.

I have been playing around with transformers for 7 years now, and can see and qualify the improvements observationally. Innovations like thinking blocks, the agentic loop, the many architectural refinements flourishing, SAEs, steering vectors, harnesses, etc. Despite what it sounds like, I've yet to incorporate LLMs into any of my professional workflows, they're really not quite up to my standards yet. But then, in my industry I would never in a million years touch anything like SQLite either. Those kinds of things are very taboo for anything but like an internet service and that's more the kind of operations drek that gets shoved off to the IT department. All of this colors my perspective. I was never pulling in dependencies. In the future, it's looking like I'll have infinitely less reason to.

With 5 active sessions going nonstop? That seems like a pretty important qualifier.

This isn't anything new or particularly interesting. It's the entire basis upon which ILP demonstrated generality. A metatheory to synthesize 10 trillion rules isn't even scratching the surface of what you can reasonably do. The key was finding out the tractable semantics for actually computing it in reasonable amount of time, which right now is looking decidedly like informal semantics was the answer the whole time.

That's before we get into the entire non-linearity of agentic systems introducing massive decidability problems on this in the first place. A little bit of epistemic humility please.

Even SaaS isn't safe. I don't even have to describe your product to my system, I just have to give it a harness with access to the interface and have it replicate it locally. Frankly you can probably already prompt for that.

The only thing holding this future back right now are pricing problems and code generation quality. Both of those barriers are constantly being knocked down. We might never arrive at that future, but it's definitely a higher probability than solving AGI's scaling issues, and would arrive much sooner for technical users.

You can argue there's a selection bias that openrouter users are less likely to display model loyalty, but it would still be a visible confounding factor if it was a statistically significant behavior. And it's not. Nor is there a visibly meaningful indication that people don't sidegrade between models. With every single data set, you're going to see that. You're also going to see it reflected in discourse, as I mentioned. Fact of the matter is there isn't a status quo in AI any more than there's a status quo in cars.