Customer Rating:  
Summary: Good information on NAnt and CruiseControl
Comment: 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.
Customer Rating:
Summary: Poorly-written and painful to read
Comment: 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?
Customer Rating:
Summary: great tools explanations
Comment: 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.
Customer Rating:
Summary: A decent introduction to NAnt and CC.NET
Comment: 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.
Customer Rating:
Summary: A Must-Read for Anyone Doing Significant .Net Development
Comment: 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.
|
|
