I heard something yesterday about some sort of bizarre drama in the Rust "community" (community should only ever be put in quotation marks since it has become a marketing term - except for the times when it is used to impose control onto people or otherwise generalize about them).

Apparently, their governance body publicly and nonsensically offended some influential computer scientist by inviting him to give the keynote at a conference they were running and then told him he wouldn't be giving the keynote, some time later (once he had prepared for it).

This caused him, his company, and much of the developer base and user base to turn on the governance body (well, this one - there are two) and required them to issue various apologies, etc.

When hearing this, the confusing part to me was: "Why do they need a governance body?" Isn't the language basically done, having essentially been fleshed out from the initial implementation in Mozilla research? Even if they do need some kind of system for ongoing development, why do they have a non-technical governance body, at all, much less one which directly manages conferences and has worrisome responsibilities like "enforcing code of conduct"?

Now, I know that other languages do change, over time (even C has the forthcoming C23), but I would argue that this should be minimal and the bodies in charge of it should be extremely technical and senior (ideally populated by the people who were involve in the initial language interpretation/usage and compiler development, where possible). Controversies should be around purely technical matters and should be minimal as changes (especially big changes) are less frequent in mature languages.

I am kind of reminded of how so many public blockchains worked where they had these incredibly heavy-weight governance bodies, populated by people who are looking to tell other people what they can/can't do, all while patting themselves on the back for being useless factories of smugly over-stated self-importance.

I actually wish that systems like programming languages were less monolithic and permanent: Fewer moving targets but more stationary ones. If you can't implement what you want purely on top of the system or know of a language change which would create an elegant solution to a confusing problem, then build some kind of pre-processor and see if a community grows up around it. In actual practice, this would be pretty rare but would likely be useful to people working in that domain. This would also avoid the problem where all languages converge, instead of remaining good at their respective philosophies (and yes, I am still annoyed by so many languages adopting the "all the logic is in the destructor so you can't see what is actually happening" philosophy - their argument is sound but incomplete and, I would argue, replaces a small problem with a worse problem).

Bah, enough of my babbling,
...Nights