I had quite an interesting discussion with someone who staunchly believes in the programming language Java.
Java isn’t just a dumb corporate concept. Java is Gosling’s concept, and Gosling happened to work at a corporation at the time.
Yes, I agree. That is why the original prototype, version 0.96, was quite good. People liked it. Gosling managed to make an interesting point. Everything that followed that original version, was no longer Gosling floating a concept, did not improve it, but just made it increasingly unusable.
Java is a reasonable combination of programming patterns.
Well, I rather believe that a decent programming language is the reflection of a particular mathematical axiomatization.
Lisp is a very good example of that. The concept was first published in 1958. Lisp and its derivatives are still viable programming languages today, because underlying math obviously did not rust.
For Java, however, there is no underlying math. In other words, Java is absolutely not in the same league.
Enforcing a circumstantially-useful programming pattern through programming language syntax is not what we needed then, and also not what we need now.
Not everything is a valid class or object.
If it were, the Java crowd would have phrased an object calculus first. They did not.
For example, everything really is a function. The lambda calculus guarantees that.
Therefore, I ignore things like Java. These things just do not have it, and do not cut it.
Java is particularly good for developing libraries since object-oriented programming is good at encapsulation. It isn’t so good for rapidly developing applications.
At the meta-level, a programming concept rests on mathematics.
Java is just not good mathematics. In fact, it is not mathematics at all.
Therefore, it is fundamentally not good for anything it claims to be good at, since programs are primarily mathematical objects, as in Alan Turing's Halting Problem, or in the Curry-Howard Correspondence.
Therefore, either you are capable of treating programs as mathematical objects, or else you should just refrain from making spurious, wide-ranging, non-mathematical layman claims about things that are essentially mathematical objects.
Mathematics is what powers computability.
Java is a tool built by non-mathematicians for non-mathematicians, the blind leading the blind. In the realm of computing and computability, the better tools are built by mathematicians for non-mathematicians.
Other paradigms may work for libraries, but they are unproven and Java is proven, so why bother?
At best, Java could possibly be falsifiable (as in science) but never provable (as in math). Note that theorems about mathematical objects that are merely falsifiable, are considered to be silly.
You should not try to falsify Fermat's Last Theorem by randomly generating thousands of numbers and then concluding that you could not find one tuple (a,b,c) for which a⁵+b⁵=c⁵, and invite people to try your test too, in order to conclude Fermat's impossibility. That would indeed be the scientific method. However, it is considered a laughable practice in mathematics. The mathematical method does not work like that, and people who advocate that kind of things, are generally requested to find another subject than mathematics.
Provability requires that all untruth in a statement be exclusively the result of the untruth in a set of underlying statements. This principle is then repeated for each of these underlying statements, recursively, turtles all the way downs, to the basic statements, aka, the axioms.
The concept of proof means that you use the rewrite rules allowed by the axiomatic system in order to unambiguously derive the statement from other, existing statements in the axiomatic system.
Unlike Lisp, Java has never been phrased as a theorem in an axiomatic system. It has never been formally derived from one. Java simply has nothing to do with provability, proof, or axiomatic systems.
Java has not even, ever been phrased as a falsifiable statement along with an invitation to conduct experiments in order to falsify it. Therefore, Java is not even falsifiable (as in science).
Java is something else. It is more like someone who discovers that the number 47 appears everywhere in biology.
Especially, if you add up 21 to 26 or 5 to 42, and so on. You can always find reasons to see the number 47 there.
Therefore, he concludes that all biology rests on the core principle of 47.
From there on, he creates a programming language in which all numbers must be phrased as multiples of 47, and in which all functions have 47 arguments.
They now really believe that it works like that.
They are absolutely convinced of what they have discovered.
From there on, everything must be like that.
Any function with a different number of arguments than 47, is simply wrong. They are sure about that. They pay for enormous advertisement campaigns insisting that everything is pure 47.
A lot of people do not know better and believe them. So, now you have a complete gang, some kind of sect, creating all their programs in the 47 concept.
That is exactly what Java is. We look at it, and we look at the people who believe in all of that, and we consider the whole lot to be utterly stupid.
