I recently bought a copy of Enterprise JMS Programming to assist with my Mule tinkerings.

I was looking at JMS books for a while before I took the plunge and bought one. For some reason, bookstores in Orlando, FL just weren't carrying any JMS love, which pisses me off because I hate buying books I haven't thumbed through. There are a lot of factors that go in to the quality of a book, especially a programming book, and it's just not possible for me to get a good feel through online samples. Also, with regard to JMS, all the books worth having seem to be on older-than-current versions of JMS (this one included). I settled on Enterprise JMS Programming, and hoped for the best.

The book has been pretty awesome. The author did a really nice job of packaging the chapters in to easily consumable chunks focused on specific areas, and was able to deliver both code samples and best practices on almost every page without providing so much that the reader became bored, or so little that the material was unhelpful. Also, best practices and "gotchas" in real-world implementations are described whenever possible within the context of the item being discussed.

The fact that the book covers the earlier version of JMS has not been a challenge so far, partially because the API for JMS hasn't changed that much, and partially because the way the content is presented the concepts are still relevant regardless of the final implementation.

I like that the code samples are simplified without being devoid of useful content, and tightly focused on the topic at hand. Some books try to follow a theme of building an application or framework through the chapters, which pisses me off because I can't jump around the book at random without having to decipher which parts of the sample code are boilerplate for the sample app, and which are related to the technology I'm trying to learn.

That being said, having a soup-to-nuts sample app to look at is certainly useful, and the end of the book shows three system architectures for varying applications. The author has done a nice job of keeping the requirements for these applications simple while still introducing enough differentiation and quirks to demonstrate varying models and architectural styles. Each application case study is short enough to be coherent while providing enough sample code to build a picture of the full implementation in the reader's mind.

Another nice aspect of the book are the sample chapters on JMS administration. The discussion of JMS administration is useful because you can't really have a good messaging architecture if you don't understand the challenges that must be tackled to administrate it. There are also some examples given of walk-throughs in two different JMS products, but unfortunately these are so old that they're not relevant any more (all the screenshots are in Netscape 4, if that gives you an idea :) ). Since the high level discussion on JMS administration is implementation agnostic, these chapters can be safely skipped without detracting from the value of the book.

So, kudos to Shaun Terry for his efforts. This book is quickly becoming one of my favorites, and I highly recommend it to anybody planning on learning JMS.