Rating: 
Summary: Number of errors distracting and weak wrt "why do this"
Review: 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".
Rating:
Summary: Number of errors distracting and weak wrt "why do this"
Review: 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".
Rating: 
Summary: every programmer should understand these concepts
Review: Don't let the name fool you: except the last chapter on Tiger JDK 1.5, there is nothing hardcore about it. Every Java programmer should understand all the concepts in this book. Read the table of contents and buy the book only if you aren't completely comfortable with each topic.
Rating: 
Summary: Newer prints of this book are better...
Review: I purchased a copy of this book a couple of months ago and was fortunate to obtain a more recent printing than the earlier reviewers probably had. There were still some errors and typos of various levels of severity, but quite a few fewer than the earlier printings. This, together with the O'Reilly errata page for the book and a small bit of work on my part involving the use of scissors and a glue stick, gave me a book which has become very useful to me at work. Hopefully, even more recent printings will be even better.
These annoyances aside, I am very happy with the book and what I was able to learn from it.
Rating: 
Summary: Very disappointing
Review: 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.
Rating:
Summary: Good explanations of proxies and References
Review: The author is certainly spot on about saying his book is not for Java beginners. What Simmons tries is to take you beyond the scope of most Java books, that first have to teach syntax. He assumes you are quite comfortable with Java. But he discusses topics that may give you a deeper understanding. He starts off simply enough, by emphasising that you should use "final" where ever it is made possible by the logic behind your code. The idea is to push a bug that might violate the logic into being found at compile time rather than at run time. Amongst later topics is proxies. You might be familiar with these, in CORBA, EJB and RMI. But of all the Java texts I have read, Simmons has the clearest, most lucid explanation of proxies. A simple description that cuts through the necessarily detailed clutter often used elsewhere. There are chapters of other books, and indeed entire books, on each of CORBA, EJB and RMI. But in the involved explanations of each, though the term proxy may be used, there is often lacking a simple unifying description, encompassing all three. Simmons also has a chapter on References, which are often neglected. This may be the hardest chapter to understand. But potentially the most useful, in minimising your memory footprint.
Rating: 
Summary: First impressions quite ok
Review: The author makes the point in the preface that this book is intended for an intermediate to advanced audience. I'm coming from c++ with some limited Java experience and this book is quite readable for me.(I'm only up to page 42, but understanding everything..) His code examples are well done. I think the value of this book is in all the little gotchas you might otherwise have to learn about at the debug stage.
Funny how many of the subtle issues from c++ show up in java, only manifesting themselves somewhat differently. This book has stuff from jdk 1.4 like assert and shows how to take advantage of it. Simmons exhibits techniques that make for more elegant, less redundant code. If you've been programming in java for less than a year or two I'm sure this book is worth your time.
Rating:
Summary: First impressions quite ok
Review: The author makes the point in the preface that this book is
intended for an intermediate to advanced audience.
I'm coming from c++ with some limited Java experience and this book is quite readable for me.(I'm only up to page 22, but understanding everything..)
His code examples are well done.
I think the value of this book is in all the little gotchas you might otherwise have to learn at the debug stage.
He also conveys a few techniques that make for
more consise(elegant) and less redundant coding..
If you've been programming in java for less than a year I'm sure this book is worth your time.
Rating:
Summary: OK but not a Java bible
Review: The author of this book recently visited the Java Forums to discuss it and it was noted that he had a misundertanding of the protected scope. That's a pretty fundamental part of Java. From the sample chapter on the O'Reily site I've come across a few things I find to be poor advice, such as making Singletons extensible and spending time trying to speed up Logging. Other than that, this book does cover a lot of poorly understood and misunderstood topics in Java. Just don't take all advice in this book as law. A good starting point but there many other schools of thought.
Rating:
Summary: Nice intro to slightly advanced Java...
Review: The title "Hardcore Java" is definitely overkill. A better one may be "Stuff a new Java developer might not know yet". This book is full is little nuggets of "oh, good idea" and "oh, I never knew that". But don't expect to be a guru after reading it by any means. Lean towards 'Effective Java Programming Language Guide' for a thorough, advanced discussion of the Java language. For it's price, it's not bad, it seems relatively cheap compared to many books on the subject. It's easily a weekend read as well.
| 
