Continuous Integration in .NET
Buy it now
One Minute Bottom Line
|I don’t think there is a better way to start CI in .NET than reading this book!|
ReviewNowadays developers hear every day in articles about miracles that Agile methodologies do in development teams. Seasoned developers sometimes find those practices a little bit naïve, while junior kids spend hours asking themselves when they can start to write code, instead of playing with post-it or boards.
But I think there’s no one that meets Continuous Integration (CI) and doesn’t understand its value, instantly.
I’m one of these people, so when I started to change my mind about development by looking for better ways to release working code, I began to read here and there over the Internet about tools that would help me to do it right in a .NET manner; but I didn’t find a good enough resource to accomplish my requirements - no way to get all I need, and all together.
Fortunately today this is only a bad old story: now we can buy a copy of “Continuous Integration in .NET”, by Marcin Kawalerowicz and Craig Berntson, and start to enjoy CI in matter of hours!
If Manning decides to publish a book, it’s unlikely that their shelves would host a useless book. I’m a fan of this editor, for no other reason than this publication's quality. My enthusiasm for this book was at the same level as when I read a new edition of “C# in Depth”, by my hero, Jon Skeet. :-)
This book is well written, well organized, full enough about stuff to become operative even if you are just a solo developer, without the help of a sysadmin or a skilled CI coach. It is organized in three parts: “Make it happen”, from chapter 1 to 6, put readers in the proper condition to start doing; part two, “Extend it”, helps us to refine some roughs edges; while part three, “Smooth and polish it”, gives us some inspiration about extending concepts, for example in databases.
The first chapter pushes the reader inside CI, starting with an introduction to what CI stands for; after that we find a bird's eye overview about tools and methods we have to use to do it right, making clear concepts like versioning systems, unit testing and build automation, with a particular focus on reducing project risks and team member drawbacks during adoption.
The second chapter helps readers to setup a Control Versioning System (VCS); this kind of tool is quite popular, but if you don’t use it (or if you use is it in the wrong way) this chapter will tell you all the things you have to know, from theory to working environment; the protagonists are Subversion and Team Foundation Server. I’m sad not to see almost one DVCS (Distributed VCS), like Mercurial or Git, but this is only a little flaw.
Chapter 3 is about build automation, an essential part of CI. MSBuild is the tool of choice, just for his great background in the whole Visual Studio guided development, but even NAnt finds space here.
Well, we are now at a crossroads: what is the right CI server for our needs? Chapter 4 tries to help us make the best choice. In these pages we will learn to setup CruiseControl.NET, TeamCity and Team Foundation Server Team Build (this one only for the bravest…); personally I think TeamCity is the most interesting solution, even CC.NET is a solid and effective alternative (if you are ready to pay the angle-bracket tax:-)).
We have a code blender now, finally! :-)
Now we have only to commit code, and wait… Oh no, my build is broken!
Chapter 5 helps readers to get notifications and feedback from their CI server, learning basic tasks to operate when things go wrong. Furthermore, we can get informed when code quality decreases, and if you like fireworks, there’s a paragraph that will teach you how to integrate a LED message board. :-)
In chapter 6 we will learn the fine art of testing, in all its tones, making use of NUnit or MSTest; the chapter is good enough to start, but if you want to get more from your testing experience, the authors and I will recommend the great “Art of Unit Testing”, by Roy Osherove, another Manning best seller.
Part one finishes here, and I can assure you that if you get these things working you have made the most of your CI process already.
Chapter 7 starts part 2; we find here some advanced topics, like acceptance testing, UI testing, mocking and integration testing. Things become more difficult here, but Marcin and Craig find a way to explain it in the easiest manner. Topics are not analyzed in depth, but as a starting point I can say this chapter is a good one. FitNesse, Rhino Mocks, Selenium are some of the tools discussed.
Chapter 8 makes the rules. Did you ever smell your code? Have you ever found it just stinky? Well, eau de cologne is not the solution. :-)
When you feel you can write better code, but you cannot remember all the “best practices” you have ever read, some tools like StyleCop or FxCop come in handy: we find here a way to set them up. NDepend and TeamCity's tool for duplicated code searching have their mention of honor, too.
Part three is not strictly related to CI, but gives us some interesting advice.
Chapter 9 helps us generate better XML documentation with SandCastle; chapter 10 talks about deployment and delivery with WiX and MS Deploy and Chapter 11 tries to explain a thorny argument like CI in databases, using RoundHousE. Chapter 12 points the readers to the next horizon, where simple CI users can become masters.
At the end, I can only confirm the great value of this work, not only for the variety of tools discussed, but mainly for the super fast effectiveness of setup procedures, that give us the opportunity to make things work during the reading.
If you wanna do CI in .NET, don’t look further: this is “The Book”.
(Note: Opinions expressed in this article and its replies are the opinions of their respective authors and not those of DZone, Inc.)