Also, you can have NixOS instead of debian: https://github.com/nix-community/nixos-avf

Wouldn't it make sense to have these wikipedias created by different llms, and compare them to expose their biases?

It's not only the amount of code but also the quality of the available code. If a language has a low barrier to entry (e.g. python, javascript), there will be a lot of beginner code. If a language has good static analysis and type checking, the available code is free of certain error classes (e.g. Rust, Scala, Haskell).

I see that difference in llm generated code when switching languages. Generated rust code has a much higher quality than python code for example.

I fully agree with this approach! 5 years ago I built a prototype to execute that same concept of language covering. But instead of just using words, I used n-grams. It ii trained on subtitles to model spoken language. Combined with sqlite in the browser to get the next sentence with the most impact.

github here: https://github.com/fdietze/ravioli

prototype deployed here: https://raviolio.web.app/

I think memory safety is a weak argument for rust and only works against C/C++, as you mention. For me, the strongest arguments against GCed languages are static analysis goodies that other languages don't have. Like checked immutably by the compiler, the borrow checker which forces you into a certain architecture, fearless concurrency etc. All those lead to fearless refactoring, which is a very strong point for me.

This pre-AI article makes a very similar argument: https://mortoray.com/programming-wont-be-automated-or-it-alr...

Once we realize that what we actually want is turning specifications into software, I think that English will become the base for a new, high level specification language.

We are turning specifications into software precisely because English (and any natural languages) lacks the formality that makes it not reliable (necessary quality for a tool), but great for imagination (the source of invention).

We always start from natural language. RFC, docs, tickets,... are in natural language. But gaining formality (losing ambiguity) is what programming is (software engineering is doing programming well). People that struggled with programming struggle in fact with formality.

Search for "bridging based ranking". The X community notes algorithm does that. I think it should be applied to all content.

Sounds like type-classes from haskell/scala? Or is that a different thing?

I'm not familiar with Haskell so it's hard for me to say. A cursory look at the wiki.. I get the impression you'd need to explicitly create a new type class? In a dynamic language you can just "dynamically" extend the record (which is sort of like a "class) with new interfaces without making a new class type.

Hopefully that helps.. Sorry if it's not exactly helpful

The protocol example at the end shows how it's done

https://eli.thegreenplace.net/2016/the-expression-problem-an...

If you write something like

    (extend-type BinaryPlus
      Evaluatable
        (evaluate [this] (+ (evaluate (:lhs this)) (evaluate (:rhs this)))))

Then you are adding (and defining) the Evaluatable interface to a record BinaryPlus (which can be coming from a different library and already be implementing other interfaces)

BinaryPlus records can still be used where they were used previously, but you can also use them with the enhancement you added

Clojure's protocols are basically the dynamic language equivalent of type classes.

> I get the impression you'd need to explicitly create a new type class?

In the same way you need to use defprotocol in Clojure. You can implement existing type classes on types without defining a new type class.

Yep pretty much. It’s “open world” polymorphism.

Similar simplicity but in rust: https://github.com/fdietze/alors

Really nice, thanks for sharing!

I'm also in the process of creating a general purpose agent cli+library in rust: https://github.com/fdietze/alors

Still work in progress, but I'm already using it to code itself. Feedback welcome.