Book Review–Continuous Integration in .NET
Disclosure: I received a review copy of Continuous Integration in .NET from Manning.
I don’t normally blog book reviews – mostly because it requires a specific skillset that I do not necessarily possess. However, due to some fortuitous timing I jumped on the chance to receive a review copy of Manning’s new title - Continuous Integration in .NET by Marcin Kawalerowicz and Craig Berntson.
One of my many hats right now is version control manager of our team – a role I inherited rather than requested but one that nevertheless led to a deep interest in all things VC and build related. Due to the restructuring of MSDN’s licensing tiers our team is finally in the position to utilize Team Foundation Server as our version control repository. Having successfully sold the migration to the powers-that-be, and having previously started the team down the path to TDD, I’m interested in leveraging a number of incorporated technologies – at the very front of the pack is Continuous Integration. Our shop has never had a CI process, but that is about to change.
The version of this book I read is a MEAP (Manning Early Access Preview) meaning that it is not the finished product. Specifically, and sadly, the final chapter Scaling Continuous Integration is not complete at this time. My review is of what is available as of 9/20/2010
· Explain why we need Continuous Integration
· Define the basics
· Go through full setup and lifecycle
· Provide tips and tricks for advanced scenarios
· Provide advice based on real world experience
Continuous Integration in .NET as expected starts out with an introduction to Continuous Integration, explaining in simple terms why it is needed and how it can be used. The notion of source control is introduced and then a manual automated build is illustrated showing how one, if they so desired, could do the grunt work to set up a trivial automated build. The 4th chapter, Choosing the Right CI Server, is where the real meat begins and the rest of the book deals with integrating commonly used technologies – unit testing frameworks, deployment tools, documentation generators, etc. – with the CI tools of choice.
After reading this book for a little while it hit me that the Continuous Integration itself is little more than an aggregation of other technologies and mechanisms, bundled together towards the common goal of automating tasks that may not otherwise receive the attention they deserve. The book acts as a 100 foot view of Continuous Integration in .NET environments. The authors do not choose a specific CI tool, but instead use Team Foundation Server, TeamCity and CruiseControl.NET, evolving their CI process by adding new steps as the book progresses. I really enjoyed the comparison of these CI servers and, while concise, it highlighted well the reasons to choose one over another. I’d like to have seen a few more thrown in for good measure but, frankly, these seems to be the big players anyway so I’m probably being picky.
The book’s greatest strength is probably also its greatest weakness – the huge scope of CI, coupled with the use of 3 CI servers, means that generalization is preferred to specialization and the book covers MANY of the basic tenets of CI, but does not delve very deep into any one topic. This is not a criticism of the title – it appears to be an explicit tradeoff that the writers made and was not unexpected. By the end of the book a novice should know exactly what CI is, the different types of automated builds available to them and integrate everything from email notifications to unit testing to code analysis…and then some. The book is easy to read and never feels overly technical (perhaps because of the content material) and I found it very accessible. If, despite my grogginess, I can read a technical book on my morning train ride to work, then it deserves some credit!
Because I am already very familiar with Version Control, Unit Testing, WiX, Clickonce and a number of other technologies in the book I felt myself skimming over a lot of material that would have been useful earlier in my career. I speed-read my way through the sections on unit testing and found that there while the authors did a good job of explaining how to integrate such testing into one’s CI process and have the results displayed through the CI GUIs, most of chapters 6 & 7 were wasted on me. I’d like to have seen more real world information and definitely some gotchas based on industry experience. Unfortunately such information was not contained in the MEAP version I read.
Interestingly I would love to give a copy of this book to (junior) newcomers on our team. Not only does the book provide an excellent description of the ins and outs of CI but it also explains in detail a large number of best practices in the software industry today and illustrates practical approaches to implementing them.
All-in-all this was a good book, definitely worth reading. It hit about 3 of 5 of my expectations (listed above) and as a precursor to my first foray into the world of CI it was useful to get a lowdown on the CI options available to me and guides to hook up other technologies to these CI servers. I’d definitely recommend the title to newcomers to CI and also to those interested in related technologies. However, if you’ve already leveraged CI, or are proficient with Unit Testing/Code Analysis/etc. the value you derive from this book may be a little more limited.