ADVERTISEMENT

Dialog Box

By Matt Neuburg, letters@mactech.com

Java Without the Hype

Introduction

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?”

Java 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 developer’s 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.

Java’s 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 object’s 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.

Summary

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.

Postscript

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 Sun’s 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 Java’s 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
uncle.dave@sdu.com