Rating: 
Summary: Very poor and shallow
Review: It's a shame that Sun fellows can only come with so little material about Java performance.
Even JavaWorld articles contain more information about the subject. For example, when
talking about optimizing the serialization process all authors can offer is to set more
fields to be transient. Is that all you can think of ? How about custom writeObject, folks ?
When discussing data structures and algorithms all authors can say is "choose accordingly,
it depends". Oh, thank you, I didn't know that ..Well, it seems to be that this books was written in a couple of days without any serious
research. Too poor and shallow. All I got from this book is a couple of facts
regarding GC, HotSpot and some other things I didn't know before. And first chapters described
the general tuning strategy pretty well, actually. But that's it. Shame on you, folks.
Just read "Java Performance Tuning" by Jack Shirazi if you have nothing to say.
Or at least make some Web-reserach before publishing a book.
Rating: 
Summary: How to Tune Swing
Review: The focus of the book is on tuning single user GUI (Swing,AWT) applications and as such, offers some good insight on this subject. Chaper 2, The Performance Process, Chapter 3, Measurement is Everything, and Chapter 4, I/O Performance although thin, offer practical information that extend beyond Swing. The focus in subsequent chapters narrows as the authors prepare the reader for the more advanced techniques used for tuning Swing applications. Those tuning server applications will find that they are not able to use a number of techniques or advice offered by the authors.
Rating:
Summary: Shallow coverage with some redeeming utility
Review: The table of contents is deceptive, because all of the important optimization topics are covered, including the Java-specific ones. The problem is, most of these topics are not covered in any depth beyond a simple introduction. I like terse books and believe most books about computers these days are way too fat; my hats are off to Addison Wesley for controlling that tendency with well edited books in this series. This book is thin at 230 pages, but unfortunately, a lot of that is filler of the "let me tell you what I'm going to tell you, tell you, and then tell you what I told you variety. The advice is generally sound, such as "use a profiler to decide what to optimize", but all too often the advice stops there. One learns that linked lists are fast for deletes and array lists are fast for random access. But what if neither has the performance characteristics you need? I would recommend Jon Bentley's "Programming Pearls" for someone who really wants to get a feel for optimization through a number of tight case studies. The examples may be C, but they're insightful and more applicable to the problems you're likely to face than the ones encountered when writing the Swing or Collections classes themselves. Then go out and use a serious optimizer like Quantify, which is essentially what the authors of this book suggest. At that point, you'll wonder why the authors stopped their review of Collections with Sun's built-in implementations. The code for running mulitple programs and controlling class loading in Chapter 6, though I have not tried it, is interesting and something I'd not seen elsewhere. Other diversions, such as timers and threading in Swing are covered elsewhere. What would have been helpful is a detailed look at debugging threading performance, say through object, resource or thread pooling (an idea dismissed earlier for "small objects"). One glaring omission is a serious micro-benchmarking of basic operations. I found the comparison of speed when using final vs. non-final classes or methods to be startling in practice, and numbers here would help. Similarly, access times for hash tables vs. arrays, simple object construction times, floating point vs. integer arithmetic times, object variable vs. local variable access, etc. There are some wonderful micro-benchmark applets on the web with this functionality. What you'll learn is that up-casting takes forever, so any use of built-in collections/iterators for performance-critical operations will do you in. I found the constant sales pitch for the Sun HotSpot (TM) Virtual Machine a bit tiring. It concludes with a recapitulation of the marketing materials in Appendix B. It is alternately described as "highly optimized", "state-of-the-art", having a "superior memory allocator", "ultra-fast", having "excellent multiprocessor performance characteristics", having "agressive inlining", having "excellent paging", etc. etc. The appendix devoted to HotSpot (TM) is particularly noteworty for its omission of any profiling information!
Rating:
Summary: Shallow coverage with some redeeming utility
Review: The table of contents is deceptive, because all of the important optimization topics are covered, including the Java-specific ones. The problem is, most of these topics are not covered in any depth beyond a simple introduction. I like terse books and believe most books about computers these days are way too fat; my hats are off to Addison Wesley for controlling that tendency with well edited books in this series. This book is thin at 230 pages, but unfortunately, a lot of that is filler of the "let me tell you what I'm going to tell you, tell you, and then tell you what I told you variety. The advice is generally sound, such as "use a profiler to decide what to optimize", but all too often the advice stops there. One learns that linked lists are fast for deletes and array lists are fast for random access. But what if neither has the performance characteristics you need? I would recommend Jon Bentley's "Programming Pearls" for someone who really wants to get a feel for optimization through a number of tight case studies. The examples may be C, but they're insightful and more applicable to the problems you're likely to face than the ones encountered when writing the Swing or Collections classes themselves. Then go out and use a serious optimizer like Quantify, which is essentially what the authors of this book suggest. At that point, you'll wonder why the authors stopped their review of Collections with Sun's built-in implementations. The code for running mulitple programs and controlling class loading in Chapter 6, though I have not tried it, is interesting and something I'd not seen elsewhere. Other diversions, such as timers and threading in Swing are covered elsewhere. What would have been helpful is a detailed look at debugging threading performance, say through object, resource or thread pooling (an idea dismissed earlier for "small objects"). One glaring omission is a serious micro-benchmarking of basic operations. I found the comparison of speed when using final vs. non-final classes or methods to be startling in practice, and numbers here would help. Similarly, access times for hash tables vs. arrays, simple object construction times, floating point vs. integer arithmetic times, object variable vs. local variable access, etc. There are some wonderful micro-benchmark applets on the web with this functionality. What you'll learn is that up-casting takes forever, so any use of built-in collections/iterators for performance-critical operations will do you in. I found the constant sales pitch for the Sun HotSpot (TM) Virtual Machine a bit tiring. It concludes with a recapitulation of the marketing materials in Appendix B. It is alternately described as "highly optimized", "state-of-the-art", having a "superior memory allocator", "ultra-fast", having "excellent multiprocessor performance characteristics", having "agressive inlining", having "excellent paging", etc. etc. The appendix devoted to HotSpot (TM) is particularly noteworty for its omission of any profiling information!
Rating: 
Summary: Improve your Java by shedding its myths
Review: There are a number of things everybody 'knows' about Java. Bad things such as "It's slow (but can be speeded up by calling native methods)" or good things such as "It doesn't leak memory". Unfortunately, like most things, the truth is more complicated. Wilson and Kesselman have done an excellent job of getting under the bonnet (or hood for those in the US) of Java whilst firmly remaining practical rather than theoretical. I bought the book because we suspected memory leakage problems in one of our applets but couldn't find much information on the subject elsewhere. The net result is that we've had our eyes opened to a number of issues we weren't aware of and have been able to tackle them with informed confidence rather than ill-educated guesswork. A particular bonus is the information on benchmarking. So often we find we develop solutions on the basis of ease of coding rather than performance (not always bad thing). What I've found now is that I have greater confidence in both trying out different solutions and then concrete evidence with which I can justify my decisions to others. Though not for beginners, I would reccommend this book as a good one for expanding your knowledge of how to deliver good, practical, faster and more robust Java. Being able to give sound background information on why you write a piece of code in a particular way is an important step on the way from being a developer to being a key developer.
Rating:
Summary: Improve your Java by shedding its myths
Review: There are a number of things everybody 'knows' about Java. Bad things such as "It's slow (but can be speeded up by calling native methods)" or good things such as "It doesn't leak memory". Unfortunately, like most things, the truth is more complicated. Wilson and Kesselman have done an excellent job of getting under the bonnet (or hood for those in the US) of Java whilst firmly remaining practical rather than theoretical. I bought the book because we suspected memory leakage problems in one of our applets but couldn't find much information on the subject elsewhere. The net result is that we've had our eyes opened to a number of issues we weren't aware of and have been able to tackle them with informed confidence rather than ill-educated guesswork. A particular bonus is the information on benchmarking. So often we find we develop solutions on the basis of ease of coding rather than performance (not always bad thing). What I've found now is that I have greater confidence in both trying out different solutions and then concrete evidence with which I can justify my decisions to others. Though not for beginners, I would reccommend this book as a good one for expanding your knowledge of how to deliver good, practical, faster and more robust Java. Being able to give sound background information on why you write a piece of code in a particular way is an important step on the way from being a developer to being a key developer.
Rating:
Summary: Excellent
Review: This book covers many parts of Java. There are lots of tips on how to make your code faster. I really liked the chapter on "RAM Footprint." The chapter about JNI was also really useful. The writing style was easy to follow and the example code is very clear. You should get this book.
Rating: 
Summary: Good resource for real programmers
Review: This book neatly explains some of the performance issues of java application development. Real programmers would gain a lot by using some of the techniqes shown by the author. BUY IT ! ONLY FROM AMAZON
Rating:
Summary: Performance, Performance, Performance this book has it
Review: This book opened my eyes to alot of issues that most java programmers dont think about. If you are looking to get better performance from the systems you are writing that you should read this book
Rating:
Summary: Excellent
Review: Well-written, very technical, and without the useless filler that you see so often in computer books.
| 
