Most Helpful Customer Reviews
58 of 60 people found the following review helpful:
1.0 out of 5 stars
Very disappointing, June 30, 2004
This review is from: Hardcore Java (Paperback)
In the preface, the author states that the goal of this book is to transform a developer from the intermediate level to a true guru. In the back cover it even promises that "you'll master the art of writing error-prone (sic!) code", and the reference to "error-prone code" sadly finds its confirmation once one starts reading. It takes about two chapters to demolish the author's credibility as a guru, and you will be reading the rest of the book with a skeptical eye, doubting every assertion that looks questionable and suspecting that the author is talking well above his level of competence, and patronizing about it too! The first chapters are an atrocious review of some Java concepts, densely packed with serious mistakes, not typos, mistakes (plenty of typos too). As an example, on page 9 the definition of the `for' statement is wrong, a simple check of the Java Language Specification would have spared the author some embarrassment. On page 15 the author gives us wrong rules for labels in Java, and in the same page he confuses the logic of the `break' and `continue' statements, providing also a logically wrong code example, just to screw-up things even better. I would not know how to describe the section on "Chained deferred initialization" on page 53, "raving" maybe. This one is cited in the errata page at oreilly.com, and the "author regrets that it slipped through the proverbial cracks". I am more concerned that something like that has been actually written (complete with code samples!), than that it has passed unscathed through editing and reviewing. Let's hope it was written by somebody else playing with the author's laptop. Somebody who does not know what JVM means. There are also less severe but equally confidence-abating points, like, on page 25, the form: new String("A button to show" + text); which we should not find in books for guru wannabes. The author is probably a productive software architect, some points, later in the book, are interesting, though nothing could be defined advanced, but he does not know Java better than an average developer, and this book does not add very much to an intermediate level, apart, maybe, from a warning about writing books: writing a book can transform you from a good developer into a bad author. It is sad that we are flooded with such mediocre and unprofessional "error-prone"publications from such once reputable publishers, from time to time I still re-read and enjoy the conciseness, clarity and value of classics like K&R's "The C Programming Language" and I wonder why today's output is so vastly inferior. As one of the few exceptions, I strongly recommend Bloch's "Effective Java" (Addison-Wesley) which is truly a book written by a guru. After reading that one, "Hardcore Java" will seem even emptier.
Help other customers find the most helpful reviews
Was this review helpful to you? Yes
No
32 of 34 people found the following review helpful:
2.0 out of 5 stars
Number of errors distracting and weak wrt "why do this", May 26, 2004
This review is from: Hardcore Java (Paperback)
A typo from the back cover sums things up, "Also, you'll master the art of writing and maintaining bulletproof and error-prone code...". I suggest going to the O'Reilly website and reading the errata before buying. Another one of my favorite lines in the book is, "The only way to clear an entire bit...". Anyway, why is there a 5 page discussion on bit manipulation in a book entitled Harcore Java? I wanted to like this book. There is some good advice here, but you have to sift through a lot of text to find it. The first chapter, of 42 pages, contains a lot of very basic beginner type information and could be reduced to:
1. Chain constructors because...
2. Don't hide exception information...
3. Make the default case of an if/else or switch be an assert because...
Discussions about every object descending from java.lang.Object, if statements, ternary expressions, for loops, break, continue, labels, and a reminder that System.exit() causes your program to exit, are misplaced in all but the most basic of books for beginners. That's not how this book is advertised. The author mentions assert and takes a swipe at a discussion on assert versus the various runtime exceptions. A good opportunity to discuss Design by Contract and how it's core tenants will lead to asserts and NOT IllegalArgumentException (and it's ilk) is missed entirely. This is the kind of information I would expect in a Hardcore book. The author appears to really like reflection. Too bad there are no good examples on why you would want to use reflection, such as dynamic mock objects, overcoming a few difficulties while unit testing, specific library implementations (making JMS messages look like function calls, for example), etc. Instead we get a toString() implementation, a discussion on beans/introspection, and an example unit test that has very limited scope. The author suggests mayby GUIs could be built using reflection, but fails to expound on this fantasy. Imagine every GUI looking like a simple properties editor. This is not the kind of statement you throw out and don't attempt to back it up. At least the reader is given a warning, although slight, about the performance of using reflection. The chapter on Proxies is made up of a discussion on the Proxy Pattern and dynamic proxies. The first half of the chapter is a rehash of a well known pattern and there are no reasons given why you'd ever use a dynamic proxy. The chapter on references covers no new ground. The one example of weak references in listener lists skips over the problem that, often, the only reference to the listener is in the list iteself. Otherwise, Sun could rewrite their listeners and clear up lots of leaks. The chapter on JDK 1.5 contains some errors likely related to changes made while the book was in production. Anyway, there's nothing here you couldn't find online. The chapter on immutable objects has good advice. Too bad examples later in the book don't follow the advice. In the section on Constraints the author calls them, "reusable and immutable objects", yet in the very next example doesn't make the private data final. Eat your own cooking before asking us to eat it too. One last thing, the book is way over priced. It should be $20 and about 150 pages smaller. Of course, then it would have to be retitled, "A Few Java Tips".
Help other customers find the most helpful reviews
Was this review helpful to you? Yes
No
13 of 16 people found the following review helpful:
2.0 out of 5 stars
Full of errors, avoid, April 20, 2004
This review is from: Hardcore Java (Paperback)
This book has many errors, both typographical and factual. A lot of the advice is dodgy, to say the least. My impression is that the author is trying to write beyond his competence level, but at the same times manages to be patronizing. I'm currently preparing a (practically) page-by-page critique of the problems with this tome. I'll publish a link here when I have a substantial section completed. (Note - this goes way beyond the errata published on the O'Reilly site.)
Help other customers find the most helpful reviews
Was this review helpful to you? Yes
No
|
