Rating: 
Summary: Great book
Review: This book does a great job of explaining how to use each of the tools but what I really appreciate is that it shows you how to use the tools together. For example, the Cactus chapter tells you how to use Cactus to do Mock Object (a new approach that extends the concepts of XP unit testing). Great! What makes the whole chapter really useful is that the code project in this chapter shows you how to use JUnit, Ant, and Cactus together to do XP testing on a set of JSPs in a Web application. These are the great things in this book that are not covered in the tool docs and this is the kind of information i can use in my work every day. This book really works to extend XP concepts found in other books. A good example is the chapter on HttpUnit, which deals with functional testing (important stuff that usually gets downplayed by most us XPers). Here again this chapter tells you how to use HttpUnit and JUnit together to spider all the user-accessible pages on your site and make sure there are no broken links. This book helped me see how to use a group of tools together to build great XP tests for my Web apps. Thank you!
Rating: 
Summary: Nice Introduction To Ant and JUnit
Review: This book is a nice introduction to Ant and JUnit. I have been meaning to use these two tools for some time now, but could not decide how to get started. This book eases the programmer into these practices by providing thorough practical examples. I have not gotten to the other tools covered.
Rating:
Summary: Java Open Source tools power XP!
Review: This book is not about extreme programming (XP). Rather it teaches open source software tools we can use to utilize one important aspect of XP: Continuous testing. XP principles say that you should write your unit test code according to the requirements *before* you write any application code. That guarantees that your software meets the minimum requirements for now. And if refactoring is needed in the future (likely), you will have a set of unit tests that can guarantee the changes you make are correct. In this book, the authors discuss frameworks and tools to write and automate the testing process for sophisticated application server software. The authors started with Jakarta build tool ANT. As a build automation tool, ANT is used throughout the rest of the article to provide an integration point for other test tools. ANT itself is not very complicated (It is designed to be easy-to-use!). The book goes through simple ANT syntax and build processes. The authors also give an advanced example of automating the build and deployment process of a complex J2EE web application. It is a nice review of different components of a J2EE application and how they work together. After ANT, the authors move on to discuss the popular Java unit test framework JUnit. JUnit is not really so much a "tool" since it only offers very simple implementing classes. But rather, it is a "framework" that provides the conceptual basis of object oriented unit testing. It defines the steps to setup and execute tests. JUnit can be extended to make specialized and automated tests for complex circumstances. One such specialized, JUnit based testing tool is Jakarta Cactus for J2EE application unit testing. This book really shines in its explanation and extensive examples on how to install, setup and use Cactus. The difficulty of J2EE unit tests is that all components have to run inside J2EE containers. Cactus counter this by running tests on both client side and server side. Once ANT automatically redelopyed and restarted the server, the client side Cactus test engine sends out requests to the server using customized request/response connectors. The connectors pass the information to server side Cactus and allow it to setup server side environments such as session objects and context objects, according to the test requirements. Then the server runs the test case and sends the results back to the client. The client tests assertions and and reports to the tester. That process guarantees the server side test code runs under a controlled environment. Cactus unit testing can be quite complex due to the multiple parties involved. So, the authors give a good example on how to test JSP custom tags. It illustrates how to setup those tests and test the life cycle methods for each tag handler step by step. This is an example on how to use Cactus in real life. Unit testing is an important development method. But in complex in-container J2EE applications, we also need to make sure all units work together in integration (function) tests. The authors discussed integration test tool HttpUnit, performance test tool JUnitPref and JMeter. Overall, this is an excellent book covering a wide range of Java build and testing issues. It would be even better if you can provide more examples outside of J2EE area. Examples on automated testings in GUI applications and even J2ME applications can be very useful.
Rating: 
Summary: A book for beginners at best
Review: This book is not practicing eXtreme Programming as anyone that does XP would recognize it. Instead it seems to take that stance that just using the tools that have come to be associated with XP - means you are doing XP. Instead, it is nothing more than an attempt to "jump on the XP bandwagon" and get some more shelf space for the book by putting XP in the title. Aside from the obvious padding at the back (there is probably about 300 actual pages or work) the book is decently put down. The code is easy to read (although it doesn't make use of well-known best practices) and the author's style is only slightly annoying.
Most of the code actually compiled with few changes, which is something you cannot say about many programming books. But considering what the author is working on this isn't a great achievement in programming books. Still. While I rate this book as only 1 star - if the capsule would have limited its writeup purely to EJB Web Designers then I would say this is a 3-star book. Since they don't mention what a limited selection this book really represents I have to rate it on its overall usefulness.
Rating:
Summary: potential to make you a better programmer
Review: This book is the first of its kind, covering topics that haven't been explored this directly anywhere. It does a remarkable job, covering not just the tools but the philosophy behind good unit tests and frequent, automated builds. The book is divided into three major parts. Part I presents a foundation for the ideas in the rest of the book, exploring the philosophy behind XP, J2EE project development and deployment, and demonstrating the process with a simple Model 2 Web application. Part II spends its first three chapters (4-6) looking at ANT, first with a high-level look at continuous integration practices and then at more concrete examples. Chapters 7-11 look more closely at testing, with chapters on JUnit, Cactus, HttpUnit, JMeter, and JUnitPerf. Part III is a series of reference chapters for ANT, JUnit, Cactus, and HttpUnit. The coverage is exceptionally good and the material is comprehensive. There's no question that a book like this is unlikely to stimulate readers to suddenly adopt these techniques. Instead, you should consider applying those things that make sense to you and focus on those chapters. The book is written well enough to make that possible, in part thanks to the flexibility, modularity, and effectiveness of the tools being discussed. Serious projects need to take testing seriously and few books approach the topics with this kind of practicality and experience. If you're doing rapid development, and who isn't these days, this books is well worth a look. It goes beyond simple solutions and may be of interest to QA or testing groups. The philosophy behind this material is modern and forward thinking. It captures some of the best practices and clarifies the application of current tools in the Java community, and has the potential to make you a better programmer and better able to deliver higher-quality code on a shorter timeline. It's not a panacea, but it is a good investment, and inexpensive considering the book's content. Regardless of whether you subscribe to the practice of Extreme Programming (XP) or not, you're likely to be interested in tools that can help you perform better unit tests and improve your build environment. Good unit tests can make the difference between discovering problems at an early stage (when debugging is least expensive) and less flexible, more expensive projects. If you make heavy use of Java, the ANT build tool is also important, enabling you to do much more than merely build classes. ANT has facilities that range from simple builds to sophisticated interactions with protocols, packaging, and much more.
Rating:
Summary: Great Book!!!
Review: This book rocks!!! Did you ever get frustrated and alone trying to get the open source dev tools to work? This book ends all of that. It is really marvelous. I have seldom bought a tech book that I was so satisfied with.
Rating:
Summary: Schizophrenic but Still Quite Useful
Review: This book tried to be too many things to too many people. However, if you want to learn more about Ant, Junit, Cactus, HttpUnit, JMeter, or JunitPerf this book is probably one of your best choices.
The book has one dedicated chapter on Extreme Programming and certainly incorporates an Extreme Programming perspective, but this is not really a book about Extreme Programming. If you want to learn about Extreme Programming this is not the book for you. If you don't care about Extreme Programming, you can skip the one chapter on it and benefit from the rest of the book.
The book aslo waists one chapter and other miscelaneous pages discussing how to deploy J2EE applications. If you want to learn how to develop or deploy servlets, JSP, EJB, and other J2EE technologies, this will not be sufficient material to properly introduce you to it, and you should buy other books for that purpose. If you already are a J2EE developer, then you already know most of what this book says about servlets, JSPs, and EJBs and you will probably want to skim or skip these pages.
The book also spends one chapter and many other miscelaneous pages on substantial case studies which may be quite useful to some people, but arguably are of limited value to most people.
However, there is a light at the end of the tunnel. The coverage of Ant, JUnit, Cactus, HttpUnit, JMeter, and JUnitPerf is quite good. The writing style is very clear and easy to learn from. The coverage could be more comprehensive, but it is certainly will give you a very strong start with these tools and does go into some advanced topics. In addition, most of these tools don't have many if any books that significanly discuss them, so this coverage is something of a rare find.
The last quarter of the book is an API reference. The API reference does have some useful dicusssion and details of the parts of the API. So while I find API references to be of limited value in a book, this API reference is moderately useful.
In summary: If you want to learn about some good open source tools for Java deployment and testing (Ant, JUnit, Cactus, HttpUnit, JMeter, and JUnitPerf,) then I highly recommend this book, but you should expect to skim past several parts of the book to get to the good parts. If you want a book on Extreme Programming or general Java development, then this is the wrong book for you.
Rating:
Summary: Great book
Review: This is a great book. I used it to teach myself HTTPUnit even with little Java knowledge. The chapters on the API are my main source now for my work. They include code snippets to get you on your way to doing useful things with HTTPUnit and the other APIs. Mr Hightower also hangs out on the mailing lists for some of these APIs and is extremely knowledgable on the subject.
Rating:
Summary: Excellent introduction to many important tools
Review: This is an excellent book that shows you how to actually apply the XP philosophy using modern tools. Whereas most XP books are long on philosophy and anectdotes but vague on implementation, this book instead focuses on what tools are available to developers and how these tools allow them to implement the philosophy. For JSP/custom tag/servlet developers, the chapter on getting Cactus up and running is worth the price of the book, answering questions that are sometimes poorly covered by the Cactus documentation. The main complaint that I have is one that others might not share: the last fifth of the book - around 150 pages - is made up of Ant tag references, and the APIs for the various libaries dicussed in the book. I personally do not like having to pay for reference material that is otherwise avaialable online, but some may like having a hardcopy of this documentation.
Rating: 
Summary: Nice consolidated overview and reference
Review: This short text (340 pages, remainder is API reference) contains enough information to get you up to speed quickly with some valuable tools. Developers and project managers alike will shine by adding automated build, test, and reporting tools to their repertoire, and I certainly can't complain about that. I would have expected a more thorough job of tying the tools back to Extreme Programming, but those not interested in XP or those already familiar with XP will appreciate the "down to business" style. Much of the sample code is too simplistic to be helpful, and I found the case study to be much less valuable than others have suggested, but both provide enough context to whet one's appetite. Most of these tools have excellent documentation anyway, and this book serves its purpose well: an adequate introduction to some great productivity tools.
| 
