The evolution of Java has come to an end

" In a hundred years, what languages will people be using to develop software? Why is this question worth thinking about? Not because we'll see these languages eventually, but because, with luck, we'll be paying attention to them early on! "

Java's evolutionary path has come to an end

We try to think about a question: What language will people use to develop software in a hundred years?

Why is this question worth thinking about? The reason is not that we will eventually use these languages, but that, with luck, we will be able to choose and use these languages from now on. In my opinion, programming languages are like biological species, there is an evolutionary context, and many branches will eventually become evolutionary dead ends. This phenomenon is already happening. The Cobol language was popular for a while, but now it seems that no subsequent language inherits its ideas. It is like "Neanderthals", the evolutionary path has come to an end.

I predict the same will be true for Java. Someone wrote and said: "How can you say Java won't succeed? It has already succeeded". I think it depends on what your success criteria are. If the criterion is the number of books published, or the number of college students who believe that learning Java will get them a job, then Java has indeed succeeded. When I say that Java is not going to succeed, I mean that like Cobol, its evolutionary path has come to an end.

This is just my guess and may not be correct. The point here is not to look down on Java, but to propose that there is an evolutionary context in programming languages, so as to guide readers to think about the position of a certain language in the entire evolution process. The reason for asking this question is not to make future generations lament that we were so wise in a hundred years, but to find the backbone of evolution. It will inspire us to choose those languages that are close to the trunk, which is the most beneficial to current programming.

The backbone of programming language evolution

Choosing an evolved trunk is probably the best option at any time. It would be too bad if you were unlucky enough to pick the wrong one and become a Neanderthal. Every now and then your rival Cro-Magnon will attack you and steal all your food, which is why I want to find out what programming language will be in a hundred years. I don't want to bet on the wrong bet.

The evolution of programming languages is still different from the evolution of biology, because languages of different branches will converge. For example, the Fortran branch appears to be merging with Algol's successor. Theoretically, different biological species may also converge, but the probability is very low, so probably there has never been a programming language that may converge, one reason is that its probability space is relatively small, and the other reason is its mutation Not random. Language designers always consciously borrow design ideas from other languages.

For language designers, it is especially useful to recognize the evolutionary path of a programming language, because it allows the language to be designed accordingly. At this time, recognizing the backbone of evolution not only helps to identify existing excellent languages, but also serves as a guide for designing languages.

Any programming language can be divided into two major components: the set of basic operators (playing the role of axioms) and the other parts besides operators (in principle, this part can be expressed by basic operators). In my opinion, basic operators are the most important factor in the long-term survival of a language. None of the other factors are decisive. It's a bit like when you buy a house, you should first consider the geographical location. There are ways to make up for problems in other places in the future, but the geographical location cannot be changed. It is not enough to choose an axiom carefully, it is also necessary to control its size. Mathematicians always think that fewer axioms are better, and I think they're on to something.

You take a close look at the core of a language and consider which parts can be discarded, which is at least a useful exercise. In my long career, I've found that redundant code leads to more redundant code. Not only the software, but with a lazy personality like me, I find this proposition holds true under the bed and in the corners of the room, one piece of garbage begets more garbage,

My judgment is that those programming languages with the smallest and cleanest cores will exist on the evolutionary trunk. The smaller and cleaner a language's kernel is designed, the more tenacious its vitality.

How to maintain the first mover advantage

Now, let's start changing!

Re-examine your favorite programming language, and choose those evolutionary backbone and derived languages, which will allow you to maintain a first-mover advantage in the subsequent evolution!