I did so! (quirks of the path I took in the French educational system)
I went through a book similar to the one above, with no internet connection. The first few weeks were rough: I did not quite know what a type was and the compiler error messages were unforgiving and hard to understand without that context.
But, once I grokked the core ideas (a proper idea of what could be done with recursion took much longer), things went surprisingly smooth. I definitely credit it with making me a better programmer.
I started programming at 18 right after highschool (which, I guess, is late by HN standards: a number of my peers had played with Python first and hated Ocaml).
> For example there is less joy to be had in learning a programming language in 2026 than there was in 2016, because there is less utility in it now.
I... disagree. The joy I get from learning a programming language does not come from knowing that it is useful. Rather, it comes from engaging with its abstractions and figuring out the associated mental puzzles.
On a related note, I recently realized that I am barely writing code these days (instead I am reviewing a lot of LLM-written code and nudging it in the right direction) which will make doing the advent of code (which I usually use to play with a language I have never used) without any LLM help even more enjoyable: it will be both the fun of figuring out those puzzles in a new language, and stretching my code-writing muscles.
> I... disagree. The joy I get from learning a programming language does not come from knowing that it is useful. Rather, it comes from engaging with its abstractions and figuring out the associated mental puzzles.
Fact is though, a LOT of people derive joy from showing their creations to other people and others finding utility or awe in it because they created it with their hands. The fact that a few of us can sidestep that does not mean it's a general phenomenon.
Please try to interpret comments in the context of the discussion, not floating freely in a vacuum. The context of the discussion is the Bun port's excessive use of unreviewed unsafe blocks. unsafe in Rust can easily be misused to create Undefined Behavior, which renders any safety guarantees otherwise ensured by Rust's borrow checker invalid.
> Does bun actually do anything insane like that in its unsafe blocks?
Who knows? At 10k unreviewed uses of unsafe, I'd guess there are quite a few incorrect ones. LLMs don't produce perfect code (neither do humans), so there's a high probability that at least some of those create UB.
I use jaxtyping as documentation, but the fact it can only be used for runtime checking (in a slightly clunky manner) and can't infer shapes based on ops really limits its utility imo.
It's what put MuJoCo on my radar recently! But I was surprised to not see him do any kind of gradient descent to optimize his hyperparameters. MuJoCo has a JAX backend so it should be fairly straightforward.
I'm pretty sure he has used gradient descent in previous videos to optimize systems, maybe this time it was just easier to hand tune rather than set up an optimization feedback harness around MuJoCo.
For people wondering why the Islamic world would have had more texts, many of which are of western (Greek/Latin) origin, than the western world. The problem is that, as the Roman empire collapsed, papyrus supply disappeared in the west (while north Africa still had papyrus, and later early paper) forcing copyist to use-significantly more expensive and lower supply-parchment. As the texts on papyrus started to crumble to dust, monks had to decide which ones to save given the limited writing material available (so they saved a lot of Saint Augustin...).
In short: start with a dataset of question and answer pairs, where each question has been answered by two different LLMs. Ask the model you want to evaluate to choose the better answer for each pair. Then measure how consistently it selects winners. Does it reliably favor some models over the questions, or does it behave close to randomly? This consistency is a strong proxy for the model’s intelligence.
It is not subject to dataset leaks, lets you measure intelligence in many fields where you might not have golden answers, and converges pretty fast making it really cheap to measure.
Interesting, but couldn't a model "cheat" in this task by being very good at telling model outputs apart? How far do you get with a classifier simply trained to distinguish models by their output?
It seems to me many models - maybe by design - have a recognizable style which would be much easier to detect than evaluating the factual quality of answers.
In theory, yes! If this metric ever becomes a widely used standard, one would have to start accounting for that...
But, in practice, when asking a model to pick the best answer they see a single question / answers pair and focus on determining what they think is best.
It presumes some models are better than others (and we do find that providing data with a wide mix of model strengths improves convergence) but it does not need to be one model, and it does not even need to be transitive.
Fun fact: archaeological evidence on I Ching divinatory records shows an hexagram distribution different from the one produced by the yarrow stalk method. Meaning that, while it is now considered the traditional method, it was likely not the original approach.
To be honest, my reason for picking this method was simple: I was reading a book about the I Ching that described the different ways to cast hexagrams.
The Yarrow Stalk method stood out to me because it felt more mysterious—in the past, it seemed like a secret method known only by a few experts.
Also, from a coding perspective, this algorithm was just much more interesting to build than a simple coin toss!
I doubt it. The I Ching does not really have bad / low interest hexagrams. Also historians who studied the topic seem pretty sure that the yarrow stalk method is a recent introduction (by I Ching standards, we are talking about a bronze age divination tool...).
I went through a book similar to the one above, with no internet connection. The first few weeks were rough: I did not quite know what a type was and the compiler error messages were unforgiving and hard to understand without that context. But, once I grokked the core ideas (a proper idea of what could be done with recursion took much longer), things went surprisingly smooth. I definitely credit it with making me a better programmer.