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 people aware, none of them have gone all-out and decided that
their main design goal would be to conquer the complexity of developing and maintaining programs.[1] Of course,
many language design decisions were made with complexity in mind, but at some point there were always some
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 to be backwards-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 to be an extensible language, so all the extensions piled upon VB have produced some truly horrible and
unmaintainable syntax. Perl is backwards-compatible with Awk, Sed, Grep, and other Unix tools it was meant to
replace, and as a result is often accused of producing “write-only code” (that is, after a few months 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.
What has impressed people most as they have come to understand Java is that somewhere in the mix of Sun’s design
objectives, it appears that there was the goal of reducing complexity for the programmer. As if to say “we care
about reducing the time and difficulty of producing robust code.” In the early days, this goal resulted in code that
didn’t run very fast (although there have been many promises made about how quickly Java will someday run) but
it has indeed produced amazing reductions in development time; half or less of the time that it takes to create an
equivalent C++ program. This result alone can save incredible amounts of time and money, but Java doesn’t stop
there. It goes on to wrap many of the complex tasks that have become important, such as multithreading and
network programming, in language features or libraries that can at times make those tasks easy. And finally, it
tackles some really big complexity problems: cross-platform programs, dynamic code changes, and even security,
each of which can fit on your complexity spectrum anywhere from “impediment” to “show-stopper.” So despite the
performance problems we’ve seen, the promise of Java is tremendous: it can make us significantly more productive
programmers.
One of the places people see the greatest impact for this is on the Web. Network programming has always been hard, and
Java makes it easy (and the Java language designers are working on making it even easier). Network programming
is how we talk to each other more effectively and cheaper than we ever have with telephones (email alone has
revolutionized many businesses). As we talk to each other more, amazing things begin to happen, possibly more
amazing even than the promise of genetic engineering.
In all ways—creating the programs, working in teams to create the programs, building user interfaces so the
programs can communicate with the user, running the programs on different types of machines, and easily writing
programs that communicate across the Internet—Java increases the communication bandwidth between people. People think that the results of the communication revolution may not be seen from the effects of moving large quantities
of bits around; we shall see the true revolution because we will all be able to talk to each other more easily: one-onone,
but also in groups and, as a planet. People have heard it suggested that the next revolution is the formation of a kind of
global mind that results from enough people and enough interconnectedness. Java may or may not be the tool that
foments that revolution, but at least the possibility has made me feel like people are doing something meaningful by
attempting to teach the language.
Inspired by Bruce Eckel.
