Rigidity is not the same as power
The debate in question is this: How powerful is your programming language?
I'm not here to preach one language over another. That's not how I work. I have no religious attachment to the languages I use - I prefer the languages I prefer for the reasons I prefer them, and that's that. It doesn't matter what other people think, unless they show me something that utterly changes my mind (something that hasn't happened very often, I might add).
What I am here to do is try to bring a little sanity to the discussion. To calm down the warring religions of ML style vs. Lisp style vs. OOP vs. FP vs. vs. vs. and so on with a little calm, well-reasoned, logical discussion. So that's what I'm going to do, starting with debunking a simple misconception (or trying to, at least).
Far too often, the debate about "How powerful is your programming language?" becomes a debate about "How rigid is your programming language?". This is a misconception that personally bugs me every time I see it, for one simple reason.
Rigidity is not the same as power, nor is it the opposite.
I'm here to tell you that they're both wrong, and that they're both right.
Rigidity is a useful tool. Restraint forces you to be more clever, finding ways to work within the constraints you're given. It also helps rule out some problems and bugs by making it harder to make mistakes. On the other hand, being less rigid allows for faster, more intuitive development, effective meta-programming, and a lot of simple solutions to difficult problems that simply can't be done easily in a more rigid language. Just as flexibility can be taken too far, so can rigidity, and both are good in moderation and bad in excess.
Far too often, people see rigidity as either entirely good or bad. They see a spectrum of programming languages, from most rigid to most flexible, and they pick a side that they see as "good" and decide that therefore the other side must be "bad". They come up with (legitimate) reasons for what they see as good and bad about them, ignoring the (also entirely legitimate) reasons to think the opposite, and they go off to war.
In reality, this just isn't true. The more I think about the languages I've used, the more I see the same spectrum, with one key difference. I haven't labeled one side as "good" and the other as "bad". I've simply labeled them as what they are, more rigid or more flexible.
Rigidity is good. Flexibility is good. Which you should choose depends entirely on what you're trying to do.
Do you want your programming language to find your bugs for you, ripping out entire categories of problems in one fell swoop? You should choose a more rigid language such as Kotlin or F#, that holds you to strict, mathematically sound design principles and prevents you from making silly mistakes like not checking for null.
Funny internet images aside, both of these are beautiful choices with their own ups and downs. Rigid languages like Java, Scala, C++, and so on often have trouble dealing with the possibility that something could be multiple types of things. Their rigidity is their greatest strength, but also their greatest downfall (and one of the reasons for "Nobody uses Haskell" being a flat out meme).
I know my half-coherent rambling isn't going to stop the language wars raging across the internet. Hopefully, though, it'll do some good to the people who read it. I guess all I'm trying to say is that programming languages are tools designed to fulfill a purpose. There's no point getting dogmatic about which is better, especially on a non-issue like rigidity. There's two sides to every coin - it's time we stopped acting like our grass is the greenest and realized that everyone has different needs, preferences, desires, and so on. Everyone has their own list of things they need from their programming language - there is no silver bullet.