Some of the earlier ones remind me of C#'s records. Were they inspired from them?
No, that stuff is much much older.
Named parameters are problematic because of parameter names becoming significant to the API. See Python’s * and / in parameter lists (like def foo(a, *, b) for example).
I think the name problem is overblown, you can always have an annotation to facilitate name changes.
In addition to that, I have my own list of things Rust should not have shipped with, but did.
This. I’d rather have fewer, better working features.
Rust devs sometimes seem to be an incredibly insecure and angry crowd.
I mentioned elsewhere how I had very good outcomes from looking at Rust and asking “how can this be done, but simpler?” in my language, listing a few examples … and they were absolutely livid about it.
I would be deeply uncomfortable to work in an environment where one couldn’t ask the author of a change for insights or rationale, because the author let some machine write it and therefore lacks any deeper understanding.
I’m on Codeberg because it cannot get bought out and enshittified (like GutHub, or GitLab).
I’m at a point where I reconsider my contribution if the project uses GitHub.
I think it’s due to multiple reasons, and the threshold of rejecting the course of GitHub/Microsoft/the USA seems to have reached a level where GitHub stopped being the “default” place to be for a number of projects already.
And if you are at a point were you need a Codeberg account anyway already, why not move your own projects there (or use it for new ones)?
Not to mention, the Forgejo project is at a stage were it feels like your bug report/feature request/contribution has an actual impact.
Only if you like “eventual consistency”, in the sense of “eventually, your data is consistently gone”.
To be honest, this is an interesting article from a language comparison perspective, but this really weird breathless fawning over syntactic decisions (that may, at best, be slightly better than Rust) is insufferable.
If one added all the weird stuff Zig (or “Tig” as I call it due to the endless shilling of that one database company that seems to be the sole user of the language), it simply evens out:
Neither Rust nor Zig are particularly “beautiful” or in the top spots when it comes to good, clean, minimal syntax design.
It’s just … weird?
Thinking Zig has “lovely syntax” compared to Rust, feels like someone saying that Go has “great semicolon inference” based on only knowing JavaScript.
Which is not very noteworthy, don’t you think?
Putting some HTML files on a web server somewhere is not that big of a mystery in 2025 that it might have been in 1995.
Github Pages supports Jekyll as a SSG out of the box.
Any documentation or tutorial – official or otherwise – that simply skips on this is getting people’s hopes up just to waste their time.
Ohh, boohoohoo, what are you gong to do, cancel your lib.rs subscription?
Perhaps, the linked page just does a poor job of selling that.
As someone also working on a minimal programming language, I might share some of the values, but using Go as an implementation language is an immediate turnoff.
Also, not having a single code example on the linked page is super-annoying.
People need to stop that.
Incorrect.
Rust is not a functional, let alone functional-first language.
Your opinion is unpopular, because it is wrong.
No normal person would think of C when told to imagine a language that is not bloated and not unnecessarily complex.
And all of this due to the mistaken design decision to stick with the obsolete readiness-based model instead of going with the superior completion-based model.
(You can build a readiness-based API on top of a completion-based API, but not the other way around.)
I went the “only
letintroduces bindings” route, and I’m pretty happy so far:if (left.next(), right.next()) ... is (Some(let l), Some(let r)) { /* use l and r */ } ... is (Some(let l), None ) { /* use l */ } ... is (None, Some(let r)) { /* use r */ } ... is (None, None ) { /* use nothing */ } }