Server-Side Programming Techniques (Java(TM) Performance and Scalability, Volume 1)

Written for the working programmer who wants to get more speed out of Java, Java Performance and Scalability, Volume 1 bundles several dozen tips for faster and smaller Java code. Backed up by benchmarks of what works and what doesn't, this book provides essential wisdom for eliminating some common bottlenecks to Java performance.

The 48 optimizations for various aspects of the Java API make up the heart of this text. Early sections look at a particularly tricky subject--string processing--giving you several techniques for increasing speed and reducing object creation. The in-depth examination of the costs and benefits of string concatenation and the immutability of Java String objects will help you uncover possible hot spots that cause lagging performance with strings.

Subsequent sections look at more general strategies for faster programs, like purging obsolete code, and the well-known 80-20 rule (optimizing the 20 percent of your code that consumes 80 percent of processing time, allowing you to create faster software; this book shows you how). Short tips on such APIs as Java collections and the Java Native Interface (JNI) come next.

The second half of the book zeros in on better server-side performance with tips on caching and file I/O. The guide to multithreading and synchronization is a standout here. You'll get several smart tips for speeding up servlets, such as precomputing your standard strings for headers and other boilerplate HTML. The book closes with a valuable custom class for JDBC database connection pooling and a custom HTTP server. Both samples make use of the techniques presented earlier in the text. Even if you don't adopt every suggestion, the ideas here can get you thinking about performance in new ways. (One of the main points of this book is that you can write faster custom code, instead of always relying on built-in Java classes and APIs.)

Clearly, Java performance is not something that happens by accident; it must be engineered into your code. This compilation of useful techniques and tips deserves a close look by anyone who wants to squeeze more performance out of Java. --Richard Dragan

Topics covered: Introduction to Java performance More efficient Java string handling (optimizing String, StringBuffer, and StringTokenizer objects) Reducing Java overhead Faster initialization The 80-20 rule for optimization Getting rid of obsolete code Speeding up the JDK 1.1 Vector and Hashtable collection classes Caching techniques Optimizing file I/O and buffering Object recycling and object pools Techniques for multithreading and synchronization Amdahl's law and scalability basics Pros and cons of using the Java Native Interface (JNI) Hints for optimizing Remote Invocation Method (RIM) calls Performance hints for servlets and JavaServer Pages (JSPs) Custom sample code for JDBC database connection pooling and a Java HTTP server

User review
Outdated, don't like this word, but nearly `useless` today
Outdated, so pretty big percentage of tips in the book are not really true currently.

User review
An oldie but a goodie
Definitely a `Java Geek` must-read as you'll uncover a lot of performance results that you might have assumed would be very different - however due to API implementations and/or JDK changes you get unexpected results. With Haggar's `Practical Java` you've got two good books for Senior Developers to help avoid performance and scalability issues in code. Probably the conclusions in the book need to be verified under newer JDKs 1.3 and above, as so much has changed since this book was released

User review
Good for those H1B guys.
I have to work with Chinese, Pakistani and Indian programmers who were handed a copy of `Learn Java in 24 hours` Then they start hacking on my project. This book helps me fight with them when they do stupid things over and over. I already knew 90% of what is in this book, but it's nice to have everything laid out for you clearly. Where is Volume 2?

User review
Tips and Tricks,, but thats that
There are many good tips and tricks in this book but thats where it ends. I expected a bit more continuity on issues definitively surrounding server side development. It seems like it competes with `Effective Java` which the title does not imply.

User review
An excellent, easy read that I could apply immediately.
This book covers the basics of improving the performance of server side java programs by writing different java statements. I like the fact that it had just the answers, not excessive amounts of padding. I especially liked the chapter on taking an existing, well written java program that was a web server, and optimising it in several stages. The stages were consistent with the optimisations discussed in the preceding chapters which helped put it those chapters into context nicely. The optimisations turned a good web server written in Java into a much faster one, which was good to see.

I describe this as a `basic` book on optimisation because the chapter on RMI was rather light, presumably because of the 80:20 rule wereby the biggest gains can be had with the simplest of coding changes. Going into more detail would have made the book thicker so perhaps it was best it was left as it was. There is perhaps an opportunity for someone to write an `advanced` version at some later stage.

I'd recommend this book to someone who is an experienced java programmer who wants to make their java programs run quicker. I certainly found it useful in my own java programs.