This serves as a good introduction to NAnt and NAnt contrib. Working through the excercises was helpful. The introduction for CC.NET is also good.

I recommend this for anyone new to NAnt and CruiseControl. I caution the use of Continuous Integration. It is an excellent way to immediately identify build and integration issues; however, you have to beware of "false positives". For example, an auto-build everytime something is checked in will determine if that checkin causes a build failure with everything else that is checked in.... however, you need to do some soul-searching to determine if this is what you really want. Do you want to trap failures and correct them, or determine a development strategy ahead of time that will prevent these surprises? The continuous build isn't a bad idea, but it becomes troublesome if you are substituting that for a good development and integration plan.

This book is simply arduous to read. I kept looking to the "About the Author" section for a hint that perhaps this was a translation from the Russian original, or something. Vague sentences, paragraphs, and overall structure haunt this book, and make it a task to read. Did this book even have an editor?

Holmes gives you a very motivated guide to using NAnt and CruiseControl.NET. I'm from the linux/Java world, and am familiar with Ant. So the NAnt discussion was very relevant to my experience. Holmes explicitly says that this book is not a comprehensive guide to the abilities of either package. But in some ways, while not comprehensive, it may well be better than a text devoted to either [or both]. You can see in Holmes' text, very plausible ways for why and how you can use those packages. Going through the chapters, he delves into a detailed practical application. Helps you build a context in which you might use the tools for yourself.

I was unfamiliar with CruiseControl.NET. But ended up being impressed with how it lets you do this agile, continual integration. On the broader issue of explicating issues in code delivery, I tend to agree with a previous reviewer, Koskela. Who stated that the book doesn't give a bigger view than that of the tools. Though it certainly does that well.

I picked up "Expert .NET Delivery Using NAnt and CruiseControl.NET" as a developer familiar with the original open source projects, Ant and CruiseControl, from the world of Java development. I have been long interested in how "the .NET people" do things even though my personal experience with .NET technologies has been limited to doing a day of training every now and then. From this perspective, I have to say I find a lot of good stuff in this book but it's still missing that something. The author, Marc Holmes, clearly states in the introduction that the book's goal is not to be a comprehensive guide for the tools being used. Instead, his focus has been to show the reader a practical approach to tackling problems involved in "delivering software." I had some difficulty seeing that focus while reading.

The first chapter titled "A Context for Delivery" is actually an excellent albeit short overview of the variety of aspects involved when discussing how to manage software configuration, the build process, and the deployment process. The next couple of chapters
introduce the NAnt build tool and its essential built-in tasks. As a tutorial to NAnt, these chapters felt a bit too lightweight. Chapter 2 is an excellent tutorial for getting started with NAnt and chapter 3 briefly enumerates the most important built-in tasks available. These first three chapters were definitely the ones I liked the most.

Chapter 4 presents a simple case study, getting a GUI application for performing XSLT transformations to build with a NAnt script. The author follows through creating the script from scratch, all the way from the classic "clean" target to checking out the project from Visual SourceSafe, incrementing a version counter on assemblies, running automated tests, static analysis, and packaging the build output into a .zip file for deployment. There's some discussion of NAnt features that weren't illustrated in the previous chapters but not much more than that.

Chapter 5, titled "Process Standards", talks about the case study team refactoring their build scripts towards a structure that supports a "standard" build script to be used throughout the company's .NET projects. Very little meat in there. Most of this chapter seemed to present a topic of interest only to move on right away, without giving solutions beyond tiny snippets of NAnt tasks. As someone not familiar with most .NET concepts, I found it very difficult to follow.

Chapter 6 brings continuous integration into the picture. After a brief explanation of why one would want to implement a continuous integration process, Holmes proceeds to describe CruiseControl.NET and how to configure it to build your .NET project. Again, only superficial coverage of the configuration options available which is consistent with the stated goal of the book not being about the tools themselves. Yet, at this point I realized that the good stuff had all been about the tools -- NAnt and (to a smaller degree) CruiseControl.NET. This pattern continued through chapter 7 which talks about extending NAnt with your own custom tasks. In fact, this chapter does a good job in showing the ropes through developing a FxCop task.

Chapter 8 is a good one. It talks about techniques for dealing with the database schema in the context of continuous integration and incremental development. The example scripts do leave a sense of "magic" happening that I would've liked to know more about, but even as such this chapter can be useful for getting started with automated integration of the database alongside the application.

Chapter 9 talks about code generation (with XSLT and CodeSmith) and how to incorporate it into the build process. The examples were a bit difficult to follow and there wasn't much background on the tools (CodeSmith and XSLT) themselves.

To finish off, chapter 10 presents some closing thoughts as a summary for all the things discussed in the body of the book. Good stuff, makes a lot of sense. I find it interesting, though, that beyond the first and last chapters I found very little content that I could associate directly with practical delivery other than from the tool perspective.

As a summary, I consider "Expert .NET Delivery Using NAnt and CruiseControl.NET" to be a nice tutorial for NAnt and CruiseControl.NET. Having said that, a large part of the book seemed to be somewhat disconnected from the stated goal of showing a practical approach to problems in delivering software.

I picked up this book last week and within a few pages already had major ideas for my build system. I had been struggling by with a very basic, very weak continuous integration system using CruiseControl.Net and NAnt, but I had no idea the kind of power these tools give you, nor did I have a real understanding of what a good enterprise build system should do.

Well, that problem has been rectified. After reading most of this book I was armed with the knowledge I needed to go out and put together a build system I can be proud of, one that presents real value to my development rather than just being there so I can say "ya...I use continuous integration" - a situation that I suspect is not uncommon.

So if you are doing any signigicant development work with .Net you definitely should read this and learn how to make a build system that works for you and provides real and significant value.

Great NAnt & CruiseControl.NET reference for .NET developers. The author includes several related & helpful discussions, such as, how to apply code generation techniques. But since some of the subject tools have yet to be updated for VS.NET 2005, the samples might not work too well without a little testing. :-)

Holy smokes, what a terrific book! This isn't some fluffy, shallow overview of a toolset; rather it's about real world delivery issues and dives deep into very practical, real world details.

Disclaimer: I got this book free as a giveaway for our .NET Developers Group. Some folks might think this could influence my opinion, but they'd be wrong.

What's cool about this book is that the author, Marc Holmes (no relation to me), approaches the process of designing a good delivery system/methodology just like designing good software: a few use cases with expected outcomes which are used as guidelines for building up the various scripts needed to get delivery tasks done. He's got a great blurb at the start of the book: "Design for delivery." That's how he approaches the tasks necessary to make an end-to-end solution for automated, reliable software delivery.

Marc uses one software product as an example through the entire book, starting out with a simple product then moving into more complicated configurations. He uses an evolutionary process to get the build and deployment scripts up and working. He starts out with a simple, rough build script which works, then refactors to demonstrate the power of the tools covered in the book.

The author covers NAnt fundamentals in very good detail, but he makes it clear the book's not a reference for any of the tools he uses. He covers features necessary only to get his job done, but that coverage is in great depth and is in very clear detail. He shows off some pretty cool stuff about NAnt, including how to wrap in third-party tools (FxCop, before its inclusion as a nant-contrib task, e.g.), then walks through some good tutorials on extending NAnt.

The book's centered around NAnt and CruiseControl.NET, but he also integrates other tools like FxCop and discusses how to use code generation tools to help solve complex issues in build files. CodeSmith is covered in detail for this task.

Two things make any automated delivery system particularly difficult: source control and database integration. Marc covers both topics in great depth in separate, detailed chapters. He starts out by laying out the end goal and what process standards should apply to the routines. He then moves forward with basic implementations wrapping Source Safe and database integration into the process.

A complete download of all the various build files, tools, and source code examples is available from Apress's website.

An important note: I think this book is applicable to cross-platform use. Sure the specific tools are NAnt and CruiseControl.NET (plus several other widgets), but many of the concepts are applicable to folks doing Java development using Ant and CruiseControl. Furthermore, I think this book pairs up terrifically with Steve Loughran's Java Development with Ant. Loughran's book was a terrific eye opener to me for specifics of laying out projects with abstracted build files, plus he hits testing, deployment, and library inclusion too. Both books together really help out folks using Ant/NAnt and CruiseControl/.NET.

This really is a terrific book, and a must-read for anyone looking to automate their build and delivery processes.