The end of progress in software engineering?

When we compare the performance of two equivalent programs in two different programming languages, we may still be able to test whether the one is faster than the other. That would be epistemically even sound. Still, difference in performance is not the main and certainly not the only reason why we have different programming languages.

We often consider the one programming language to be potentially better (at a particular task) than another, when the resulting program is more flexible, more maintainable, or just generally more readable.

In one way or another, a "better" programming language seeks to make the job easier for the programmer.

Let's compare two extremes of a "Hello world" program:

Expression 1 in Brainfuck:

++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.

Expression 2 in Javascript:

console.log("Hello World");

I suspect that most people will find the Javascript version more readable than the one in brainfuck. Still, is there a way to objectively or even mechanically ascertain this proposition? Can we experimentally test (science) or computationally derive (mathematics) that expression 2 is more readable than expression 1? In absence of a mechanical answer to the question, the answer is merely a subjective matter.

Therefore, in absence of an objective and mechanically-verifiable metric for readability, the entire debate about the tools of the trade, i.e. programming languages, libraries, frameworks, and programs, is fundamentally unjustifiable and therefore flawed in an epistemic sense.

What's more, if we have no objective definition for the term "progress", we are not particularly likely to keep making any, especially now that the low-hanging fruit has been plucked already.

Therefore, progress in software engineering, and hence in technology in general, may sooner or later come to a screeching halt for epistemic reasons.