What will the next big programming language look like? What will the last programming language look like? Is that even a sensical question?

Surely, we are not peak-programming-language yet! I don’t think so and the rest of our community certainly doesn’t seem to think so either. Usually I’m skeptical of this kind of framing because I think that our community has this irrational bias against old stuff. I’m all for reinventing the wheel when an individual does it. Whether it’s in order to better understand a problem or a technology, or to come up with a solution that is better fit to solve a specific problem. But it’s an entirely different thing when the community of software developers as a whole does it every couple of years. There is always a new hype language that large portions of the community adapt over a period of time or are somehow pressured into coming in contact with. Once it was Java being pushed by enterprises, then (to a lesser extent) PHP as the more grassroots-candidate to be used in this new important thing that was the web. After that it was JavaScript that almost everybody had to learn at least something about—whether they wanted to or not—because of its specific technological niche as the programming language that browsers implement. Today its Rust that you must rewrite everything in and if you don’t, you’re a bad person.

The point isn’t which of these languages is better, which is worse, which one has a stronger selling point than the other. You can make great arguments for what each of those languages brings to the table. The point is that we as a community invest an enormous amount of man-hours into creating a new language, learning it, building tools and infrastructure around it, cultivating tribal knowledge, actually writing applications in it… and then we do it all over again with the next language.

Many of us like to go along with this because we are curious people and enjoy learning new things. That is one of the most intriguing things about the technology and software biz! But we also pride ourselves in our ability to think rationally, we respect the scientific method and we strive for technological (and societal) progress—or so we think. Because when we zoom out to get a broader perspective of what is being accomplished, we have to ask ourselves: Are we actually doing our best to progress if we spend our time on chasing the latest language fad?

Usually I prefer to take a more individualistic view on things and in that sense, the quest for knowledge and new skills sure seems understandable, noble even. But if we talk about advancing human civilization, we might see a contradiction here: The greater endeavor towards progress might require different things from us than the small-scale affairs of the daily software business. (If one doesn’t care about one of these things—great: he can live free of this contradiction; I’d argue many of us in the software space care about both). We might be working really hard to achieve some kind of local maximum (in whatever metric or combination thereof) while failing to see the forest for the trees.

Let me drill deeper down into where I see the friction here. Manifest progress will mostly include actually writing software that people use. Spending time on building the tools we need for that is certainly justified (and lots of fun) but how far can we push this? Won’t there be a point of diminishing returns while trying to achieve peak-programming? How much time should you spend grinding your axe before you eventually go and chop down a tree?

It would be naive to think that we have the optimal programming language already. What would be the chances that after tens of thousands of years of human history already on the books (and hopefully many more to come, although we are sure doing our best to shorten the lifespan of our civilization…) what would be the odds of finding the optimal solution to such a complex problem mere decades after the problem even presented itself to us? No, I don’t think we are peak-programming. But what do we do about it?

Every new programming language is an experiment. We try to improve upon existing ones and approximate the optimum. But experiments sometimes fail. We might spend some considerable time on building and using a language that is further away from the optimum than what we had before and it takes us some time before we realize it. (How much has Java cost us in this regard? It took an awfully long time before more people came around to the insight that class-orientation is a useless programming paradigm.) And even if we only ever made steps in the right direction and continued to approximate an optimal programming language, how long do we need to get there? Is it worth it?