It's faster to have it in the runtime in native code.

You have more options, not less, you can still use the external dependencies.

Closed source :(

https://acadia.engineering/license/faq (archive since these things change over time: https://archive.vn/oUwxDwxD)

Closed source :(

https://acadia.engineering/license/faq (archive since these things change over time: https://archive.vn/oUwxDwxD)

Why haven't we all moved off GitHub yet?

Or let me ask a more useful question: if we were to move, then to where? Ideally somewhere new (not Gitlab)

Ideally something like IPNS to have a mutable ref based on (repo, pubkey, branch) to resolve a commit hash, a DHT for who has what commit hashes, and then just p2p transfers. You could still have a github or gitlab for issues and CI, but code (and maybe issues) could all be p2p like git is already designed for. Your forge could also act as a peer for code cloning, of course.

I do not need it to be meaningfully different than Github, it sounds like that introduces additional complexity. I just want Github that works.

The complexity is in locating what is already a distributed database item (git is fundamentally already designed that way), just using a protocol meant for that. Basically just support `git clone` with e.g. IPFS URIs.

I think the clear reason is even with their unreliability, the cost of migrating off of GitHub for _most_ places is not worth it, and so companies don't / won't (yet)

This bugs me so much. Management decides what is reasonable cost of service and the employees have to deal with all bullshit coming from that product. And you can't really escape it. Maybe the real moat was enterprise deals we made along the way.

Could be - I’d also argue the time cost to the engineers to switch is pretty significant too, regardless of the monetary cost

For us the uptime issues have been annoying but not consequential enough to justify the work / risk of moving.

I suspect even poor uptime for many services is a cosmetic problem for most users.

Its hard to get lemmings to change course.

They're one rewrite in Rust away from fixing everything. (jk)

Just how badly are these AI companies setting up their sandboxes?

Clearly AIs are incapable of writing secure code. Shouldn't that be first thing they use them for? Making a secure sandbox with no mistakes.

I've seen Claude Code examine the windows Event View logs and configure its own firewall rules. That was last week. Who knows what's next week.

edit: though honestly it really did take it long enough to figure out how to use PowerShell.

The company I work for just did a huge and expensive study that was showing LLMs are much better at exploiting than securing code. So ya, that's kind of problematic.

they say the model(s) found and exploited a zero day

Last stage is moving everyone to their cloud platforms, they deploy everything for you, you don't even get to see the code, just the deployed end product.

Because letting you look at the code would be too dangerous, you could reverse engineer an exploit to another product! Or distill their internet-distilled model!

But don't worry, at least it will be very convenient.

no, last stage is removing you completely from the equation

It's not complex actually, but it is C...

> There is no concept of "knowledge" in LLM as it is on Wikipedia.

There can be, you don't know if the closed source models aren't using something like DeepSeek's Engram.

The name "Engram" (n-gram) says it all - this is just another type of statistical word association, not a factual knowledge store.

While DeepSeek describe this as "knowledge lookup", what Engram is really trying to do is separate dynamic reasoning from static pattern recall, with the static patterns just being word-level n-gram statistics, not declarative facts/knowledge.

Just because 2-3 words often appear together in a sequence doesn't mean they represent a fact or truth (or falsehood) - it is just an n-gram statistical regularity.

If Engram helps reduce LLM GPU memory and FLOP requirements then that is great, but it's not a solution for Hallucination.

IMO, there isn't much space left to fill that Rust couldn't already fill.

Simplicity is one thing Zig excels at (at least from my early observations).

Yup. Rust tries to make it hard to do systems programming poorly. Zig tries to make it easy to do systems programming well. Rust pushes you into certain (good) practices. Zig makes it exceptionally easy to understand what's happening, making good practices the obvious choice.

Haven't yet used Zig in anger, but it looks more like a successor to C (with a bit of Go), whereas Rust is a successor to C++, first and foremost.

How crazy is it to have a language where combining two foundation traits is such a huge footgun that the linter has to warn you (but somehow you can't ban it within the language)