Rating: 
Summary: extremeLy intersting...
Review: I enjoyed "Java Tools for Extreme Programming" by Hightower and Lesiecki and am glad I bought the book. I work in QA for a software company and my primary interest is the tools such as Ant, JUnit, and Cactus. There is a little bit about the philosophy of extreme programming, and it is interesting as it sets a context for using the tools.The section on using Ant was interesting and educational. I had heard of Ant but didn't know what it was or how I could apply it. The book has copious examples on using Ant for both Java and J2EE. The section on JUnit and Cactus were of value as I am just exploring using these tools. There are also sections of JMeter, HTTPUnit (and the difference between it and Cactus),and JUnitPerf.
Rating:
Summary: building, testing, and deploying J2EE applications
Review: I find if you are doing J2EE development this book is a must-have! Even if you are not doing XP. Don't let the XP title turn you off from this book. At first glance at this book, I thought it was trying to be too many things to too many people. It seems to contain every buzzword: Opensource, Extreme Programming, Java, JSP, TagLibs, EJB, etc. However the book focuses on applying Ant, JUnit and Cactus to J2EE development. The book is very J2EE and web application centric. A small part of the book had very choppy flow--a few rough spots. Mostly (95%) the book is well written. Generally the book is easy to follow.
My favorite chapters are the ones on JUnitPerf and Cactus. The case studies are a little long, but they can be skipped and returned to later. The source code on the website is hidden in plain site. It took a while to find it. The description above and title miss an important point. The book is J2EE/Jakarta centric. J2EE testing and continous integration can be very difficult without the use of Ant, JUnit, HttpUnit and Cactus. The description of the book on the companion website clears up the missing points well. I found the description while searching for the source code. From the companion website: "Java Tools for eXtreme Programming describes techniques for implementing the Extreme Programming practices of Automated Testing and Continuous Integration using Open Source tools, e.g., Ant, JUnit, HttpUnit, JMeter, and much more." "The book contains small examples and tutorials on each tool. The examples cover building, deploying, and testing Java and J2EE applications." "In addition to small examples, there are larger case studies. The case studies are larger more realistic examples. We have case studies involving XSLT, EJB, Struts, JDBC, etc." "Each case study is complete with an ant build script and several tests, written with JUnit, HttpUnit, Cactus, JUnitPerf and/or JMeter. The case studies focus on building, deploying and testing J2EE applications with Ant and JUnit." "There is also a reference section for APIs. Instead of rehashing the API documentation, the reference section has example usage, i.e., code examples for the important classes and methods." "Although this book speaks from an XP perspective, you need not practice XP to benefit from it. For example, you do not have to adopt the entire XP methodology to get value out of this book. Automated testing, for example, can help you refactor code regardless of whether you are doing pair programming or not. Continuous integration can help you detect and fix problems early in the lifecycle of the system regardless of whether your customer is on site or not."
Rating: 
Summary: good intro to several tools
Review: I found this book to be a good introduction to several open source development tools (with an emphasis on testing tools), but its strength is definitely breadth rather than depth. The individual chapters primarily serve as introductory tutorials, although there is some integration of the tools (e.g., combining HttpUnit, JUnitPerf, and JMeter to test several different aspects of performance and scalability). While all this information could probably be found on the tools' websites, I thought the book provided a worthwhile condensation. My major problem with the book is that 1/3 of it is devoted to API reference, which I generally find to be a waste of paper.
Rating:
Summary: Extremely Rewarding
Review: I found this book very helpful. It provides great, in-depth code examples showing how to use Ant, JUnit, Cactus and other open source tools. It takes a little effort to get through the sample application used for all the tutorials (Chapter 3), but it was worth the effort--really shows how to master these tools, whether or not you use XP methodology.
Rating: 
Summary: very useful book
Review: I found this book very useful because it filled up some gaps in my programming practices. For a long time I avoided to learn Ant and other open source tools because their documentation and usage if any look so intimidating. But now with big project looming over me I decided to give it a try.
The book not only helps to start with Ant, JMeter and JUnit but also shows mechanics of packaging and deployment of complex enterprise application.
I substracted one star because the book does not use more accessible application server and database.
Rating: 
Summary: Lots of potential - not much delivered
Review: I had high hopes for this book, but cannot recommend it. You'd be better off checking the Jakarta web sites for information and examples on the tools covered, and buying another book that actually covers XP. This book could have been great if it didn't try to be an XP book, covered the tools much more in-depth, and removed the clutter of the appendixes and repeated poor examples throughout. In addition, proper editing could really help remove the countless typos, grammatical errors, and punctuation mistakes. In this day and age I don't understand the logic in publishing hundreds of pages of code.
Rating:
Summary: Put XP theory into practice
Review: I have been struggling with turning XP methodology into a solid development process. We've had some success at my company but most times we've met frustrations primarily because we were trying to teach old tools new tricks. Rick Hightower's java Tools for XP has made a big difference for us. My team has been able to use the tools described in this book to actually DO unit testing, and we've already automated a significant portion of our testing and deployment processes. Its also let us make a good case for open source tools at my company. I agree with one reviewer that the chapter on the sample application is tough to get through. This chapter is LONG!!! But it was worth it because obviously you have to understand you application to build appropriate tests. The tests in the book did a great job of showing us what we should be doing with our own applications. Maybe it's a learning style difference but I disagree with the reviewer who complained about the API chapters. I found them useful because 1) they weren't a lame rehash of the docs, and 2) they have a ton of code snippets. So I read the chapters to get the overall gist of the tool and see examples of it working, and then mainly used the API chapters at the back to build my tests. One small complaint about the book: I was suprised when I got it that the cover was washed out. It looked like Amazon had it sitting in their window for a while before they sent it to me. But hey, the inside sure is easy to read! Overall I definitely recommend this book as the first book to make XP real.
Rating:
Summary: Nice Surprise
Review: I ordered this book based on the title and the preview content here on Amazon (I couldn't find it at the B&N near my work). I was very pleasantly surprised at the practical, nuts-and-bolts approach that the authors took to XP and the tools in this book. I was also extremely pleased at how well the authors showed the integration of these tools into a sophisticated and professional development environment. This is not easy, especially when working with a wide range of tools which includes
* CVS
* Ant
* XDoclet
* JUnit
* JUnitPerf
* Bugzilla
* JMeter
* Cactus
* jcoverage
* Swing testing tools like Jemmy
* Maven
* Anthill
And even though all these tools are O.S., some projects are very territorial (eg they consider other tools to be the competition) so just reading the docs will not always help you choose the right tool for the right job or learn how to use the tools together.
The code I downloaded from the Wrox site was a little rough (some missing files), but the version I downloaded last week was *much* better and has solved all the earlier problems I was having. I'm glad the authors were responsive and willing to release fixes. Great stuff!
Rating:
Summary: Excellent Book
Review: I used this book to teach myself JUnit quickly and painlessly. The examples were clear and with the Object listing and some help from the author on the JUnit mailing list I was running automated tests quickly and easily. I highly recommend this book.
Rating: 
Summary: eXtremely Disappointing
Review: I was awaiting the arrival of this book with some eagerness. At last XP would be breaking out of the "in-crowd" and the Addison-Wesley series. Unfortunately, the (500 page) book that arrived consisted of ~150 pages of API documentation and some pretty poor tutorials for ANT and JUnit. I must confess to being unable to comment on the Cactus / HTTPUnit / JMeter tutorials as I gave up after JUnit. The book mentions XP a couple of times in the introduction, but isn't really about about XP (or tools for XP). It should be called "Open Source Tools for Building J2EE Aplications (with tests)". It wouldn't surprise me if that *was* the original title before the XP bandwagon presented itself.
| 
