It's not technically possible, at least without giving up functionality.
For example, languages have different levels of strictness which is proportional to how high or low level they are. Scripting languages are softly typed because they can easily perform runtime type checks and conversions. Compare this to C/C++, which has much more difficulty with type flexibility due to being closer to the memory. While more type-agnostic features get added, at the end of the day, most of these are still compiler-based: they serve more as programming aids than actual language functionality.
Another major example is how memory is handled. In scripting languages (and even some compiled languages), memory is largely out of the hands of the programmer, managed by the interpreter or some other system. In contrast, lower level languages provide the ability to directly manipulate and access memory, such as C/C++'s pointers.
While it's possible to think that maybe with increasing performance we'll someday stop caring about low-level programming and all start using some weird PHP analog for everything, I think that's failing to understand how the world really works. I consider C/C++ a low-level language, as do most people; but once upon a time, and still among some, it is a high-level language, and low level would be the likes of assembly. This is not merely terminology: as the performance framing of the question of efficiency shifts, so too do the measures of it. Simplifications we might now consider too costly to implement even in interpreted languages might one day be common-place among "high-level" languages, Java might be considered "low-level," C/C++ might be relegated to those weird times you simply must use it like assembly is now, and assembly itself might even be forgotten as an in any way viable language (class) in itself.
I think it's much less likely programming languages will converge than spoken languages for that reason. Human language serves a single fixed task, to convey information. While you might argue different languages are better or worse at some portion of that goal than others, they can all accomplish those goals. There are, however, things you simply can't do in PHP. There are also things no sane person would want to do (these days) in assembly.
One way to think about it might be this. If everyone in the world tomorrow spoke fluent Welsh, what would happen? Well, everyone would be able to converse in Welsh, translation services would go under, and perhaps leeks would become more popular. If tomorrow the only programming language available was JavaScript, we'd all be utterly screwed.
That's not even counting inertia. In human language, inertia is mostly a matter of being able to read old works of literature, something which is rarely a decision when deciding to learn a new language, and never a decision when learning a native language. While losing understanding of classic works would be a cultural loss, it's not likely to motivate actions on a large scale. On the other hand, having to reprogram the Linux kernel, Windows, almost every device driver, and web servers would definitely factor into broader decisions of programming languages. That COBOL still lives is a fairly strong argument against programming language convergence, in my opinion.
However, there is one point you might expect some convergence in programming languages: syntax. That is already happening, and the C-like family has largely won. C, C++, Java, JavaScript, and PHP all share mostly identical syntax, abet with some changes in operators, mostly mirroring their inherent difference. No pointer-operating *
and &
in PHP, no fun and easy string concatenation .
in C. However, those aside, these languages are almost entirely mutually intelligible in at least structure. An alternative family would be the BASIC line, including VB and I'd argue Python.