Ruud van Asseldonk, a software engineer, writes about Rust, type systems, build systems, abstraction, and configuration languages.
HN links it for the YAML critique and the 'neither necessary nor sufficient' essay on garbage collection, and commenters also admire the site's design.
I enjoyed the thoughtful article.
It's interesting that type checking happens at runtime so there is no compile time, only runtime. It seems this would make it acceptable. But I wonder if the assumption will always hold.
The assumption:
> The program doesn’t even have any inputs: all parameters are “hard-coded” into it. [1]
Will that always hold? What about environment variables? If the language ever needs to handle parameters, this assumption breaks and thus compile time and runtime will be separated.
Other languages like Go would force you to insert type assertion which is the same thing just explicit. I forces you to "approve" what's happening, and that's a good thing.
There is the saying that every configuration language will eventually evolve into a full blown programming language. I guess it's all about the real world proving the underlying assumptions to be incorrect.
[1] - https://ruudvanasseldonk.com/2024/a-type-system-for-rcl-part-1-introduction#static-vs.-runtime
I don't really understand why people would want a GC over deterministic destruction like in Rust. GC is [neither necessary
nor sufficient](https://ruudvanasseldonk.com/2015/10/06/neither-necessary-nor-sufficient). Ownership model in practice is much more convenient precisely because objects can act like resources and implement their cleanup logic, and the business logic can rely on it. It's a great improvement in any imperative PL.
I have (re-)implemented couple of real-life projects, and each time Rust was much better higher-level language than eg. Java, Python or JS. Borrow checker fights are non-issue in practice: just avoid references, pass messages as copies and when you have to share data use `Arc` and copy on write (or just add `Mutex`).
There's a reason why Rust is most loved PL for 4 years in a row. Once you try it, and get past initial adjustments (mosty: what owns what relationship) everything clicks, and I guarantee that you won't miss GC at all.
There are underpowered languages / tools, that can only solve a problem for which they are intended poorly. But not all limited tools are like that.
Say, eBPF is prominently not Turing-complete, which allows to guarantee that a eBPF program terminates, and even how soon. Still eBPF is hugely useful in its area.
Or, say, regular expressions are limited to regular languages; in particular, they famously [1] cannot process recursive structures, like trees. Still tools like grep / ag / rg are mightily useful.
Yes, I agree that YAML is underpowered for proper k8s configuration! But it's also too powerful for its own good in other aspects [2]. I wish Google used Dhall [3] or their own purely functional config language (FCL? I already forgot the name) instead of YAML; sadly, they did not.
[1]: https://stackoverflow.com/a/1732454/223424
[2]: https://ruudvanasseldonk.com/2023/01/11/the-yaml-document-from-hell
[3]: https://dhall-lang.org/
To me YAML seems like the CoffeeScript of JSON, and unlike CoffeeScript I don’t understand why people are still using it.
I guess XML and JSON are too verbose. But YAML is so far in the opposite direction, we get the same surprise conversions we’ve had in Excel (https://ruudvanasseldonk.com/2023/01/11/the-yaml-document-from-hell). Why is “on” a boolean literal (of course so are “true”, “false”, as well as “yes”, “no”, “y”, “n”, “off”, and all capitalized and uppercase variants)? And people are actually using this in production software?
Then when you add templating it’s no longer readable and concise anyways. So, why? In JSON, you can add templating super easily by turning it into regular JavaScript: use global variables, functions and the like. I don’t understand how anyone could prefer YAML with an ugly templating DSL over that.
And if you really care about conciseness, there’s TOML. Are there any advantages of YAML over TOML?
While it does not solve your use case, others here might find it interesting: I built a domain-specific language for designing slides (https://github.com/ruuda/pris#readme). It is superficially similar to LaTeX/Beamer/TikZ, but it has first-class graphics that are reusable. More motivation in this blog post: https://ruudvanasseldonk.com/2017/04/27/a-language-for-designing-slides. It is still basic, but I have used it a few times to do slides nonetheless.
Some context, this was launched at IndiaFOSS[0] yesterday
25 minute talk at https://www.youtube.com/live/AUrPdOZNsX8?feature=shared&t=13962 (starts 3h:52)
The talk proposal is at https://fossunited.org/c/indiafoss/2025/cfp/arsnhack6n
And it primarily tries to avoid YAML horrors : https://noyaml.com/ and https://ruudvanasseldonk.com/2023/01/11/the-yaml-document-from-hell.
[0]: https://fossunited.org/indiafoss/2025