Softpanorama Bulletin
Vol 10, No.02 (April, 1998)

Prev | Contents | Next

Note on  an uncritical acceptance of OOP

Extracted from Review of "Thinking in Java"

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 pretty decent (i.e. 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.

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.

Chapter 3 "Controlling Program Flow"

In Chapter 3 the author included both  the explanation of  Java operators with the explanation of control flow constructs. It's OK to do so, but I believe that chapter would better be separated into two (the second starting with "Execution control" on p.130).

Java operators are explained well with a lot of examples. At the same time examples does not represent typical patterns of the usage of control structures in Java. There are much more like laboratory experiments that help to understand the syntax and semantics of the control statements. And they need to be refined -- the example of the program on pages 120-129 contains a lot of useful experiments, but it's too long and horribly typeset. In future editions the fond probably should be smaller and it could be typeset in two columns. Or may be its content can be reworked into a table and the program provided only in electronic form.

Now let's talk about treatment of the control structures. I believe it should be expanded as here Java make a "revolutionary" decision to get rid of goto statement. And as one knows from history revolutions usually lead to sufferings,  at least at the beginning.

Generally in order to check the quality of such a chapter in any Java book one can use the following test:

• if the book mentions that any program can be written using only three control structures -- recycle it -- it's a trivial fact that any program can be written using only three control structures and it's really easy(and very stupid) to do so. Don't be fooled by references about the C. Böhm and G. Jacopini theorem, which supposedly proves that any control structure can be represented by an equivalent control structure with just three basic control blocks - while loop, if statement and sequential composition. From the mathematical point of view, the result is trivial since any program can be represented in a form like:


while(stmt > 0)
    if (stmt==1) { ... ; stmt = 3;   }
    if (stmt==2) { ... ; stmt = 4; }
    if (stmt==3) { ... ; stmt = 5;  }

...

...

...
}

• whether it mentions Donald Knuth's article "Structured programming with goto statements." If not probably it's better to get another or additional book.
• whether it discuss short-circuit and and or operation in if statements and while loops. If not the chapter is superficial.
• whether if shows how to program loops with two index variables.
• whether it contains an example of programming in Java of some classic algorithm -- at least simple search. If not, it's probably an introductory book.
• contains at least some diagrams clarifying complex issues such as multilevel break and continue.

A use of this test on Chapter 3 of TIJ is a good exercise that is left to participants of the seminar.

The problem with Java is that IMHO Java designers did not understand issues of safety of control structures well. IMHO they made three important mistakes:

• they fail to make the use of curly braces mandatory after "if" "do", "while", "for" (that can be probably compensated by warning in the compiler). 
• Suffix after closing curly braces greatly increase safety of nesting as and decent PL/1 programmer knows. That feature can be imitated with comments and some kind of postprocessor.
• They omitted useful shortcut for else if (elif). Yet another important safety feature is so called foreach loop that prevents a lot subtle errors with indexing of an array when one just need to process all elements in some way.

The only extension that I see from rather Spartan set of C control structures is a multilevel break/continue with the label. It's useful bit its insufficient to compensate for the absence of goto.

As a result Java is neither well suited to writing complex algorithms like algorithms from the Art of Computer Programming by D.Knuth nor it represent the state of the art in safe control structure. There is no such thing as a free lunch and if one drops goto from the programming language one needs to add a lot of additional specialized "structured" statements to compensate for that. Or the language will remain crippled. Bruce Eckel recognize that the decision to drop rather than restrict goto was probably a mistake (p.137). But he does not provide any recommendations for compensating Java weaknesses.

Here I would like to stress  again that one should consider Java as a better VB, not a better C++.  But it's really unfortunate that Java did not benefit from additional control structures found in other modern languages, for example Perl and Icon.

The author correctly includes a discussion of the return statement into the control structure section as in Java the return statement can sometimes compensate for the absence of a goto statement.

Studying of control structures in programming languages is often provided under the umbrella of so called structured programming. The idea of "real" structured programming, or "structured programming with goto statements" is that one could write, understand and modify the program much more easily by organizing and coding computer programs in which all control structures have a single entry and a single exit point. It is this idea that constitute rational, useful part of the whole structured programming movement.

But there is a lot of religious junk around this sound idea (as around many other sound ideas). Some authors go too  far and declare that just three types of control flow are allowed: sequential, test, and iteration (kosher control constructs ;-).

Those who are interested in the study of a history of programming probably know that structured programming created probably the first strong religious movement in programming as scientific ground of usefulness of just three kosher control structures are very weak, if exist at all. Here I would like to cite Edsger W. Dijkstra -- a high priest of structured programming and verification (unlike many of his "structured" followers Dijkstra is a real computer scientist; before initiating structured programming movement, he invented several useful algorithms including semaphore synchronization; currently he is a professor at the University of Texas at Austin):

Summarizing: as a slow-witted human being I have a very small head and I had better learn to live with it and to respect my limitations and give them full credit, rather than try to ignore them, for the latter vain effort will be punished by failure.

Edsger W. Dijkstra, Structured Programming.

 

Like a lot of slogans, it looks appealing, but it was often used for the advocacy of "structured primitivism" writing of any program using only the "kosher"  control structures mentioned above. This "orthodox" structured programming movement now looks a little bit strange (much like an idea to verify each and every program instead of testing), but in the early 70es a lot people jumped on this bandwagon and tried to do what the apostles of the movement preached.  The remnant of this days is an entry in the famous Jargon File:

considered harmful

adj. Edsger W. Dijkstra's note in the March 1968 "Communications of the ACM", "GOTO Statement Considered Harmful", fired the first salvo in the structured programming wars. Amusingly, the ACM considered the resulting acrimony sufficiently harmful that it will (by policy) no longer print an article taking so assertive a position against a coding practice. In the ensuing decades, a large number of both serious papers and parodies have borne titles of the form "X considered Y". The structured-programming wars eventually blew over with the realization that both sides were wrong, but use of such titles has remained as a persistent minor in-joke (the `considered silly' found at various places in this lexicon is related).

 

Java control structures do not provide the possibility of programming each and every one-entry one-exit control structure without goto, so generally some additional computation needs to be specified. But again clever use of return and exceptions sometimes can compensate for this drawback.

Java has the following two statements to improve the control of execution of loops:

• continue -- start the next iteration of the loop (unlike Perl. Java allows no possibility of specifying a special block that is a part of the loop and that will be executed each iteration even if the continue statement was used).
• break  -- break out of loop; in Perl the same semantic has last.

Each of these statements can have suffix that should correspond to a loop label. In this case it applies to the loop labeled with the same label. So multilevel breaks are possible. 

Note on the structure of the for loop

For people who did not program in C the easiest way to remember the correct sequence of components in the for loop is by remembering the magic word "STAB" that corresponds to the following general scheme of the for statement"

       for (start; test; action) { body }

One can see that for loop consist of four parts. The for loop works well where the number of iterations of the loop is known before the loop is entered. The head of the loop consists of three parts separated by semicolons.  I recommend always to use the braces for the body of the for loop, even if the body consist of a single statement.

• The first or start part is run before the loop is entered. This is usually the initialization of the loop variable. The start part is executed only ones when the flow of control reach the loop.
• The second test part is a logical expression that returns true of false. The loop is exited when it returns false.   The test part  is evaluated at the beginning of each iteration and determine when to transfer control to the statement following the loop.
• The third is action part -- a statement to be run every time the loop body is completed. This is often an increment/decrement of the loop counter. The action part is executed on each iteration just before test part of the loop.

The continue statement

Java continue statement is used to start next iteration immediately without executing the rest of the of body of the loop. Use of continue in Java helps to avoid excessive nesting in the loop. For example:

One can see that the loop at the left is more difficult to understand that the loop at the right.

What Java is definitely missing -- Perl foreach loop

The foreach loop is similar to the "for..in" loop that can be found in many scripting languages including MS DOS batch language.  It has a built in iterator which iterates through each of the elements of an array or list. Here we do need to specify the order in which elements will be processed. Foreach can be generalized so that elements can be proceed in any order (those who programmed in assembler know that loops in reverse are slightly more efficient)  foreach is very convenient when modifying or processing several elements of an array or list that meat certain conditions.  For example

Cat X = new Cat[];

... ... ...

foreach (Cat c  in X) {

   if (c==my_cat) {found=1; break;}

}

if (found==1) {

}

Note that Java even with the foreach statement does not permit to program simple search loop without additional computation (flag found is used to determine whether we have found the element of an array or no).

In Java 1.2 one need to specify iterator to achieve the same effect, but it applies only to collections. For example

Collection c = new ArrayList();

... ... ...

Iterator it = c.iterator();

while (it.hasNext()) {

  System.out.print(it.next());

}

For Java 1.1 the ObjectSpace company created Generic collection Library for Java   similar to STL in C++. It's available from www.ObjectSpace.com.

Discussion of exercises and additional exercises

Exercises provided are somewhat weak taking into account that book is oriented on the programmers who know at least one programming language. IMHO it would be beneficial to rework them in the second edition of the book.

Some additional exercises

Exercise 1

Write a program that allocate an array of, say, N integer elements and then add elements(to the end of the array) from other preallocated and initialized array containing N*N elements with some of them repeating several times. When overflow occurred in a loop that search for an element of an array the program should print the message

Overflow occurred when trying to add the element <element>. Remaining elements are:

and print all remaining elements in N columns after that message so that each remaining element that is already in the first array should be printed in brackets. Recommenced test values for the second array for N=3 are

5 5 3 4 4 0 4 2 3

The error should occurs when the program tries to add element "0" of the second array. After the message the program should print:

0     (4)    2

(3)

Exercise 2

Program binary search algorithm and consider what control structure should be added to Java to program this algorithm most efficiently. 

Exercise 3

Explain how continue statement with label to external loop works in Java. What will be the value of i after continue in the following example. Will the external loop ever terminate ?

n=5;

i=5;

loop1:
   for(;;) {

      for (i=0;i<n;i++)
        continue loop1;
      }

   break;
   }

Useful links

• Control Flow Statements -- from the official Sun Java Tutorial by Mary Campione and Kathy Walrath
• Flow Control Statements - note on translation of control statements into machine code
• Control statement in programming languages
• Why are some people opposed to using the goto statement?

Some examples of "considered harmful" movement ;-)

• CSH PROGRAMMING CONSIDERED HARMFUL -- A popular "considered harmful" article.
• Interface Pointers Considered Harmful - Don Box  -- another example 
• mod_perl Archives Re Global variables considered harmful -- now for USENET newsgroup

Other links

• Control Structures
• Why OOP - Contents -- "Why Object-Oriented really is better than Structured" by Gary Warren King

Bibliography

C. Böhm and G. Jacopini, "Flow Diagrams, Turing Machines, and Languages with Only Two Formation Rules", Communications of the ACM 9
(1966), pp. 366-371.

E. W. Dijkstra, "Goto Statement Considered Harmful", Communications of the ACM 11 (1968), pp. 147-148.

E. W. Dijkstra, "Guarded Commands, Nondeterminacy and Formal Derivation of Programs", Communications of the ACM 18, (1975), pp. 453-457.

E. W. Dijkstra, "Notes on Structured Programming", in Dahl, Dijkstra and Hoare, Structured Programming, Academic Press, 1972, pp. 1-82.

D. E. Knuth, "Structured Programming with Goto Statements", ACM Computing Surveys 6 (1974), pp. 261-302.

Etc

Society

Groupthink : Two Party System as Polyarchy : Corruption of Regulators : Bureaucracies : Understanding Micromanagers and Control Freaks : Toxic Managers :   Harvard Mafia : Diplomatic Communication : Surviving a Bad Performance Review : Insufficient Retirement Funds as Immanent Problem of Neoliberal Regime : PseudoScience : Who Rules America : Neoliberalism  : The Iron Law of Oligarchy : Libertarian Philosophy

Quotes

War and Peace : Skeptical Finance : John Kenneth Galbraith :Talleyrand : Oscar Wilde : Otto Von Bismarck : Keynes : George Carlin : Skeptics : Propaganda  : SE quotes : Language Design and Programming Quotes : Random IT-related quotes :  Somerset Maugham : Marcus Aurelius : Kurt Vonnegut : Eric Hoffer : Winston Churchill : Napoleon Bonaparte : Ambrose Bierce :  Bernard Shaw : Mark Twain Quotes

Bulletin:

Vol 25, No.12 (December, 2013) Rational Fools vs. Efficient Crooks The efficient markets hypothesis : Political Skeptic Bulletin, 2013 : Unemployment Bulletin, 2010 :  Vol 23, No.10 (October, 2011) An observation about corporate security departments : Slightly Skeptical Euromaydan Chronicles, June 2014 : Greenspan legacy bulletin, 2008 : Vol 25, No.10 (October, 2013) Cryptolocker Trojan (Win32/Crilock.A) : Vol 25, No.08 (August, 2013) Cloud providers as intelligence collection hubs : Financial Humor Bulletin, 2010 : Inequality Bulletin, 2009 : Financial Humor Bulletin, 2008 : Copyleft Problems Bulletin, 2004 : Financial Humor Bulletin, 2011 : Energy Bulletin, 2010 : Malware Protection Bulletin, 2010 : Vol 26, No.1 (January, 2013) Object-Oriented Cult : Political Skeptic Bulletin, 2011 : Vol 23, No.11 (November, 2011) Softpanorama classification of sysadmin horror stories : Vol 25, No.05 (May, 2013) Corporate bullshit as a communication method  : Vol 25, No.06 (June, 2013) A Note on the Relationship of Brooks Law and Conway Law

History:

Fifty glorious years (1950-2000): the triumph of the US computer engineering : Donald Knuth : TAoCP and its Influence of Computer Science : Richard Stallman : Linus Torvalds  : Larry Wall  : John K. Ousterhout : CTSS : Multix OS Unix History : Unix shell history : VI editor : History of pipes concept : Solaris : MS DOS :  Programming Languages History : PL/1 : Simula 67 : C : History of GCC development :  Scripting Languages : Perl history   : OS History : Mail : DNS : SSH : CPU Instruction Sets : SPARC systems 1987-2006 : Norton Commander : Norton Utilities : Norton Ghost : Frontpage history : Malware Defense History : GNU Screen : OSS early history

Classic books:

The Peter Principle : Parkinson Law : 1984 : The Mythical Man-Month :  How to Solve It by George Polya : The Art of Computer Programming : The Elements of Programming Style : The Unix Hater’s Handbook : The Jargon file : The True Believer : Programming Pearls : The Good Soldier Svejk : The Power Elite

Most popular humor pages:

Manifest of the Softpanorama IT Slacker Society : Ten Commandments of the IT Slackers Society : Computer Humor Collection : BSD Logo Story : The Cuckoo's Egg : IT Slang : C++ Humor : ARE YOU A BBS ADDICT? : The Perl Purity Test : Object oriented programmers of all nations : Financial Humor : Financial Humor Bulletin, 2008 : Financial Humor Bulletin, 2010 : The Most Comprehensive Collection of Editor-related Humor : Programming Language Humor : Goldman Sachs related humor : Greenspan humor : C Humor : Scripting Humor : Real Programmers Humor : Web Humor : GPL-related Humor : OFM Humor : Politically Incorrect Humor : IDS Humor : "Linux Sucks" Humor : Russian Musical Humor : Best Russian Programmer Humor : Microsoft plans to buy Catholic Church : Richard Stallman Related Humor : Admin Humor : Perl-related Humor : Linus Torvalds Related humor : PseudoScience Related Humor : Networking Humor : Shell Humor : Financial Humor Bulletin, 2011 : Financial Humor Bulletin, 2012 : Financial Humor Bulletin, 2013 : Java Humor : Software Engineering Humor : Sun Solaris Related Humor : Education Humor : IBM Humor : Assembler-related Humor : VIM Humor : Computer Viruses Humor : Bright tomorrow is rescheduled to a day after tomorrow : Classic Computer Humor

The Last but not Least Technology is dominated by two types of people: those who understand what they do not manage and those who manage what they do not understand ~Archibald Putt. Ph.D

The statements, views and opinions presented on this web page are those of the author (or referenced source) and are not endorsed by, nor do they necessarily reflect, the opinions of the Softpanorama society. We do not warrant the correctness of the information provided or its fitness for any purpose. The site uses AdSense so you need to be aware of Google privacy policy. You you do not want to be tracked by Google please disable Javascript for this site. This site is perfectly usable without Javascript.

Last modified: March, 12, 2019