Haven’t read the Wired article Robby links to as it’s behind a paywall but the first two lines of the preview were enough to convince me the author seems to be missing the point:

Ruby Is Not a Serious Programming Language

Ruby survives on affection, not utility. Let’s move on.

There are reasons for the affection, and it’s those reasons why it survives, and imo, exactly what will help it (and others like it) continue to survive in an age of AI

Any context I’ve seen the term “serious” used, it’s a pure expression of contempt. It never has any significance beyond that. One never describes something positive as “serious”–no one would know what that means. But it’s always quite clear that “not serious” simply means “beneath consideration”, which is fine to have as a private judgment but is hardly constructive as an argument in a public forum. It certainly wouldn’t fly in a professional context, where it would add nothing to the actual arguments for and against. But perfect for language wars I guess where there is no actual problem at hand to be solved.

As someone who used PHP, Python and other comparable languages before encountering Ruby, the appeal of Ruby’s ergonomics was clear and immediate. For various reasons, I was able to be more productive with it and that allowed me to achieve a certain amount of success. Evidently that was also true for a significant number of other developers. If it has been a poor fit in various applications, well, it can hardly be blamed for that. Is a bike not a “serious” mode of transportation because someone failed to ride one to the moon?

This is a property for which I have yet to come up with a name but which I have come to appreciate is very important. I have tried “power” or “powerful”, but it’s not quite right. Maybe it’s easier to explain what I mean by example.

I would much rather write my build scripts in Python than YAML. I would prefer something like JSX to string templates. These are simple examples and should be obvious to most, but this concept can cut quite deep.

I very much like React’s engine and the way it models rewindable code. It’s easy to look at it and say, this is very unsophisticated, we can replace these blunt components with a fine-grained reactive graph. And at first this seems like a great idea, and everything is going fine and it’s very fast, and then you wake up one day and your if statements are components.

And I have picked on Solid here, but you might notice that Phoenix has gone down a similar path as of late with :if and :for. Really, it seems like most tools end up like this, as though it’s some sort of trap which takes very careful and deliberate design to avoid. I am truly impressed that React managed to consistently ship such elegant abstractions for so long (probably not anymore).

But perhaps the truly goated example of this is Erlang, which has delivered on its underlying message passing abstraction for nearly 40 years. Like, this thing has lived through personal computing, the rise of superscalar and multicore processors, the shift from mainframes to commodity hardware, the ossification of that model into “cloud computing”, the entire history of the web, and throughout all of that has maintained relevance as a useful abstraction. I cannot imagine how much wisdom and care must have gone into that.

I hope that, someday, I will be wise enough to design such things. Either way I will keep trying.