Java Tools for Extreme Programming: Mastering Open Source Tools, Including Ant, Junit, and Cactus

by Richard Hightower

Learn how to use the hottest new Java open source tools for eXtreme Programming eXtreme Programming (XP) is a new development methodology for building software systems quickly without sacrificing quality. New Java open source tools have appeared recently that help with the most time-consuming and difficult part of the XP process-testing, integration, and deployment. Java Tools for eXtreme Programming is the first complete guide to using those tools...

• Format: Paperback
• Language: English
• ISBN: 047120708X
• ISBN13: 9780471207085
• Release Date: November 2001
• Publisher: John Wiley & Sons
• Length: 544 Pages
• Weight: 2.15 lbs.
• Dimensions: 1.3" x 7.5" x 9.3"

Customer Reviews

Work smarter

Extreme Programming (XP), a methodology developed by Kent Beck and Eric Gamma, has joined CASE/UML as a core practice in professional software development. The central tools for XP (JUnit, Ant, Cactus, JMeter, HttpUnit) are now covered in a practical reference by Richard Hightower that explains how these open source tools should be integrated into a project to achieve XP's benefits.The book follows the construction of an online pet store--similar to Sun's J2EE Blueprint Pet Store but instead of focusing on J2EE technologies, Hightower's example illustrates how XP tools are integrated into a project.The tuturials work through several iterations of the pet store. The baseline version has no connection pooling and no EJBs. It has several JSPs, a few classes that use JDBC, and some tables in a database.The second iteration of the case changes the content management piece of the system to a container managed persistence (CMP) entity bean that implements the backend product management. This iteration demonstrates how to incorporate EJB deployment into Web applications and how to ensure that the unit testing of the category systems still works after the addition of CMP entity bean support.The third iteration of the case study uses an EJB stateless session bean to add pooling of connections and prepared statements. This iteration is used to demonstrate JUnitPerf and show the time savings from pooling prepared statements when the site is hit by many users.The fourth iteration of the case study creates a Catalog TagLib. Cactus is used to test this TagLib. This is an excellent example to learn how to operate and run Cactus tests and how to integrate them into the build/deploy process.The fifth iteration of the case study refactors JSPs using the Apache Struts project. Then, it uses HttpUnit to test that the application still works. The HttpUnit test is run against the baseline and new version to show that the requirements are still met.The sixth and final iteration of the case study refactors the Web application to use Exstensible Style Language Transformation (XSLT) instead of JSP to build the catalog view. It then compares the throughput of the two approaches using JMeter.I've found it very difficult to follow the partially finished documentation for many of the useful open source tools needed for full XP. Having a book like Hightower's is invaluable to fully leverage the benefits of the XP movement in mid to large scale development efforts.

Great book for Ant, JUnit and Cactus -- Not an XP tutorial

This book describes the techniques for implementing the eXtreme Programming (XP) practices of automated testing and integration under the auspices of XP. This book is not meant as XP tutorial even though the book includes a good introduction to eXtreme Programming and the practices that make up XP. For the uninitiated, eXtreme Programming (XP) is a pragmatic approach to software development that emphasizes results first and takes an incremental, `build something that works quick' approach to building the product, using continual testing and refactoring. Kent Beck came up with the idea and has written several books on XP and he emphasizes testing and writing test code to validate the actual code you are writing. Beck calls Extreme Programming a "lightweight methodology" that challenges traditional notions of software development process. The basic idea is to start small and building something real that works and move forward while constantly refactoring the code.I bought the book as a reference guide for Ant and Cactus and found this book to be really well written, easy to read and a great resource even if you don't use XP as your software development practice. One of the reasons I love this book is because of all the examples and code included in this book. The authors and contributors take real examples and apply Ant, Cactus, JUnit, etc in terms of those real problems making it easy to take the lessons learned and applying them to your projects. I really like the flow of the book - For example, the chapters on Ant begin with some basic information about Ant, what is it, and how to build your xml file to use Ant. You use Ant on a simple example and then move to more complex tasks where you eventually end up building an entire ear file using Ant. The chapters on JUnit and Cactus are also excellent and are written in the similar tutorial fashion. I haven't spent a lot of time looking at the HttpUnit, and JMeter chapters.Another nice feature of the book is that it includes all of the API and tag references for Ant, Cactus, JUnit, and HttpUnit that takes up over 150 pages. In most cases, I find it annoying when authors pad their books with 100's of pages of API, but I didn't mind it in this case as it's nice to have them available for easy reference.

building, testing, and deploying J2EE applications

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."

Great book

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!

Great reference!

This a must-have reference for anyone seriously interested in XP and its application in the software industry. I found a lot of really good examples of how to do continous integration and automate testing. Most of the technologies covered are pretty new and have the big bonus of being open source! All in all, XP and Java are a very robust combination and this book is doing a good job of showing it.