Customer Reviews

Java Extreme Programming Cookbook

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

 

 

This is an interesting work because while it does have the cookbook format it isn't really a cookbook. The book starts with an introduction to the XP methodology (which is concise and great), and then has chapters on a number of tools (Ant, JUnit, HTTPUnit, XDoclet, Tomcat, etc.). Each of these technology chapters has a number of 'recipes' which are in fact how-to segments about commonly used tasks around these technologies. Now these sections are great and I think anyone looking at these technologies should consider this book a quick and concise way to learn the fundamentals.

That being said the book fails somewhat, and thus the four stars, because it isn't organized in the problem/solution manner of the cookbooks. Most of the chapters are about testing but these are organized around the tool and not the problem. I would have preferred a section on web development that combined information on Tomcat and Ant, and one on web testing that talked about HTTPUnit, JUnit and Ant. In that way the book addresses problem areas without relying on the reader to understand the tool that would address his problem in addition to understanding his problem at hand.

My gripe is not so critical. The content in the book still remains very valuable and if you are looking for a concise how-to in these Java technologies you should have a look at this book.

This book covers a very similar selection of tools and techniques to "Java Tools for Extreme Programming" by Hightower and Lesiecki, and in a broadly similar way. Both use the currently fashionable idea of Extreme Programming (XP) to attract readers to a collection of short pieces about a bunch of useful tools for Java programming.

The XP stuff is covered quickly at the start, the meat of the book is in the "recipes", which walk you through configuring and using tools such as Ant, JUnit, Cactus etc. to build, unit-test and manage the development of a Java project.

The tools and tips the authors have chosen to include are a good representation of current practice, but I have a few reservations about the organization and structure of the book. My biggest worry is whether the target reader is actually likely to find many solutions. The authors seem to assume that everyone will pore over the several pages of "contents" at the front of the book every time they hit an obstacle, but in my experience they are just as likely to flip through pages or head for the index at the back, neither of which works particularly well. Worse than that, they may never think to look in the book in the first place - the "Extreme Programming" in the title may help it sell, but it's not something that jumps to mind when you are struggling to get Ant to deploy a web application to Tomcat.

That said, I'm glad I've got it, and some of the recipes now have little sticky notes to try and remind me that it's often an unexpectedly good place to look for Java development tips.

Java Extreme Programming Cookbook consists of a bunch of "recipes" for helping you to build and test Java programs through XP. Each recipe consists of a Problem, Solution, Discussion and a "See Also" pointer to where you can find more information about the topic. The recipes cover the following opensource technologies: Ant, JUnit, HTTPUnit, Mock Objects, Cactus, JUnitPerf and XDoclet.

Want define a classpath using Ant? Check out recipe 3.7. Wanna test a form in your web application? look at recipe 5.9. This book gives a bunch of good strategies to commonly encountered problems, but it's by no means a complete reference to the different technologies. But it will definitely get you started, and you'll be able to apply these different recipes to your own development environment.

The organization of the recipes and consistency between the chapters is where this book lost points in its rating. Want to know how to run JUnit with Ant? look in the Ant chapter. Want to know how to run HTTPUnit with Ant? Look in the HTTPUnit chapter. The Cactus chapter has a nice recipe about "When not to use Cactus" and the JUnitPerf chapter has a nice recipe about "When to use JUnitPerf" it would have been VERY helpful to have such sections for EACH technology discussed in the book, but alas the book is inconsistent.

Overall, I think this is a good book to jump-start you into an XP development environment using open source technologies.

Instead of digging through the documentation of your open-source tool, take a look at this book. The first two chapters give an overview of extreme programming (XP), but the rest of the chapters are focused on the tools of XP. Each of the chapters on the tools begin with a brief description of the tool (and I mean brief). The rest of the chapter is sub divided into sections. Within each section, a problem that one might encounter with the tool is introduced, then a solution is proposed and discussion of the solutions follows (with an example).

The tools covered are Ant, Junit, HttpUnit, Mock Objects, Cactus, JunitPerf and Xdoclet. Tomcat and JBoss are addressed in a chapter together. Because of the brevity and focus of the book, probably not everything that you want to know about a tool is mentioned. After you already know why and when to use a tool, this book can help with the how.

The book is a good reference tool and could save someone a lot of time, but look elsewhere for more in-depth explanations.

I like books which get to the point with practical examples and easy to follow explanations of complicated technology. I had dabbled with JUnit and Ant, but wanted to take the next step: test-first development.

The authors obviously have a strong belief in testing. Here is a list from a companion article from the publisher's web site

"Top 12 Reasons to Write Unit Tests"
1. Tests Reduce Bugs in New Features
2. Tests Reduce Bugs in Existing Features
3. Tests Are Good Documentation
4. Tests Reduce the Cost of Change
5. Tests Improve Design
6. Tests Allow Refactoring
7. Tests Constrain Features
8. Tests Defend Against Other Programmers
9. Testing Is Fun
10. Testing Forces You to Slow Down and Think
11. Testing Makes Development Faster
12. Tests Reduce Fear

Any of these ring true with you? They did with me too. I immediately bought the book. I initially wanted to learn about Mock Object's to help build test rigging for a complicated environment at work. After my success, I thought the book would end up on the bookshelf, but, because the book is so approachable and easy to read I found myself exploring other topics (in my case XDoclets and the discussion on XP in general). Check it out. It's a really great (and hands-on) introduction to this technology!

The Java Extreme Programming Cookbook by Eric Burke and Brian Coyner features more than 100 recipes for using extreme programming tools. The tools covered are the build tool Ant, various testing tools, like JUnit, HttpUnit, Cactus and JunitPerf, and XDoclet. Included is also a chapter about deploying projects to Tomcat and JBoss.
As always with O'Reilly cookbooks the recipies you will find in this book are of great quality and go straight to the point. Even if you already are an extreme programming devotee (and who isn't ;-) you will find a lot of interesting tips.
Especially interesting is the chapter about Cactus. You need to test server side Java code? This chapter gives you a jumpstart introduction to it. You will learn how to set up and configure Cactus and how to write Cactus tests to test session tracking, servlet filters or JSPs.
This book offers a lot of great solutions and should not be missing in any bookshelf.

This book contains a set of "recipes" for common, important, non-trivial uses of a bunch of (free!) Java tools. The recipies are combinations of "how to" information and best practice recommendations.

The thing that sticks out most in my mind about the book is that while I already had most of the knowledge contained in it (I've used most of the tools in J2EE projects in the past), that knowledge took a lot of time to figure out along the way. This book like this could have saved me substantial time in setting up a project using these tools.

Extreme Programming appears in the title, but you don't need to be using that methodology to benefit from the contents; nearly all of it is applicable to any project following good software development practices.

I recommend this book very much to anyone wanting to add these tools (Ant, JUnit, Cactus, XDoclet, etc.) to their project.

I found this book immediately useful. I say immediately because the recipes presented in this book are succinct and to the point. It has already helped me in several consulting assignments.

You don't have to be a die hard believer in all aspects of XP to find this book useful either. If you're a Java developer and you believe in unit testing, this book is worthwhile. It will help you sort through the various tools out there and find the best one for your situation. It will also give you clear explanations and examples of good techniques.

If you are starting out in the Extreme Programming (XP) methodology, you will quickly learn the importance of running continual builds and unit tests of your code. And if that process isn't easy and automated, realistically it won't get done. Fortunately, there are a number of open source tools out there that are commonly used to take care of this. The Java Extreme Programming Cookbook will help you understand what those tools are, how they are used, and how to solve some of your common problems with those tools.

This isn't a tutorial on XP. Instead, it concentrates on the tools you need to make XP work for you and become part of your normal development process. In some ways, a more accurate title for this book would be the Java Extreme Programming Tools Cookbook. The format provides a nice basic introduction to each tool, where you can download it from (as well as where to find the complete documentation), and then a number of problem/solution scenarios from basic install to more complex automation tools.

For instance, let's take one of the tools; JUnit. JUnit is a tool that does unit testing on your code. You define a test class as well as test cases that should either pass or fail. Once you have your test class and test cases set up, you can quickly test your code after making changes to make sure that all the results are still accurate. In XP methodology, you actually write your test cases first, and then write the code to make them pass. In that way, your testing drives your coding. This book will give you the overall information on what JUnit is, how to install it, and how to run it. You then run into a number of situations, such as running tests concurrently, repeating tests, testing naming conventions, and organizing tests into test suites. Using the problem/solution layout of the Cookbook series, it's very easy to get the base information you need to stay productive.

If you are brand new to XP or the tool set, you might be a little lost since it's not a "step-by-step" how-to of each tool. It assumes you either have a small amount of working knowledge, or that you'll supplement your knowledge with the tool's documentation. Still, you can't look up what you don't know, and this book made me aware of some tools I didn't know existed. An experienced user of these tools might also gain a few tricks that they didn't know about, and it might be worth it for those tricks alone.

For Websphere developers, you might find that a couple of these tools aren't necessary. For instance, Websphere Studio does your build for you, so Ant isn't as critical as it would be if you were running a J2EE server such as Tomcat. Also, JUnit integrates directly into Websphere Studio, so it's very easy to run that tool in your environment. Even so, having this book will help you expand your horizons.

Conclusion
If you are a Java developer using the XP methodology, get this book to learn the tools you need to make your build and testing process flow correctly. Even if you don't practice XP, the automated build and testing tools will help you to write better code.

The recipes presented by Burke & Coyner are to the point. After reading through the first 8 chapters, I haven't met a recipe I couldn't immediately see use for in my recent projects.