This is a good book. But I have to say, for $30 I was surprised at how slim it was. There's a lot of good concepts covered, but nearly every implementation relies on a Java-specific tool. I would have loved to have seen the book spend a little more time talking about how to automate some of the tasks in a more language-neutral way. Nevertheless it is a good book, albeit one only genuinely useful to Java programmers.

This book brings together information possible found elsewhere, but saves a great amount of time looking for the information.

Wonder how to send a HTML Email without creating your own CSS?

Tidbits like this make this book worth it. If you're not using CruiseControl yet, you should definately consider it. Then pair it with CheckStyle!

Mike Clark deserves all the high rating everyone is giving him. He explains his material bit by bit and mixes in real world practical experience. Fantastic stuff! Definitely a learning experience without the struggles. You will get a great understanding of the hows/whys/what of automated builds. Very thorough stuff. Along the way, he comfortably steps you through Ant, Cruise Control and see what its all about. If you like easy gentle reads with clear explanations, this book is for you. If you want to get a good overview of automating a java development environment, this is it.

This book will save you from hours of work and from many headaches. Mike Clark's "Pragmatic Project Automation" will show you how to automate any aspect of your project that you find repetitive.

Clark starts by describing how to automate a build script using Ant. There are entire books on this subject but "Pragmatic Project Automation" does a great job of distilling the essentials of what you need to know to get started (and for most projects in total). Once you have an automated build, the next step is having it run automatically. Clark describes how to do this with Cruise Control, a tool that will build a system whenever new code gets checked in.

This book goes well beyond just automated builds, however. We next learn how to automate releases, including generating all necessary distribution files. Next up are how to automate the installation and deployment processes. Finally we learn how to monitor both our build process and our deployed applications. The book even goes so far as to tell us how to monitor the build process with a pair of lava lamps.

I highly recommend this book to anyone working with Java applications of any size.

Project Automation is an investment in the project infrastructure. This investment will pay huge dividends. Few developers want to spend their time fussing over a build or creating the new release, but it has to be done. This book shows how to get it done without sacrificing a developer to the process. At first, I was a little skeptical as to how much automation could be accomplished, but now I am sold. The time and aggravation saved are tangible dividends to this investment.

With anecdotes, coding examples, and a sharp wit, the author progresses from touting the value of project automation to showing how to do it. He starts the process of convincing the reader that automation is a good thing with an amusing story to illustrate the need and the potential. Using readily available tools like Ant and CruiseControl, the author carefully explains each step. While there is sufficient coverage on the use of the tools for the examples, reference documentation will be necessary to "roll your own".

On our last big project, I now realize that frequent automated builds would have saved a lot of time, which was in short supply. Because they became so painful we did them less frequently, rather we should have increased the frequency. I would consider this book an essential part of a technical lead's toolkit. Once the team can experience the benefits of continuous integration and project automation, they probably would not want to go back.

This is a good book. There is not much to lurn, as experienced Java developpers already know the road to continuous integration.
This book is primarily useful to convince your coworkers and managers that a good development process is key to the success of a quality software development.
The wireless Java lamp turning red when the build process failed is a bit far fetched, but most of the ideas are excellent.

For a novice to intermediate "build master", this book is a must have.

"Pragmatic Project Automation" is all about how to automate the tasks
associated with building, testing, and deploying your application. The
assumption is that your project is a Java project, and all the tools
are based around that. Most of the automation is done with Ant, an
automation tool written in Java and primarily used for building Java
projects. Since I do most of my work in java and ant, this is right
down my alley.

"Pragmatic Project Automation" is one of the "Pragmatic Starter Kit"
series of books. The words "Starter Kit" should be taken seriously.
If you are acting as build master for your first project, this is a
great book. It will have you up and running your one-step builds in no
time. It provides numerous "best practices" for running automatic
builds, unit tests, and deployment. Unlike the original "Pragmatic
Programmer," which was a collection of generally good ideas and
practices to follow, the Pragmatic Starter Kits are specific recipes to
follow for good results.

The book assumes that you are using Java; the ideas behind the
practices are universal and can be applied to any kind of project, but
the specific advice is for Java only. The specific tools recommended
by the book are Ant for scripting, CVS for version control, and Cruise
Control for scheduling. Obviously, other tools can be used instead,
but the recipes in the book will no longer work. The ideas remain valid, however.

I wish this book had been around 5 years ago when I first started
building Java projects. As it is, I had to learn much of this by trial
and error. Most of it is just simple, good sense, like having all your
source in version control and having a script to check out your code
and build the finished application. But like all good sense, it is not
as obvious and wide spread as it should be. Every project I've been on
could have used a good dose of pragmatic project automation.

Though most of the book was already familiar to me, I did learn several
things. One of the great ideas was to make build failures publically obvious through the use of lava lamps! If the build, or build tests, failed, the suggestion is to turn on a red lava lamp which is in a publically visible location. Ant does not actually have a lava lamp task, so they cleverly provide instructions on automating the lava lamp with the use of an X10 lamp module. When the build succeeds again, turn off the red lamp and turn on a green one. I haven't yet implemented this, but I'd like to.

Using ant for builds and CVS for version control is pretty standard,
nowadays. I think most projects do this or something equivalent (though
the statistics on this show that statement to be hopelessly
optimistic). This book does move on to a more advanced, and less
standard tool. They recommend performing builds automatically whenever
code is checked in, and their tool of choice is Cruise Control.

They provide nice recipes for setting up and running Cruise Control.
In my job, inspired by the book, we decided to try it and found it
quite simple to set up and use. It requires a little more
infrastructure than, say, CVS in that it runs inside a java container
like Tomcat, but if you are a Java shop you probably already know how
to manage Tomcat. If you don't, maybe it is time to learn.

If you are a new build master on a Java project, read this book
immediately. Even if you've been doing it for a while, you probably
won't be wasting your time if you read it. The book is well written
and accurate. It has a nice style that moves along nicely. At 176
pages it is not a very long read, a welcome change in computer books.
The author tells you what he has to say, then shuts up--there's no
padding here.

All in all, a good book. I'm glad I read it. I wish I'd read it 5
years ago.

Michael Hirsch

This book is a worthy successor to the previous two Pragmatic Starter Kit books. You've got unit testing down. You've got version control processes. But, you're a programmer who is manually slaving over all of these processes not to mention system monitoring, builds, and deployments.

Pragmatic Project Automation gives a wonderful, step by step recipe for automating all of the time-consuming, error-proned activities of a (Java) project. It also instructs and motivates the reader to think in this way, so that future opportunities for automation don't go unrecognized.

This one is a "must have".

This book is very short and tight, weighing in at only 150 pages. The book concentrates on automating the Java build, deployment and test process. It covers Ant, Nant, Maven, CruiseControl and other tools. But even if your specific tool or environment isn't covered you will still gain from the experienced based insight in the book, even if you can't use the code samples directly.

The text of the book is fresh, easy to read, and often funny. Graphics are used sparingly and effectively.

I certainly recommend this book for any build master, or someone stuck with the build master role. Though I really recommend the whole series for all engineers because they, as a set, will help you round out your entire skill set.

This third book in the "Pragmatic Starter Kit" series is the book I most enthusiastically recommend to developers and project teams. It completes the other two books, adding another crucial technique, and showing in the process how source control and unit testing can really help a project in practical ways. Interestingly, that also means that this third book serves as a good introduction to the other two.

Automation is one of those practices that can lead you to other good practices, teaching you to appreciate them and finally understand just how valuable they are. Every developer would do well to "catch the automation bug," and in the process they will learn a lot about other valuable techniques. Mike Clark understands that, and his book on project automation also serves as a terrific introduction to the larger practice of quality software development.

I'm a huge fan of the Thomas and Hunt Pragmatic series...but this current book is weak. Perhaps because its not written by Thomas and Hunt themselves, perhaps because it was so closely tied to a particular CMS, I don't know, but the book seemed to light.

As an example, early in the book there was a teaser about using a lava lamp as a build indicator with a note that it would be discussed later. The later discussion never explained the details of 'how' to this...expounding instead on why it was a good idea.

I'm not saying this book is 'bad'...just that its not 'great' like the other Pragmatics.

I just finished reading a very useful book... Pragmatic Project Automation by Mike Clark (Pragmatic Bookshelf). If you've ever wondered how to make your life easier as a Java developer, this will answer some of your questions.

Chapter list: Introduction; One-Step Builds; Scheduled Builds; Push-Button Releases; Installation and Deployment; Monitoring; Resources; Pragmatic Project Automation: Summary

The basic premise here is that most development teams spend far too much time managing the compile/build/deployment process because it's a manual one. And with manual processes comes the real possibility of errors and neglect. You should be spending more time coding business solutions and less time baby-sitting the infrastructure. Clark takes you through some of the freely available open source tools that can help you make the build process repeatable and automated. By doing this on a regular, consistent basis, you'll have higher quality software and faster response times to errors because you can narrow down to a matter of hours (or even minutes) when an error was introduced into a code stream.

Along with the "why" of doing this, you'll learn enough about the components to get you started. Ant will help you automate the compile and build process. cron scheduling can set up your builds to happen on a regular basis without your intervention. CruiseControl can take cron and Ant to a higher level and also send out notifications on the results of the builds. CVS is covered as a repository that should be where your code is stored and versioned. And NSIS is covered as a way to create an automated installation package for your most current release. While none of these technologies are covered in an all-inclusive way, there's enough here to get you started and to whet your appetite to pursue the matter further.

This isn't a big book... 161 pages. But there's a lot of practical advice and wisdom packed in there. Definitely a "must have" book if you're spending too much time as the "buildmaster guru" on your projects...

If you're involved in any type of commercial Java projects, you owe yourself to pick up this book. I'm not kidding.

"Pragmatic Project Automation", the third book in the Pragmatic Programmers' Starter Kit series, authored by Mike Clark, is an invaluable asset for automating the grunt work of your Java development projects and raising your standards regarding quality, lead times in bug fixing, and eventually, the motivation of your whole team.

I read the book over a weekend in two sittings and enjoyed every minute of it. Mike has put together a series of high quality tutorials for setting up a repeatable build process using Ant, scheduling the build process using shell scripts, cron/at, and eventually CruiseControl, while keeping in the spirit of pragmatic thinking. He then continues by showing how to automate your release process and software deployment -- with both simple shell scripts and an open source graphical installer tool. To finish, he talks about different techniques for monitoring your software for errors.

I honestly couldn't find anything to complain about this book -- except that I wouldn't have minded reading another 150 pages of it.

(The following is an excerpt of a review of "The Pragmatic Starter Kit" I posted at JavaRanch.)

The third and final volume of "The Pragmatic Starter Kit" series, "Pragmatic Project Automation" by Mike Clark, is an excellent guide on automating repetitive tasks that increase the quality of a software project, and the productivity and confidence of the team creating it. (Who wouldn't feel good around a glowing green lava lamp?) If you don't currently employ a system that automatically checks out your project from a version control system, compiles it, tests it, and reports back to the team the status of the build, after reading the first three chapters of this book, you'll have all the information you need and no excuses left not to create such a system. The remaining three chapters of the book are dedicated to teaching creating push-button releases - facilitating the practice of releasing early and often, to teaching automating installation and deployment, and to introducing a potpourri of tools and recipes for monitoring and reporting the health of a running system. I'd recommend this book to any software developer.

Pragmatic Project Automation: How To Build, Deploy, And Monitor Java Applications by programmer, consultant, author and public speaker Mike Clark is a straightforward guide for experienced programmers. Volumes one and two covered version control and unit testing, respectively; volume three of the Pragmatic Starter Kit series delves into practical means to deploy software reliably and accurately, as well as methods to reduce grunt work and eliminate bugs. Tested techniques for building and testing code at regular intervals form the core of this guide written especially by programmers, for programmers. Java examples, sample code, and explicitly clear instructions make Pragmatic Project Automation a first-rate, get-to-it resource.

I'm always on the lookout for tools to help convince and convert my more reluctant friends to my way of thinking, so I'm thankful to Mike for this book that is both informative and -- more importantly -- inspiring.

I've recommended other books in this series to several people, but their "starter kit" nature made them of limited interest to the more experienced. In contrast PPA takes my existing knowledge and experience with automation and throws down the gauntlet: "what possible excuse do you have for not pushing your automation attempts further?"

After reading this book you'll be motivated to squeeze the most out of every spare CPU cycle. Check it out!

In software projects, a lack of automation is like doing construction work without a hard hat. Not only is the risk greater that you will hurt yourself, but more importantly, working without a hard hat makes you nervous and slow when performing routine tasks. Pragmatic Project Automation explaines plainly how and why to automate the building, integration, and release of your projects. This book is a must-read for anyone who wants to have their software project succeed.

The book explains plainly how to use standard open source Java tools to automate your project. For the more advanced readers, the book also touches "extreme feedback devices" like lava lamps and build monitors.

It was right there in front of me. Why should I have to come in the office every morning and manually check the status of the nightly build when a green Lava Lamp can indicate the status for me?

Mike, once again, shows his in depth knowledge of the subject matter and adds a sprinkling of humor, an active imagination and real life experience that make this book hard to put down. It's easy to forget, we have all this horsepower surrounding us, sitting idle, while we complain about needing more manpower. This book opened my eyes to how much work could be done while I slept. Anyone who plays an active role in any part of the software release cycle should grab some herbal tea, fire up the incense, sit down in a bean bag chair and start reading

Where has this book been all my life?! Mike Clark's clear, concise, and fun style has me on the edge of my seat eager to find out what trick is next. His CruiseControl RSS publisher is already in action on one of my projects, and even more of these gems are working their way into my routine.

Mike didn't just stop when he finished writing the book. He is also running an ongoing site of automation tips/tricks that I encourage everyone to tune into.

Don't let its relatively small size (152 pages) fool you -- this book has more relevant content per page than I've seen in a technical book since, well, the last book I read from the Pragmatic Programmers ("Pragmatic Unit Testing", by Andy Hunt and Dave Thomas). In fact, I believe this book's compactness to be one of its greatest features.

Mike Clark has done a masterful job of distilling the essence of the topic of automation and presenting it in a well-thought-out, easy-to-follow progression. He finds a natural starting point -- the build -- and takes us from a simple on-demand build using Ant, to scheduled builds using CruiseControl. At each step he shows us how we can safely relinquish control to an automated tool, buying time and increasing reliability.

Subsequent steps follow in natural progression -- from simple builds to automated, scheduled, and triggered builds. From building the software to assembling a release. Then on to deploying the release. And finally, monitoring the release once it's deployed.

Don't be fooled into thinking this book is just for server-side Java developers. That audience is certainly a main focus, and the book doesn't have room to be encyclopedic by any means. Even so, Mike does a great job of pointing out alternatives where they exist -- if there's a .NET equivalent of a tool, you'll find at least a mention of it, along with a URL where you can go to learn more. There are shell scripts of various flavors sprinkled throughout the book. There's even an example written in Ruby!

Mike has a gentle, relaxed writing style. He doesn't -- as too many other technical authors do these days -- try too hard to impress us with his knowledge; he just lays it out there. He doesn't bombard us with overly formal (or informal) language, hackneyed metaphors, or lame jokes.

If you believe that time is money, then it follows naturally that saving time is saving money. This book will help you do both. I give it my highest recommendation.

I have applied a good number of the concepts in this book and have found them extremely useful. I was already doing a fair amount of project automation, but this book helped me fill in some of the gaps and made me realize where I was missing the boat. All in all a very accessible and high value read.

Aimed at Java programmers who are working on a project and who need to install a disciplined project framework on themselves. Clark assumes you're clued into the utility of having a version control system and of writing unit tests. Those were the subjects of his two earlier books in this series.

Now he shows plausible next steps in automating certain development steps. A lot of attention is focused on the build. Naturally. You can see how to use Ant and a lesser known open source program, CruiseControl, for automated building and running of unit tests. This is the most important part of the book and you should focus your attention here.

Clark also discusses other topics, like deploying over the web. Useful, but subsidiary.

There is very little jargon or acronym soup to navigate. Something to be thankful for.

This little book could double your productivity by showing you how to make computers actually help you do your job. Do you spend too much time chasing configuration bugs, following checklists, and performing repetitive tasks that take time away from your coding and design duties? Then "Pragmatic Project Automation" is for you.

This isn't the kind of "software process" book that tries to sell you on following a methodology. There's no preaching, and there are no outlandish claims of productivity increases. Instead of selling snake oil, Mike Clark just wants to explain, in a clear, effective way, how to use open-source tools to automate your builds, release process, and application monitoring. Java tools like Ant, CruiseControl, and JUnit are the centerpieces of this book, but shell scripts and batch files also make cameo appearances.

There's even a section on assembling novel monitoring devices. Admit it -- wouldn't it be cool to have red and green Lava Lamps that light up according to the status of your project build?

The beginning programmer might wonder what all the fuss is about, but anyone tasked with delivering software on a schedule will appreciate the many ways in which this book will help them.

Mike's book should be a desktop reference for anyone working on Java projects.

He first gives you a high level overview of why a concept is needed on your project. Then he shows you which product to use, and gives you a practical working example.

Whether you are learning how to use various build tools (like Ant or CruiseControl) or refining your existing project, this is a must have book. It's a "report from the trenches", not an academic analysis. You can read this book and boost your productivity the first day.

I've always been a tool-builder. When a solvable problem presents itself, I like to fix it with the simplest possible solution. This book--fun and interesting to read--is a wonderful collection of tips and tricks that will help you take simple everyday tools and do amazing things with them. By the time you are done reading it, not only will your builds be repeatable, but you'll have industrial strength monitoring and troubleshooting tools in place as well. Mike stays one step ahead of you and builds a compelling case for each tool as well as how to combine them. And, in the end, you might even end up with a couple of lava lamps out of the deal.

If you are doing any serious software development, then you have tasks that need to be automated. Your build process, unit tests, deployment, measurements of quality, and other metrics for project management can all be automated once, and then created over and over again, basically 'for free'. This is what computer do, right? So why not let them do it for software development?

Mike Clark does an excellent job describing both the 'high-level why' of project automation, as well as real-world 'low level' examples. He describes project automation with shell scripts, tools like Ant and CruiseControl, automation of routine tasks in CVS, and create automated 'status reports' with things like log4j and RSS feeds of data from your build report.

The day after reading this book, I had modified our automated build to send an email to my cell phone if it failed - along with the names of everyone who had commited a change since the last successful build. While not every project needs this level of paranoia, this kind of 'project safety net' gives us great confidence in the quality of our code.

It's hard to say what could be improved about this book - its biggest strength and its biggest weakness are its size... at 150 pages, I feel like there could have been so much more said on the subject... on the other hand, the books size makes it very approachable - you can pick it up, read it, learn something, and use it that same day. If the book were any larger, it would run the risk of trying to say too much, not saying it as clearly, and dating itself much more quickly.

This book (actually all three of the prag prog 'starter kit' are on our team bookshelf, and are considered part of our project's documentation.