I originally approached Java as just another programming language, which in many senses it is.
But as time passed and I studied it more deeply, I began
to see that the fundamental intent of this language was different
from other languages I had seen up to that point.
Programming is about managing complexity: the complexity of the problem you want to solve,
laid upon the complexity of the machine in which it is solved.
Because of this complexity, most of our programming projects fail.
And yet, of all the programming languages of which I an aware, almost none have gone
all out and decided that their main design goal would be to conquer the
complexity of developing and maintaining programs. Of course,
many language design decisions were made with complexity in ming,
but at some point there were always other issues that were considered
essential to be added into the mix.
Inevitably, those other issues are what cause
programmers to eventually ”hit the wall” with that language.
For example, C++ had tobe back-compatible with C (to allow easy migration for C programmers),
as well as efficient. Those are both very useful goals and account
for much of the success of C++, but they also expose extra complexity that
prevents some projects from being finished(certainly, you can blame programmers
and management, but if a language can help by catching your mistakes, why shouldn’t it?).
As another example, Visual BASIC (VB) was tied to BASIC, which wasn’t
really designed tobe an extensible language, so all the extensions
piled upon VB have produced some truly unmaintainable syntax. Perl is
backwards-compatible with awk, sed, grep, and other Unix tools it was meant to replace, and
as a result it is often accused of producing “write-only code”(that is, after a while
you can’t read it). On the other hand, C++, VB, Perl, and other languages like Smalltalk
had some of their design efforts focused on the issue of complexity and as a result are
remarkably successful in solving certain types of problems.