Dr. Nikolai Bezroukov's Devil's Advocate Commentary
on "Thinking in Java" by Bruce Eckel.
Chapter 1

Chapter 1 "Introduction to Objects"

The main problem with Chapter 1 is an uncritical acceptance of OOP by Bruce Eckel. Quite a better title would be "Introduction to Java". The chapter contains a lot of useful material,  but IMHO it is somewhat more close to OOP evangelism, than I would prefer. OOP has been touted as the next great advance in software engineering. It promises to reduce development time, increase code reuse, etc. The question never asked by the author in this chapter is very simple: "Is this true ?".  As this question was left out I will try to explore it below from the point of view of cynical, skeptical old programmer.

Java does have an important advantages and they are well described in the book. Among them:

• Tremendous marketing momentum (just look at the number of books published on Java);
• Beans component mechanism;
• Built-in multithreading;
• Extensive standard classes library (JFC);
• Good (but not perfect) portability;
• Servlets as a competitor to CGI+Perl
• Applets and browser-based communications  where you don't know or can't control the kind of client and the configuration that remote users have (on-line sail, illustrations for research articles etc.).

But in order to understand the language fully one need to understand not only advantages, but disadvantages as well. I will try to summarize Java disadvantages below.

Java is new and complex 

The first and probably key problem with Java is that it's too new and changes too fast. Each new version of JDK makes books and programs written in Java more or less obsolete. Generally a programming language need at least 10 years before is become stable enough to be used in large projects.

The second important problem with Java its complexity. More than 1000 pages for an introductory book is quite a lot.  I doubt that Java can be mastered by a programmer without extensive background in C++ or Smalltalk in less than a year.  Java is more complex language than PL/1 which at one point was considered a huge language and created KISS movement in programming languages represented by C and Pascal.

For example C -- a hybrid of PL/1 and BCPL is a programming language designed for writing Unix, and it has a minimalist set of constructs that permit both writing a decent compiler and OS. To keep language simple strings were made not first class data type. But simplicity is a very important advantage. Some people have called C a fancy assembly language and that's a very good point that can explain why C became popular and PL/1 obsolete although PL/1 in many respects was vastly superior to C (much better string handling, much better I/O, excellent exception handling,  even rudimental multitasking, etc.).

C compilers were simple, were easy to port (can be ported by a single person), required few machine resources to run, and provided about 60% of what you want from a programming language. PL/1 compilers require a huge investment to write, were not easy to port and generated programs were less efficient than in C. Half of the computers that exist at any point are worse than average (smaller or slower). C works better on them. C philosophy means that implementation simplicity has the highest priority.  Currently Java is big, complex and slow (probably factor 5-10 comparing to C, depending on the application ). 

Java is the one of very few languages that supports multithreading ( Simula 67 - the grandmother of object-oriented programming, Algol68 and Modula support co-routines, PL/1 and Ada support multitasking) and has a usable (albeit pretty complex) exception handling mechanism.  Exception handling and multithreading considerably add to the complexity of the language.  

To master "Java for applications" one needs to know three major areas:

• Syntax and semantics of the language including idioms;
• Java compiler and JVM including methods of interfacing with other languages (native interface);
• Huge number of libraries including GUI, networking, multithreading, parsing and interfacing with OS, working with databases.

This scope is definitly beyond one single book. So one may need the following additional books:

• A book on JVM and native interface;
• A book on AWK (for example Graphic Java) or JFC/Swing;
• A book on networking;
• A book on multithreading;
• A book on JDBC.

Fortunately a lot of books in each area are now available. That's one of the most important advantages of studying a popular and fashionable language.

Java is about programming at large; its suitability for system programming is limited

Java definitely can compete with VB and PowerBuilder as RAD language in commercial environment. It is a better language and in certain(but not all) aspect is a better implementation that VB.

Like VB it has a powerful marketing behind it so there are a lot of high quality commercial Java development environment and a lot of books are published on the subject.  So in any case where now people use VB or PowerBuilder,  they will probably be better using Java. Bruce Eckel is one of the first authors of books on Java who correctly stated that Java is more is a replacement of VB than for C++.

I am skeptical as for Java in system programming area, for example as a replacement for C/C++.  IMHO that promise will never materialize. Ability to view an area of memory in a different ways is fundamental to system programming and here Java with its OOP bla-bla-bla definitly sucks. Speed is another problem.  Currently Java is slow. Presence of garbage collection make debugging difficult and execution time non-deterministic. Moreover garbage collection is sometimes harmful in system programming when real-time performance is needed. 

The OOP paradigm also is far from being useful for system programming. Those who do not believe are encouraged to try to rewrite the first volume of Donald Knuth "Art of computer programming" in Java. Not much fun :-(.  In C++ if you do not want OOP you just don't use it, and when you don't need C++ you can use C.  In Java ignoring OOP it more complex. Using C is possible only via native methods, so it's much more painful than in C++. Also important is the fact that C++ is much more mature language. Even in v.1.2 (that probably should be called version 3) Java still is pretty much in the state of flux.

You can notice that Java programs tend to be bigger (i.e. contain more lines of code) that programs in procedural languages like VB or Perl. For problems like compiler writing programs in Java also tend to be more obscure than programs in procedural languages like PL/1 or C.

Some words about debugging. Although Java (like Pascal in the past) sometimes is hyped as a Newspeak of computer languages  -- the language in which it is impossible to have impure thoughts, reality is different. Generally I prefer the language that has the best debugger and best integration with the underling OS. For example C on Unix. Currently Java provide decent, but definitely not the best debugger for small and medium size projects and weak debugging support for complex projects. Heap allocation make debugging of complex system programs much more difficult (just compare complexity of Java memory allocation model with assembler or Fortran allocation model). I really do not envy the programmer facing the debugging of the program that run into JVM errors or some king of error on the border between the program code and JVM code.

There are already a couple of failures is using Java as a system programming language. Corel abandoned plans to rewrite its Perfect Suit of office applications, such as WordPerfect and Quattro Pro, in Java. Corel even ran TV commercials about it. Lotus got nowhere with its Cona suit of Java components. Oracle also quietly abandon its plans of "Java uber alles" and now use it mainly as more decent front-end to the Oracle databases that this horrible PL/SQL. Both Corel and Lotus experience shows that system programming projects in Java are currently a risky undertaking. 

Productivity gains can be not enough to win a substantial market share from the established languages

Is Java productivity promise real?  The answer is: "under certain circumstances and to certain extent". With beans Java probably can be more productive than VB and Power Builder. Without beans gains in productivity are marginal  -- it's just a better language although possibly some gain can be achieved due to a huge class libraries and a better integrated environment (for example Jbuilder 2.0 is very impressive).

Also gains in productivity are application area dependent. We probably can get better productivity in developing database-related and WEB-related applications -- where Java standard library provide rich set of primitives that can simplify the writing of the program.  At the same time CGI programming and text processing are areas were Java sucks. I  am skeptical of Java ability to compete with Perl in these two areas.

For me it is still unclear to what extent pain of learning Java can be translated into gain in productivity of writing complex applications. Other than beans, an important productivity gain can be achieved by using multithreading. But here we have too few programmers that are able to realize these gains.

I would like to stress that  the most dramatic improvement in productivity and reuse in Java can come from beans. So beans are probably the most important  feature of Java. With beans, Java became strong tool for integration of components, where we can use tested and proven components in our implementations.

Anyway, to be productive in writing commercial applications in Java one needs to know a large number of standard classes (class library). I would like to stress that this more complex task than leaning the language and it requires good guidance, documentation, search and indexing capabilities, tools that can hierarchically present all the reusable parts in a readable manner and a lot of time.

Java design flaws can prevent widespread use

No language is perfect. But some people that I respect are very critical of Java.

Linux Torvalds (do not take his words for grated -- all he is doing all his life is just debugging Linux kernel ;-) in his interview to Inforword (see Linus Torvalds talks economics and operating systems)    said:

InfoWorld: What do you make of Java?

Torvalds: I dislike the hype. I think it's way overhyped. I'd like it to have a more proven track record and I think the licensing restrictions are hurting it. I understand why Sun wanted to have them in place, but I also think that it means Java does not get as well maintained. Right now, if somebody notices a bug in Java, it's pretty hard to fix unless you're inside Sun. But the major issue is that it's a good idea whose time has come. It's an idea that's been done before, but you didn't have the same kind of hardware power you have today. Also you didn't have the same kind of software interfaces, so right now it is possible to make Java efficient? Potentially, it's a great technology, but it's unproven and there's been way too much hype.

The author of STL Alexander Stepanov in an interview for Edizioni Infomedia srl   took an extremely critical view on Java. He said:

I spent several months programming in Java. Contrary to its authors prediction, it did not grow on me. I did not find any new insights -- for the first time in my life programming in a new language did not bring me new insights. It keeps all the stuff that I never use in C++ -- inheritance, virtual -- OOP gook -- and removes the stuff that I find useful. It might be successful -- after all, MS DOS was - and it might be a profitable thing for all your readers to learn Java, but it has no intellectual value whatsoever. Look at their implementation of hash tables. Look at the sorting routines that come with their "cool" sorting applet. Try to use AWT. The best way to judge a language is to look at the code written by its proponents...

Of course one can argue that Stepanov is interested in defending C++ as his STL library is now included in standard. Still IMHO there are several design flaws in Java, some of them probably serious. Among them:

• Very limited way for defining constants (static final).
• The Java's mix of objects and native types is confusing and over reliance on object paradigm makes procedural programming problematic even for tasks that should be better solved using procedural approach.
• String manipulation is complex. Java has immutable strings (I remember only one system programming language that has had a similar model for strings -- XPL; also string are immutable is script languages -- REXX is one example)  that are not byte oriented (they are Unicode strings with 16 bit per character) and StringBuffer class. The library of string manipulation functions is much weaker than in Perl or REXX.
• Control structures are pretty weak. Labeled break like in PL/1 is the only innovation.   With such a limited repertoire of control structures the absence of GOTO is IMHO a design flaw.
• I/O model is simplistic. As for formatted input it's even weaker than in C.
• Parameterized types (see for example  Parameterized Types for Java for possible extensions of the language).
• Java is too much based on OOP and there are many pitfalls involved in the OOP (see below) -- than mean they become pitfalls of the language.  These pitfalls threaten to undermined the acceptance and use of Java before its promises can be achieved. 
• Garbage collection make language less reliable in real-time situations.

There are also several implementation issues:

• The current generation of integrated environments are still pretty primitive and buggy. Jbuilder 2.0 is probably the best, but it still has a long way to go before it become a viable development tool for complex applications.
• JVM currently is not very reliable and can die during execution of the program that do tricky things with memory and data. In such a case debugging became a nightmare.   

The acceptance of Java on Internet is exaggerated. According to WSJ Java used on less than 1% of all WEB pages with many sites abandoning the multimedia Java applets for simpler technologies such as animate GIF’s.

OOP nirvana can be a fake

One should understand that OOP is an old hat and several OOP-based languages are 10 or more years old and still fail to achieve wide acceptance and are limited to narrow niches. The classic example of such a language is Smalltalk -- paradoxically only financial institutions used it to a limited extend in real world projects. Success was mixed although Smalltalk programmers were very well paid ;-)

OOP attempts to decompose the world into objects and claims that everything is an object. But saying that everything is an object not always provide an useful insight into the problem. Just think of sorting. Will it help to sort the file efficiently if you thing that the records are objects. Most probably not.

OOP starts with classes. But  the essence of programming are algorithms. Only when you understand them well, can you come up with optimal storage structures for solving the problem.

The words "religious" outline the last problem. Many people/authors now tend to look at programming styles and languages like religions. Object-oriented programming (OOP) is often treated like a new Christianity and religious zeal of converts is often border with stupidity. So it definitely attracts charlatans which propose magic cures like various object methodologies ;-).

IMHO OOP more looks more like a paradigm shift that a language breakthrough. Much like a religion OOP introduced entirely new and quite obscure terminology with the purpose of mystifying the real underling mechanisms. It has not added a single novel concept, but it emphasizes two old, and definitely useful, concepts:

• The binding of procedures to a data a structure (called object). New procedures are now called methods. But all we need for that is the procedure variable stored as a record field, available in languages since the early 60s (PL/1).
• The second concept is that of constructing a new data structure (called subclass) by extending a given structure (the superclass). It's  essentially a variation of  like construct in PL/1.  The new concept here is to consider any structure as a new type and use type checking mechanism to prevent certain errors.

Thus, whereas in reality in Java you activate a procedure by calling it, sometimes in Java books it is incorrectly called sending of a message to the method. A new structure is no longer built by extending an existing structure, but by defining a subclass which inherits its superclass. A positive site of all this OOP blah-blah-blah is that many people learned for the first time about the important notions of data type, encapsulation, and of information hiding. This alone would have made the leaning of Java worthwhile, even if one didn't actually make use of its later on.

From the point of view of teaching OOP should probably be treated as an important aspect of programming in the large more like a methodology that a basis for a universal language. IMHO it should logically follows programming in the small and requires sound knowledge of procedural programming. And it should be compared with alternative method of integrating components like traditional shells, REXX and Perl.   In any case due to complexity Java is far from being the best first programming language. It's too far from the underling machine architecture of Pascal, C,  Modula. Even Perl and REXX are somewhat better.  They are much easier to understand than OOP approach and  they are sufficient in most cases for writing small and medium size programs.

Perl is a interesting example from the pinot of view of viability of OOP as a universal paradigm for programming in the large. Object-oriented features in Perl are somewhat counter-intuitive to the Perl way of life. At its heart, Perl is a language for creating scripts to handle routine text-processing tasks. Object-oriented design requires careful planning and adds a additional layer of complexity to the software development process. Why add this complexity to Perl?  It's a very useful language even without this layer.

OOP-orientation should not be a language issue. It is more a methodology, which, ideally, should be available in any language, but it is not suitable to any problem. Things that have state and change their state are natural candidates to be represented as objects.  Here are some guidelines to help decide if an object-oriented approach is appropriate:

1. Does your code manipulate a data structure that directly corresponds with a real-world object or that you can
   naturally think of as an object?
2. Is there a group of variables that you can group into structure or that are processed by the same set of functions?
3. Is there a group of functions that only operate on a defined set of variables?
   

If the answer to any of the above questions is "Yes", then you might benefit from an object-oriented approach.  Otherwise you will be in much better shape using regular procedure-oriented approach.  I think that GUI-centered programs benefit from OOP approach most.

I would like to stress the importance multithreading in Java. As for paradigm shift, Java can be compared to introduction of a local LAN instead of mainframe. That mean that we now have a bunch of small, autonomous PCs each with own CPU, communicating with each other via messages over the net. It takes some imagination to see a simple procedure call as a real  message passing mechanism -- only threads communicate through real messages. So true object model is intristically connected with multithreading, yet this connection is not understood well. True message mechanism presuppose that object (autonomous PC with its own CPU)  was active before receiving it and will be active after processing it.  To certain extent real OOP-style is a special case of concurrent programming.  

I would also like to see comparison of polymorphism, encapsulation, and inheritance with other approaches to programming in the large, for example with UNIX paradigm of shell programs that call small C-programs. For example as for encapsulation UNIX paradigm is as good as implemented in Java. All we have to worry about is what will be visible from the outside of UNIX utility are parameters one input and one output stream. Unix utilities are limited to one input and one output stream. But this is not critical limitation of the pipe model: for example VM/CMS pipes can have multiple input and output streams.

Polymorphism, means that object type can vary. Probably the easiest way to achieve polymorphism is to represent everything as a text string,  Of course you need to pay for this.  BTW polymorphism has nothing to do with inheritance or any other OOP mechanism.  Moreover polymorphism and generic programming to certain extent contradict OOP idea of inheritance.

If one discard all this OOP-oriented blah-blah-blah, inheritance is just a useful mechanism of working with structures. It is simple, yet a very powerful mechanism to identify and extract repeated part of structures. Inheritance brings "classification" into focus.  So programmers with a good classification skills will benefit from this approach most. Those that do not have these skills would most probably a pain a the neck for those poor folk that will mantage thier programs, if any.

I would like to stress it again that  from the point of view of design the most important part of Java is a built-in multithreading. Other than that Java is pretty much "politically correct" C++. Threads are active objects, much like actors in actor based languages. They do not need to receive a message to be in the "active" state. They are independent and concurrent objects and really can communicate through asynchronous messages. Name of the method became like a kind of unique mail addresses. 

Spots on the Sun: Are we walking right into McNealy's trap ?

Java is not an open source product and I'm disturbed about handing over control to Sun, because of their track record. Sun's treatment of other server-making companies (Digital in particular) in the past can easily be likened to Microsoft's treatment of Internet content providers in regards to Netscape. This suggests that if Java takes over, Sun will become the next Microsoft. I don't like the fact that Sun - a company that has proven it is just as ruthless and bullying as Microsoft when having similar advantages - might control the important Internet standard. We screwed up by handing over control to Gates with Ms-Dos and Windows -- so what it the reason of handing control to McNealy with Java. For years, McNealy has talked the talk of open systems, taunting Microsoft, challenging it to put its Windows APIs into the public domain. It's time for McNealy to put up. Or shut up and let Java die.

Sun treatment of Java is very controversial. Sun can't/hasn't built a Java VM for Intel processors that is light and fast. Microsoft seems to know this stuff better. Sun is first and for most a developer for its own platforms. Also if Sun is going to charge royalties for every copy of the product other companies develop using Java companies will look at going back to C++ to avoid paying royalties for the use of a language and compiler.

Now about difficulty of having a single JVM.  All the fuss between Sun and Microsoft was because MS wanted to do their own JVM and add stuff to it. Yet the main (and only?) advantage of Java is portability -- 'run anywhere'. Without open VM this will never materialize and now it is probably to late to save Java by opening VM. We're all back to square one except W Gates III has a very big grin on his face. In late 1998  Sun started realizing that Java will remain a very poor application platform compared to the Win32 API, but may be it's too late. As with most things made by man the genie of diversity cannot be kept in the bottle.

I think Java needs:

1.The Java API should reside with an open, neutral standards committee.
2.Better local applet caching and versioning.
3.Better authentication and verification. 
4.An independent testing facility to verify that Java applets meet specifications.
5.Better tools.

I think there's no greater danger than letting one company control the language. IBM showed it with PL/1 all too well. 

Conclusions

Java should be considered a competitor/replacement  to VB and PowerBuilder, but to much less extent to C/C++.  Beans are the most important productivity enhancement in Java and are especially important in a corporate environment.  Despite its good qualities, Java appeared on the scene after its competitors were already established. Whether Java advantages are enough to persuade the hundreds of thousands of VB and Power Builder out there to switch remain to be seen.

Java (and OOP in general, irregarding the amount of books published or money OOP missionaries make ;-) need to stand the test of the time. Don't put all eggs into one basket. It's more wise to consider Java as yet another (although important) programming language. Java is more suitable to programming in large than low level programming. Knowledge of C/C++ is very important for a Java programmer -- in real projects part of the solution (probably up to 20%) are better written in C as native methods.

As of v.1.2 Java is still immature language and pace of change is too high for Java to be used for large scale projects.  For pilot projects one needs the right people, a lot of training, and right tools.  Java will never replace other languages. It will be just one more language suitable for particular areas. Currently the most promising areas for Java are:

• Browser-based frontends for applications;
• Applications that could benefit from multithreading;
• I/O bound applications especially Internet/Intranet and database application development where slow execution is not a disadvantage;            
• Financial applications were currently Smalltalk is used;
• Intranet middleware (server side Java);
• Small and medium component based projects;

Outside GUI-based application, servlets, database applications and a limited number of areas  well served by OOP paradigm, Java it does not matter much and will not give a significant boost in a programmer productivity.

Copyright 1998-99, Nikolai Bezroukov.   Permission is granted to make and distribute copies of this article as long as the copyright and this notice appear on all copies.