Customer Reviews

Jakarta Pitfalls: Time-Saving Solutions for Struts, Ant, JUnit, and Cactus (Java Open Source Library)

5 star:		(8)
4 star:		(1)
3 star:		(0)
2 star:		(1)
1 star:		(0)

 

 

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.

The book is fine, but it in the back is a boiled down synopsis, about 5 pages, that suffices for the entire book. The rest of the book doesn't really add that much. The material here is good, but is available by reading a few white papers and faq's on the web. I didn't dislike the book, I just wish I hadn't spent the money.

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 <<Rafactorying>> (by Martin Fowler)
and
<<Java Tools for Extreme Programming: Mastering Open Source Tools Including Ant, JUnit, and Cactus>>
(this one covers ant and junit/cactus but not struts)

This book is very readable, some may think it just covers obvious problems, actually, it coveres common pitfalls
that most people forget to escape. It's not a difficult book, but very practical.

This is an important book. If you're new to any of these tools, don't waste your time hitting the same potholes that everyone else has. The authors took some good notes in trenches, and they present their pitfalls in a structure way that builds one upon another.

I just wish this book was available when I was first getting started with Cactus!? It will be at my elbow as I start my upcoming Struts project.

(The only reason I didn't give this book 5 stars is that I ran across a few typos.)

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.

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: <bean:message key="label.invoice.number"/> 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.

I am often hesitant to turn to books rather than net references because so often I will end up with a 500 page table decoration and 5 pages of useful reference. I would prefer to have useful book references at hand, but it so seldom happens.
This book is not only a reference, but a bit of education. It touched on problems my current project was having, and pointed out new ones to avoid. It offers both reference and actual analysis, rather than a rote description of the FAQ or what-it-is of some tech or language.
I am encouraged and will be looking for similar books and some of the references mentioned in it.

If you are designing a large-scaled web application based on Struts, you should read this book first. Reading this book will help you avoid Struts architectural pitfalls and get a better idea what the Struts framework really offers. The pitfalls discussed in this book are all really insightful ,and the solutions suggested by the authors are well-designed and practical. An excellent pitfalls book!

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.

Whether you're a beginner or an expert on Struts, Ant or JUnit, this book will provide you all the items you should watch out for. And if you're already in trouble with any of these technologies, its very likely that this book has it.