cztomsik

nothing indicated otherwise at the time. IMO he just underestimated RL-scaling. chinese models improved a lot too, they are not parrots anymore, there's some real intelligence, at 27B params.

consider me optimist now, but just few months ago, even frontier models were dumb, doing stupid mistakes all the time, all of them were so dumb I'd never expect anything to change in just few months.

there are good reasons, obviously, but it's my #1 PITA, #2 is comptime type introspection (it looks like @yara-blue is making some progress, so fingers crossed)

BTW: cheers, we should grab a beer some day :)

TIL this thing exists, haven't tried yet but I am seriously considering it. Orphan rule is something that made me switch to Zig, I am now back and so is orphan rule to get in my way :-/

BTW: It was already discussed many times in rustc repo, and it's clear that there's no serious downside for apps, but no action was taken. I am sharing this in a hope to make some peer pressure...

Zig had a breaking change half year ago and since then ZLS only works for std and local code, not for any deps. Zig is nice language but dev experience is a real nightmare at the moment. I say that as maintainer of three non-trivial libraries, and I have one Zig project in production.

That said, I've been re-evaluating my choices lately.

I think the point was that even Bash is interpreted.

Can't edit now but somehow I forgot to mention LISP/Clojure - I think it might be very interesting choice for LLMs because of the macro system and overall expresiveness.

Also, Clojure specifically is mem-safe because of the host VM and concurrency saf(ish) thanks to persistent data structures and core.async. It might be somewhere between 3 and 4, maybe together with Elixir. Unfortunately I never had enough time to play with it but I definitely will.

I will leave this prediction here and maybe come back in few years:

1. JS is mem-safe, single-threaded, and there are lots of training data. Easily my first choice. I'd put Python here as well, although I don't like it personally. Both should be used with "avoid external deps" in your AGENTS.md

2. Go might be a good second choice. Simple language, IMO good primitives for concurrency, well-designed std, therefore smaller potential for supply chain attacks.

3. Elixir/Erlang, little training data but rising. Safe language, safe concurrency, immutable, scalable, there are some many advantages... It has been avoided because it's different but that could change drastically in the age of LLMs.

4. Rust is probably next choice, along with C++, because while Rust is safer, the language is quite complex. C might be here too, there is a lot of training data, but every project is different and the language is very unsafe.

5. Zig, I really like the language, but it is terrible for LLMs, mainly because it's constantly changing, and the std is also under-featured and IMO weirdly designed. It's a fun language for hobby hacking, which I believe is not going anywhere, it's just not going to be something you will be payed for.

no, it's just clickbait.

- Rust is huge, many options, many programming styles

- typical Rust project has lots of transitive dependencies

- there is nothing in Rust that disallows using system libraries or linking to them

- it's not even true that the program is going to be mem-safe because there could still be unsafe {} either in the repo, or in any of the transitive deps. not to say that safety is broader than just mem-safety.

if you think "written in Rust" says anything, I'd argue that you might give it a try and find out yourself. I did that, and I am glad I am out. the reason why I am telling you is because I've been click-baited (into Rust) before, and it took me few years to realize all of this, and to make a move.

"single binary, no dependencies besides crypto" would be an advantage, "written in Rust" tells nothing, except (successfully) trying to clickbait

So is this the first AI lab using MUON for their frontier model?

I hope you are kidding, how is that a test of any capabilities? it's a miracle that any model can learn strawberry because it cannot see the actual characters and ALSO, it's likely misspelled a lot in the corpus. I've been playing with this model and I'm pleasantly surprised, it certainly knows a lot, quite a lot for 1.1G