Java Tools for Extreme Programming: Mastering Open Source Tools, Including Ant, JUnit, and Cactus (Java Open Source Library) [Paperback]

Richard Hightower (Author)

Book Description

Publication Date: November 27, 2001 | ISBN-10: 047120708X | ISBN-13: 978-0471207085 | Edition: 1

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 for XP. Throughout the book, author Richard Hightower uses a sample application to demonstrate how each Java tool is used. For each tool, he provides a concise description of key concepts, plenty of code examples, and directions for setting up scripts for automating the development step in which the tool is used. The book also features a detailed reference to each of the major tools, complete with coding examples.
* XP is the most popular new development methodology
* A practical, code-intensive guide to the tools that enterprise Java developers need when using the XP methodology to build applications
Companion Web site features sample code, XP software tool updates, and links to useful XP sites.

Editorial Reviews

Review

"...an excellent tutorial... I strongly recommend this book..." (CVu, August 2002)

"...an excellent introduction to the world of eXtreme Programming..." (Visual Systems Journal, October 2002)

Book of the Month - “…a much needed book…”(Computer Bulletin, March 2003)

From the Back Cover

Learn how to transform XP theory into concrete Java(r) development techniques!

Software developers live by the mantra "evolve or die." Adhering to that philosophy, Richard Hightower and Nicholas Lesiecki present you with an innovative book about Extreme Programming (XP)-- a development methodology that enables developers to build flexible, high-quality software in a quick, efficient, and cost-effective manner. This book teaches you how to implement XP in Java using open source Java XP development tools and how to master the most difficult part of the XP process: testing, integration, and deployment.

Written with experienced Java developers in mind, this book begins with a brief introduction to XP methodology and techniques, and then dives into a sample application used throughout the rest of the book to provide a real-world view of the tools and development practices in action. The authors provide concise descriptions of the key concepts behind each tool, offering code examples and step-by-step tutorials to guide readers to mastery of the technical aspects of XP development.

This book covers the following XP subjects:
* Automated unit and functional testing
* Continuous integration through build and deployment automation
* The value of refactoring and continuous integration
* How Ant, JUnit, JUnitPerf, Cactus, HTTPUnit, and JMeter can be used to achieve the goals of the XP methodology

The companion Web site contains:
* Sample code
* Updates on XP software tools
* Links to useful XP sites

Wiley Computer Publishing's Java (TM) Open Source Library provides professional Java programmers with in-depth guides to the growing number of open source tools and technologies for developing , testing, and deploying Java applications.

Wiley Computer Publishing
Timely. Practical. Reliable.
Visit our Web site at www.wiley.com/compbooks/

See all Editorial Reviews

Product Details

• Paperback: 544 pages
• Publisher: Wiley; 1 edition (November 27, 2001)
• Language: English
• ISBN-10: 047120708X
• ISBN-13: 978-0471207085
• Product Dimensions: 9.2 x 7.5 x 1.1 inches
• Shipping Weight: 2.2 pounds
• Average Customer Review: 3.9 out of 5 stars  See all reviews (48 customer reviews)
• Amazon Best Sellers Rank: #2,641,742 in Books (See Top 100 in Books)

More About the Author

Discover books, learn about writers, read author blogs, and more.

Most Helpful Customer Reviews

26 of 28 people found the following review helpful

5.0 out of 5 stars building, testing, and deploying J2EE applications January 13, 2002

By A Customer

Format:Paperback

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

20 of 21 people found the following review helpful

4.0 out of 5 stars Java Open Source tools power XP! April 9, 2002

By Juntao Yuan

Format:Paperback

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.

14 of 14 people found the following review helpful

4.0 out of 5 stars Put XP theory into practice December 8, 2001

By Kevin Davis

Format:Paperback

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.