Subscribe to ...considered harmful        RSS Feed

Murach's Java Programming, 4th Edition

Icon Leave Comment
A review of Murach's Java Programming (4th Ed.)
Joel Murach,
ISBN 978-1-890774-65-3

Murach's introduction to Java would make an reasonably good textbook in a lecture-driven course. The explanations of individual procedures are clear and simple. However, as a guide for self-study, it is lacking in important areas. There is almost no coverage of some key concepts, and the explanations of procedures, while clear and simple, are thin and insubstantial. The book is almost entirely lacking in serious programming exercises, and mostly consists of a string of tutorial explanations of simple procedures. It is remarkable to note that a student could read the book from back to front and have no real idea of what a compiler is, what the JVM is, what an object actually is in Java, or what it actually means to call a method. The very diligent student would have a pretty good understanding of how to execute certain procedures - from basic ones like writing loops, testing equality, and manipulating arrays to more involved ones like calling methods and creating objects and working with some fundamental library classes - but they would have no idea why they might want to do these things from simply reading this book.
To his credit, Murach's procedural explanations cover in painstaking detail almost every aspect of the core language, and a selection of higher-level topics. Apart from an odd bit of confusion about the bitwise OR and AND operators, and the total omission of the bitwise shift operators, the treatment of the core language is complete and accurate. Moreover, his decision to address GUI issues through the use of the NetBeans GUI Builder is a nice trick for finessing the devilish complexities of writing Swing by hand. His treatment of file I/O is a nice covert exposition of the use of classes to accomplish a goal. These things are well done, and I'm glad to point them out. However, they are not enough to get me past the serious shortcomings of the book as a teaching text.
The book lacks two important elements for someone learning Java on their own. It does not address in any satisfactory way the logic of program design, and it gives the student very little in the way of exercises to test and solidify the knowledge they've gained, and to gain some understanding of how it fits together. These two elements fit together to structure material for easy retention. You introduce a problem, you provide the new material as a solution to that problem, and you give the student a way to put that new material to use, in the form of exercises. To omit one might be forgivable if the other were highly developed. To omit both is inexcusable: the student does not actually write any code at all in the first 158 pages of the text, and is never actually given a problem to solve from scratch, not even the classic units conversion or string-manipulation exercises that every learner of every language is required to struggle through.
Programming is the art of problem solving. Reducing a problem to its essentials and capturing those essentials in code is what programming computers is. To finish an 800-page tome about "Java programming" without having written a single program seems to me something of a waste of time.

There are some further issues, but they seem minor ones in light of the above. The lower-level details of the language are never even hinted at, even when they would clarify tricky topics, such as passing arguments by reference versus passing by value. This is a non-issue if you understand a little bit about the distinction between the stack and the heap, and a very difficult issue if you do not. Furthermore, raising or at least hinting at these issues is bound to strike some nerve of curiosity in some students, and this is worth doing on its own. It would seem a no-brainer to include this sort of information where it is relevant, but it is not included.
The book has some problems of style and layout which would not be major issues in a more effective text, but they certainly do not help in Murach's case. The book overall could have benefitted greatly from the attention of a good graphic designer. It looks unfortunately like a simple dump from a Word file, and the lack of any graphic flair emphasizes the lackluster text. A few callouts or sidebars would guide the eye to critical points along the way, and break up the monotony a little. A good designer might have also questioned the basic layout of the book, with text and examples on facing pages. This works well if each and every piece of text occupies one printed page and there is a full page's worth of examples for each unit of text, but it becomes awkward when the text continues from page 566 to 568, interrupted on page 567 by the examples for both pages. This design decision becomes still less tenable when you realize that there is a striking amount of white space at the bottom of many left-hand pages, and that something like a third to a half of each right-hand page is devoted to summarizing the material on the facing page. In a book nosing up to the 800-page mark, and weighing in at several pounds - certainly heavy enough to make it uncomfortable to read without a book stand! - this seems a flaw worth addressing.
It would also be nice to see more effective use of typographic conventions to organize code and other literals in the running text. Typically, technical works will distinguish typographically among command names, function names, technical terms (at least on first use), and output samples, at a minimum. Murach uses italics to call out technical terminology on first use, and everything else is an undifferentiated wall of text. This causes some confusion, for example:


In the examples, the first statement calls the nextDouble method of the Scanner object named sc to get data from the console. The second statement calls the toString method of the Date object named now to convert the date and time that's stored in the object to a string

This would not require a careful re-reading if the code literals - toString, Date, now, and string - were set off typographically, not to mention capitalized correctly. In one font, with no decorations, these sentences become so much muck, until the reader attacks them with a fine-toothed comb.
Perhaps it seems like carping to pick on the graphic design, but it seems to me that Murach's strongest suit in this book is the clarity of his explanations of individual procedures. Good design would have supported that clarity immensely, so this is something of a missed opportunity.
All in all, I'm sorry to say that I can't really recommend this one, but there will be a Java 8. If Murach uses that release as an occasion to revisit some of the issues with the current edition, his next edition could be improved by leaps and bounds. There is nothing wrong with Murach's descriptions of procedures, and his presentation is admirably complete. The addition of some material on program design and fundamentals of the language, plus better handling of references and a dash of graphic design could easily make the next edition a contender.

0 Comments On This Entry


Trackbacks for this entry [ Trackback URL ]

There are no Trackbacks for this entry

May 2022

151617 18 192021


    Recent Entries

    Recent Comments

    Search My Blog

    7 user(s) viewing

    7 Guests
    0 member(s)
    0 anonymous member(s)