I was reading somewhere that there are gazillions of functions and subroutines that have been written in some of these languages that are flawed....and as people use these flawed subroutines (which may call on other flawed subroutines and functions), inevitable bugs are manifested. The subroutine or function may have worked as intended for its original application, but embedded gremlins are waiting to emerge when applied to new situations....I'm meditating on the word verbose. Some verbosity in a programming language isn't necessarily a deal breaker.
If I were to compare two solutions to the same problem, written in two different languages, and try to reduce "which solution is better?" to a single criteria (this a thought experiment, I realise real life is too complex for such reductions) I think I come up with:
"Which is more elegant? Cleaner/Clearer?"
A lot of that is down to the developer, not the language, but the language and its libraries support that.
You could ask which is more robust, more maintainable, more extendable, more efficient... but if the code was handed to me as my future responsibility, I vote clean and clear.
So as someone who doesn't work in this world but just reads about it and is curious.... Is it possible that a given computer language starts out very clean and clear, but that over time it becomes a bit cryptic and chaotic because of the accumulation of not-so-well developed and documented subroutines and functions? (The real scary part is thinking about how things like rockets, weapon systems, aircraft, nuclear power plant automated monitoring systems, automobiles, etc., might have gremlins lurking in their software due to this problem! The bug is ID'd only after catastrophic failure and the follow-up investigation.)