Jakarta Pitfalls: Time-Saving Solutions for Struts, Ant, JUnit, and Cactus

by Bill Dudney and Jonathan Lehr

Ideal intermediate-level book for programmers to turn to once they have read the introductory books. Identifies what can go wrong and provides refactored solutions for each pitfall complete with code. All of the pitfalls are cross-referenced within the text as well as outlined in a summary table in the back of the book. Includes background information and troubleshooting tips so programmers can avoid other errors that may also occur. The Web site...

• Format: Paperback
• Language: English
• ISBN: 0471449156
• ISBN13: 9780471449157
• Release Date: July 2003
• Publisher: John Wiley & Sons
• Length: 287 Pages
• Weight: 1.05 lbs.
• Dimensions: 0.7" x 7.4" x 9.2"

Customer Reviews

easy to read and useful

If you are working with Struts, Ant, or automated unit testing into your development process, then this is a book for you. This book looks at the popular Jakarta applications as JUnit/Cactus, Struts, and Ant, and shows the most common pitfalls when using these applications. The book gives a chapter to Ant and one chapter to JUnit/Cactus and rest to Struts. Most part of the book is on Struts. The authors discuss potential problems using Actions, ActionForms, and Struts tag library. Each pitfall has its own section and is formatted the same as the others. You get a description of each pitfall, an example of the pitfall in action, and steps for refactoring it. Corrective solutions are well documented with plenty of code samples to show both before and after images. This is a good book on anti-patterns and refactoruing, very good companion of the book > (by Martin Fowler) <br />and <br /><<Java Tools for Extreme Programming: Mastering Open Source Tools Including Ant, JUnit, and Cactus>> <br />(this one covers ant and junit/cactus but not struts) <br /> <br />This book is very readable, some may think it just covers obvious problems, actually, it coveres common pitfalls <br />that most people forget to escape. It's not a difficult book, but very practical. <br /> <br />

Using Struts? Buy this book!

I have to admit that I am a big fan of antipattern books. There are many ways to code an application but a few of those ways will cause problems in the long run both in debugging and maintenance. This book looks at four of the most popular Jakarta applications, JUnit, Cactus, Struts, and Ant, and shows the most common problems that you encounter when using these applications. The book gives a chapter each to Ant and the two testing applications JUnit and Cactus but the majority of the book is dedicated to Struts. Each chapter looks at several programming mistakes and then discusses ways to revise your code to fix these mistakes and make your code more robust. The problems with certain coding styles are well explained with clear reasoning as to why you don't want to code a particular way. Corrective solutions are well documented with plenty of code samples to show both before and after images. Although the chapters on testing and Ant are good, the heart of the book is the chapters on Struts. The authors discuss potential problems using Actions, ActionForms, and the Struts tag library. Some problems can just make your code more difficult to maintain while others can introduce intermittent bugs that are very difficult to diagnose. Anyone who is using Struts should absolutely read these chapters, as it will save you from making some simple mistakes that could cause a lot of long-term pain in your development.

Practical Guide to Avoiding Common Mistakes

If you are working with Struts, Ant, or incorporating automated unit testing into your development process (shame on you if your aren't!), then this is a valuable book. This book is especially useful for less experienced developers in that it encapsulates some common mistakes that us more experienced developers have learned the hard way. I wish there were more books like this out there. Having compact catalogs of common mistakes made with popular technologies and ways of avoiding them (with examples) is a great resource. My hat is off to the authors and Wiley for providing this book, and I hope others will follow.As a note, I especially like how the book is organized. Each pitfall has its own section and is formatted the same as the others. You get a description of each pitfall, indicators of its existence, an example of the pitfall in action, and steps for refactoring code to achieve a better solution. You can easily read through the book sequentially (due to its laid back writing style) or use it as a reference.

required reading

Dudney and Lehr have put together and excellent catalog of common pitfalls that occur when using Ant, Cactus, JUnit, and Struts. This book will help you identify pitfalls in your code and provides practical solutions for solving them. For each pitfall, a description is given along with step-by-step instructions for digging your code out of it. Accompanying the text are examples of code stuck in the pitfall and code that has been fixed. How often have you or someone you worked with used System.out.println() to verify test results? This is pitfall 1.3: Console-Based Testing. Detailed examples show how to get out of this pitfall for both JUnit and Cactus based tests. In addition to solving the problem at hand, the authors explain how you might fall into the pitfall and how to avoid it in the future. Have you ever written a getSomethingAsString() method in your model so that you can populate a Struts ActionForm? This is Pitfall 2.1: Copy/Paste Formatting. On the JSP front, this code: may look familiar, however, it is Pitfall 4.2: Hard-Coded Keys in JSPs. Jakarta Pitfalls is replete with practical examples and solutions. I cannot say enough about this book, other than it will be required reading for all projects I am on.

Comprehensive anti-patterns review

The authors have written a well organized, thoughtful catalog of mistakes commonly made by developers new to struts, ant and junit. This book is a great reference if you find yourself on a project that requires some refactoring in these areas, and it provides some unique insight from developers who have been there and pulled themselves out of these common traps.