Rating: 
Summary: Interesting but outdated
Review: If you're new to performance tuning, and you want to know what it's all about, then this is the book you need. It contains a wealth of tips and techniques, which *will* allow you make a grand entrance on a performance tuning job.
If you want an update on the latest performance-related features of Java, then you definitely don't want this book. It's just to outdated.
Rating: 
Summary: Common-sense advice on what to tune and what to leave alone
Review: Java Performance Tuning reveals how techniques such as minimizing object creation, replacing strings with arrays, and other techniques can improve code performance. Author and Java expert Jack Shirazi also offers common-sense advice about what to tune and what to leave alone in order to maximize performance while avoiding damaging a program's architecture. Highly recommended as both an instruction manual Java users, Java Performance Tuning is a very well presented, highly recommend, "user friendly" reference that is enhanced with performance tuning checklists enabling developers to make their tuning as comprehensive and effective as possible.
Rating: 
Summary: a good book, but do you really need it?
Review: Java Performance Tuning would be a good book to have if you have a seriously performance intensive application or for someone who just really dug performance issues. But it wouldn't be of interest to most people. Most programmers should be able to do all the performance tuning they need to do with a program like Optomizeit.
Rating:
Summary: Excellent Read!
Review: Near the end of every major Java project the topic of performance comes up. In some cases the use of a pricy profiling tool is mentioned or quickly acquired. But, these tools while showing you bottlenecks, etc do little in the way of dealing with the "now what?" of after you've profiled a system. While some obvious improvements can be made (e.g., removing exceptions as part of normal execution flow) many times the bottleneck is left under-addressed because it is believed that there is little more that can effectively be done. This book is a GOLD MINE of taking a given area/topic and squeezing out more and more. Replacing Strings w/ char arrays, design points for doing more effective parallelism with threads, etc all of these topics are invaluable. Also as the author states many of these things should be done only AFTER you've identified that spot as a bottleneck in your system (and not blindly implemented everywhere). When performance is on your plate this book is a must have. Personally, if I were a VM Gear or a KL Group given the price range of these tools I would include (at any cost) a copy of this book as a general tuning guide to complement their user's guide for the profiling tool.
Rating: 
Summary: NOT recommended! Full of impractical suggestions
Review: Newbies, please take the author's sugessions with a big pinch of salt, please do not go ahead and rewrite JDK classes as author says, and about 'ensuring that the defragmentation procedure does not disrupt your own use of disk sweet spots' - ask the author how. I must confess some parts of the book (a very small part though) are informative, and that alone earned the second star in this review, else I would have had no compunction to stick it with a single star.It would not take more than a casual browse-thru for an experience java developer to call the bluff, I'm concerned that some newish practitionars might end up in deep water following these suggestions. Firstly, this book comes nowhere near discussing any J2EE performance topics, though nowadays it's difficult to find plain vanilla java implementations. The author did devote a whole chapter on distributed computing, I expected to find discussions on tuning parameters for EJB deployment descriptors there; nope, he decided to discuss server-object implementation of CORBA and RMI instead, he compared them, compared different communication layers and other stuff, in short he explained to you everything about the components you have no control over! This book in most cases concentrates on topics only of academic interest, except for some discussion on code styles I found next to nothing to take away from this book. Author has given enough number of tables with performance comparisons to fill half the space for the book, but understand that these results are only indicative of what might happen for a particular program on a particular system, I'm not even going to the detail to tell you that in some cases the results and table heading say completely different things (e.g. Table 7.2 Speedups using Exception-driven loop termination actually compares timing across different switch approaches), that reminds me, I have to compile a 'don't do' list to be used along with this book Do not
- replace JDK classes: it would be unfair to say that the author himself has not warned you against it, but let me also quote him "For optimal performance, I recommend developing with your own versions of classes rather than JDK versions whenever possible." I find it outright funny, I almost can't believe (except for the fact that the rest of the book is in keeping with it) that he is actually suggesting something so ridiculous as this, I wonder whether somebody in Microsoft listened to him before they got into a legal tussle with sun about copyright.
- depend on optimizations with -O
- compile to native machine code (go use C++)
- get hooked on to native method calls: to quote the author "say goodbye to 100% pure java certification, and say hello to added complexity..." so it's not that the author has no idea of what he was talking about... still those siggestions? makes the book thicker ;-)
- reuse Exception objects
- get hooked onto the concept of comparison by identity, in short do not make significant modifications to your codes to get a comparison by identity, do not define a 'public static final Integer ZERO = new Integer(0)'
- use WeakReferences
- converts Strings to char arrays
- write exception-terminated loops
- and a lot of other things I gather I have made my point, do not buy this book unless you want to write blazingly fast applications those do not work right and is a nightmare to maintain.
Rating:
Summary: Best Tuning Book I've Seen
Review: Not only does Jack Shirazi provide an array of useful benchmarks in "Java Performance Tuning", both at the micro and macro level, he provides excellent case studies on how to set up and run benchmarks. Results are given for JDK versions 1.1.6, 1.2, and 1.3 with and without HotSpot. Although it would be nice to get a more up to date test including 1.4 and other run times, the utility of this book goes far beyond what it reports about the compilers and run times available in late 2000. The high level advice on a tuning methodology (profile and target, of course) is sound, as is the emphasis on perceived performance. Topics everyone should be aware of from caching to threading to streaming are dealt with up front. This might make this book rather hard to follow for readers unfamiliar with these concepts. Further advice on how to measure (try to get close to reality) and to not tune what you don't need to tune are also sound pieces of advice that are often overlooked. Admirable attention to garbage collection and command-line tuning of the run-times and compilers increased my confidence in the results, and should serve as a model to other benchmarkers. Details considered include everything from cache size and disk framentation to network bottlenecks. There are too many useful sections to list here. The writing is crisp and clear, the pace fast, and the examples well chosen. Shirazi provides depth on topics ranging from low level constructs such as switch statements, method calls, or upcasts, through intermediate constructs such as threading and object creation and reuse, to higher-level constructs such as the String and Collection classes. In chapter 8, the section "From Raw I/O to Smokin' I/O" alone justifies having this book on your shelf. This book is about tuning. It is not a book about algorithms or algorithm analysis. You'll need to know that, too. An elegant bridge between tuning and algorithms can be found in Jon Bentley's "Programming Pearls". All told, "Java Performance Tuning" is the best book on tuning I've ever read. Don't even bother with Wilson et al.'s "Java Platform Performance".
Rating:
Summary: Offering plenty of examples and sample code
Review: Now in an updated second edition that covers Java SDK 1.4 and J2EE performance tuning, Java Performance Tuning: Efficient & Effective Tuning Strategies by Java programming expert Jack Shirazi is a solid and superbly presented instructional resource and reference for advanced computer programmers wanting to improving their Java program performances, ranging from optimizing input/output routines, to speeding up servlets, to making the most of profiling tools, to searching out program bottlenecks, to applying appropriate sorting and other algorithms, and much, much more. A solid and comprehensive guide offering plenty of examples and sample code in addition to the well-reasoned text, Java Performance Tuning is an ideal and strongly recommended addition to any Java user's reference personal or professional reference collection.
Rating:
Summary: Fun and informative
Review: Once the business rules have been settled and all that is left is to tune the code, then the fun starts. Like a race car mechanic trying to squeeze out a couple of extra MPH from a race car, the most fun in programming is to try squeeze out extra performance from some code. A book on performance tuning should understand that and make the topic fun. Reading this book it is clear that Jack Shirazi loves to tune code. He has done an incredible amount of detailed research on different JVMs to determine exactly how to make Java perform. But he is also practical. He explains how to find performance problems, which exact areas to concentrate on, and which areas to ignore. After reading this book you won't waste your time on areas of code that can't be easily optimized and instead you'll know how to concentrate on those places where you can get the most bang. The book has been updated from the earlier edition to bring all the information up to date with the latest JVMs. Best of all, an additional 250 pages has been added to the book covering J2EE including Servlets, JSPs, EJBs, and JDBC. "Java Performance Tuning" is a programmer's book. You are guaranteed to learn a lot of very neat and useful tricks. I doubt that there is another Java book on the market with as many "WOW!" moments in it. Buy it and watch your code zoom.
Rating:
Summary: Indispenable!
Review: Performance has been the albatross around Java's neck for a long time. It's a popular subject when developers get together "Don't use Vector, use ArrayList, it's more efficient." "Don't concatenate Strings, use a StringBuffer, it's more efficient." It's a chance for the experienced developers to sit around the design campfire and tell ghost stories of previous projects where they implemented their own basic data structures {String, Linked List...} that was anywhere from 10-50% faster than the JDK implementation (and in the grand oral tradition of tall tales, it gets a little more efficient every time they tell it). Every developer has written a microbenchmark (a bit of code that does something 100-1000 times in a tight loop and measure the time it takes for the supposed "expensive operation") to try and prove an argument about which way is "more efficient" based on the execution time. The problem is when running in a dynamic, managed environment like the 1.4.x JVM, there more factors that you don't control than you do, and it can be dificult to say whether one piece of code will be "more efficient" than another without testing with actual usage patterns. This book provides substantial benchmarks (not just simple microbenchmaks) with thorough coverage of the JDK including loops, exceptions, strings, threading, and even underlying JVM improvements in the 1.4 VM. This book is one of a kind in its scope and completeness.
Rating:
Summary: Must Read Professional Java Programmers
Review: The book covered each area of Java performance except GUI/drawing. The performance techniques covered are many - I counted more than 200 listed in the index. The writer also gave a very good guide to the procedure for tuning applications, so I could start immediately without having to think "what to do next?" The checklists are very useful. I wanted to have a separate copy of all the checklists so that I could tick them off as I worked. I ended up photocopying them and keeping them a separate resource. I have many Java books, and this is one of the few books which I now keep ready to refer to. Excellent book.
|
