Jul 96 Dialog Box
|Column Tag:||Dialog Box
By Matt Neuburg, firstname.lastname@example.org
Java Without the Hype
Talking to my colleagues about Java, I find as many skeptics as enthusiasts. Both sides generally are reacting to the hype, the one rejecting it, the other accepting it. But there are reasons to praise and disparage Java without regard to that hype - that is, without regard to its use on the Internet.
Such a critique is possible because Java is designed to (among other things) support the development of stand-alone, cross-platform applications. So the question at hand really is, How good is Java as a general-purpose language, and how good is its implementation?
As it happens, the rough spots in Java are due mainly to its implementation, which is correctable, not to its language features. The Java libraries are incomplete. I could not, for example, mimic a simple FaceSpan-built interface in Java; it seems not to distinguish checkboxes and radio buttons. The libraries are buggy; list boxes would not reshape or draw correctly, for example. More important, there is no visual interface builder (yet); interfaces have to be created inside out - that is, starting with text, as during the Neolithic Age. FaceSpan, Visual Basic, Delphi and others have shown that there should be visual interface builders for a language from day one.
It is also shocking to see the sloppy, unannotated, even unformatted example applets made public in the developers kit.
But implementation problems are correctable; they are significant only until they are fixed. The more important aspects of a language are its feature set and the development methodology that it supports. This is the side of a language that is cast in concrete, and that can make it usable immediately and for the long term - or not. Now the question is, Does Java represent progress in language design?
A Little History
Program language design has made great progress during its 50-year history, albeit in steps both forward and backward. Real-life usage constantly suggests or demands new features and, when enough demand has accumulated, some brave soul abandons the current languages to design another that addresses at least some of the demands.
The demands upon languages are both concrete and abstract. Concrete demands relate to things like control constructs, data types and fine points of syntax and semantics. More abstract demands are those in support of certain methodologies; these, of course, lead to concrete demands, such as demand for a syntax that supports data abstraction.
It is fairly easy to see the major trends in language design, and to see the progressive and regressive language features. Here are some of the major trends:
Movement toward higher-level control constructs, those that do more in fewer instructions. From assembly-language looping constructs, we moved to the FORTRAN for loop, and to the implicit loops of APL or the removal of loops by way of recursion.
Simplification and reduction, the factoring out of necessary and sufficient features from the current feature experiments. In PL/I, we could loop n times, forward or backward; or loop over any arbitrary list of numbers; or over any combination of forward, backward and arbitrary; and do this while or until some other condition is true. Pascal reduced this to the simplest for, repeat and while loops.
Putting features into libraries instead of into the language itself. PL/I is a huge language; every conceivable feature (at the time) was put into it. C, on the other hand, is a small core language with large standard libraries.
Strong typing, which is the detection at compile time of errors that would otherwise occur at run time. Familiar examples of this concern type-checking in expressions and in parameter lists. In FORTRAN and C, actual and formal parameters need not match; in Pascal and Ada, they must match or the program will not compile.
Information hiding in all its forms, including encapsulation, data abstraction and objects. Opportunities for information hiding within a COBOL program are non-existent; it is very much better in Pascal; and it is key to Object Pascal and C++, both of which support objects.
There was much more in this historical mix - recursion, functional programming, orthogonality, regularity, parameter-passing protocols, and many advances in the implementation of these features - but I think I have highlighted the major ones.
Progress and Regression
The hundreds of languages that have sprung up in the last 50 years, including the dozen that have seen widespread adoption, were not always progressively better, although most fit the moods in which they were designed.
Pascal was progressive because it was a simplification, because it demonstrated the benefits of strong typing, and because it was designed for fast, single-pass compilation. But it was too simple for real-world development until it had good supporting libraries.
C was progressive because it, too, was a simplification, and because it defined a set of libraries as standard extensions of the language. But C was also regressive with respect to its arcane declaration syntax, the weakest typing since assembly language, and its exclusion of strings as a native type.
Object Pascal and C++ were progressive because they catenated objects onto compiled languages already in widespread use, but Object Pascal now suffers socially from being based upon an abandoned language, while C++ suffers technically from being based upon C.
Javas Place in History
And now Java: How does Java fit into the evolution of languages? It is progressive in several ways, some of which are:
It is a simplification (but not an over-simplification) of C++, the most popular object-oriented language.
It reasserts the necessity of strong typing.
It brings strings back into the language (and makes arrays first-class citizens).
It provides high-level program-structuring features - packages and interfaces.
Objects are central to its design; they are not just an add-on or an orientation.
Java does perpetuate some irritating features of C and C++. For example, it uses the prefix notation for declarations, whereby you sometimes must read a half-dozen qualifiers before you can find an objects name. But, minor irritants aside, Java is a real advance in language design.
This does not mean, of course, that everyone will like its features or even use them to greatest advantage. C hackers (not all C programmers) who now willingly pass along the costs of weak typing and wild-card pointers to their customers will be irritated that there is no switch to turn off responsible programming. And I have already seen a published binary-tree example that simply ignores the object features to implement the tree in a completely traditional way. But programming has always included ego, habit, ignorance, self-indulgence and resistance to change, alongside common sense, experimentation, experience, responsibility and progress. Good languages tend to support the good programming traits, but they cannot always suppress the bad.
Even if we disregard the self-serving hype of all who hope to profit financially from the spread of Java (and especially if we disregard the ignorant parroting of the popular press and the new world order freaks), we find that Java is an important step in the evolution of programming languages, a step we all need to take.
Let me make a proposal concerning Java: programmers should hijack it.
Java is an important new tool; we must not accept the idea that it is just for the Internet, or just for applets, or just for cross-platform development, or that it is just Suns language. Schools should start teaching it in introductory courses; we should create a demand for good compilers (even if machine-specific) and good development environments; and we should pressure Javas authors and promoters into making the standard libraries correct, comprehensive and truly cross-platform as soon as possible.
- David Uncle Dave Moffat, Senior Engineer at SDU