Jul 96 Dialog Box
Volume Number: 12
Issue Number: 7
Column Tag: Dialog Box
Dialog Box 
By Matt Neuburg, letters@mactech.com
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?”
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.
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