Customer Reviews

Inside the Microsoft® Build Engine: Using MSBuild and Team Foundation Build (Pro-Developer)

5 star:		(15)
4 star:		(4)
3 star:		(0)
2 star:		(0)
1 star:		(0)

 

 

I've been working with MSBuild now for about a year and have learnt it solely from other people feeding me strips of information here and there. Recently I have been working on an enterprise project that requires the utmost attention concerning automated builds.

I searched for anything on MSBuild and came across this gem. Even though I have decent experience in MSBuild I read this book from front to back twice over and was exceptionally impressed with how this book was put together. The examples were very straight forward and understandable even to a few of my friends who have no idea about MSBuild. I feel that so long as the reader has an understanding of XML, then they can understand the examples in this book. The chapter 1 quick starts are greating for getting straight into the basics and getting a great feel for the direction the books takes you in.


There is some fantastic advice and guidance for customizing MSBuilds, batch building and incremental building and there are 3 chapters dedicated to Team Foundation Build which were highly educational for me in not only a gathering a better understanding of the build process in Team Foundation but also a stronger understanding of how to utilize Build Agents, retention policies, triggers, and unit testing within Team Foundation Build.

This book quite simply in my humble opinion, is a "must have" for anybody that is serious in learning the art of build mastering and is a "must have" for build masters as an A+ reference.

Kudos to Sayed and William for writing this much needed gem. Well done.

This book is outstanding. A literal step-by-step walk through of MSBuild and Team Build. I have been working with these products for almost a year and learned them on my own, via various websites, blogs, msdn walk-throughs, etc. There are a myriad of sources with bits and pieces of the information you need, and I feel this book pulls them all together in one very well written book.

This is the best source to get going from beginner to intermediate level with MSBuild and Team Build. Obviously you need to dive into the products and get your feet wet intensely to gain expert knowledge of the two. However, this book takes you leaps and bounds into an advanced level of knowledge. The msdn topics have everything else you need as a reference beyond this book.

I highly recommend this book to anyone who is both new or experienced with MSBuild or Team Build. Great work!

I'm a developer on MSBuild; Sayed wrote this book with our encouragement, and we reviewed it for accuracy and completeness, so I can recommend it. The documentation for MSBuild in 2.0 and 3.5 was not great; I consider this something like the missing manual. Unfortunately there aren't many other MSBuild books; fortunately Sayed did a good job on this one.

We're fixing a lot of what's "missing" in MSBuild in the upcoming version 4.0 -- I hope Sayed can do a 2nd edition when that comes out. Plus, our docs should be better then :-)

Dan

When the Microsoft Developer Division sat down to consider the future of .NET development from v2.0 onwards, they recognised the build process in Visual Studio .NET was primitive in its facilities. It had to be re-architected to provide a much more flexible and extensible mechanism. Thus the re-engineering endeavour that brought us MSBuild. Although it was modeled after NAnt and featured some intriguing concepts, widespread adoption was not achieved. As in, conscious manipulation and customisation.

Sure, most developers simply think Ctrl-Shift-B when "build" is mentioned; it remains an invisible compile tool in Visual Studio in their eyes. But for those who did knew the advent of MSBuild, the woefully inadequate documentation prevented many from properly understanding the arcane concepts it brings to the table. Lack of understanding directly affects utilisation. I was one such individual who struggled last year to find relevant material to explain what I needed to know and do to achieve what I thought were pretty common build steps. Suffice to state I was disillusioned and disappointed.

Which brings me to this executive summary: I wished Inside the Microsoft Build Engine: Using MSBuild and Team Foundation Build was published last year when I needed it.

This book is what the stock documentation should have been. Sayed Ibrahim Hashimi and William Bartholomew must have realised that - developers were not getting much out of those materials - and wrote the first three chapters of Part 1 to slowly and meticulously explain the concepts and important elements one works with in MSBuild. When necessary, line-by-line details are elaborated, and the MSBuild samples are always accompanied by sample prints of the console screen output as well to illustrate the point. While this is no excuse for relieving folks from trying things out themselves, it runs the extra mile to help me understand the theory since I tend to read while commuting. Being able to finally grasp those elusive concepts was a joyous event.

The book also covers extensibility avenues, teaching the underlying framework and showing how to develop custom tasks and loggers, even how to refactor the MSBuild project elements into smaller files; they give a clearer picture how all these pieces combine together to form the entire build workflow and possible extensibility points for one to inject custom targets and tasks. But this book is not just about the official stock product either; the authors recognise weak points in the current implementation and devote a significant portion of the book to suggest a variety of alternative solutions from third-party add-ons from CodePlex or Tigris to overcome problems that may be commonly encountered by build teams. Differences between MSBuild 2.0 and 3.5 are also noted to provide readers with heightened awareness of what they can or cannot do with a particular version. The last Part that details working with Team Foundation Build is also an extremely helpful segment that I have been dying to know how builds are implemented and managed in Team Foundation Server.

As much as I love this book for filling critical gaps in my MSBuild knowledge, one thing that I did find lacking was a full-fledge demonstration of how to define an end-to-end build project that does different things all based on conditions from the previous steps. Like, invoking code analysis only if unit tests all pass, building and deployment release configuration only if debug configuration passes tests, emailing to the team the statistics or status of deployment, etc. Many of the demonstrations are isolated in their demonstration. While the content has done a fine job explaining the individual concepts, MSBuild as an XML-based semantic still remains highly arcane; more unified samples would have helped many. There is no mention of [..] either, which probably means it is not as popular as I was led to think.

Any build engineer or developing tinkering with project builds, absolutely needs to read this book. It will fill many of the blanks the standard documentation never provided, and widen your search for better ideas to improve your build.

Overall rating: 9/10
Good: Must-have supplement to SDK docs; meticulous explanations; liberal alternative recommendations
Bad: could have demonstrated more unified, sophisticated build sequences with conditional paths; no [...]

This is a well written book on the MSBuild system. I was working on an open source project that will generate the MSBuild scripts and wanted to understand it well enough to take maximum advantage of it.

This book is all that I was waiting for, it is worth the price. The explanations are simply and very clear - easy to understand language. There are few mistakes, but you can easily tell. After reading the Quick Start (Chapter 1), you know you are in very good hands.

The book can be used by any user of the Visual Studio or .NET Framework 2.x or later, and unlike many out there, it does not attempt to teach you how to install VS.NET or how to use it.

My only wish is that the complete definition of each tag is presented the first time it is introduced, so that you know at least all its attributes, without having to refer to the Appendix or other resources.

Pay attention to the title. This is a book about integrating Team Foundation Build and MSBuild.

I'm someone who had been using Ant and Cruise Control, and wanted to try out MSBuild. I picked up this book, as it was one of the few references out on the market.

This book assumes that you have a basic understanding of MSBuild itself. It does not start off with the basic "hello, world" nor does it hand hold you through your first MSBuild file. That's fine, it doesn't pretend to be a beginner's guide.

The book references several open source projects full of MSBuild tasks. But it doesn't go into detail on how to use any of them. It's up to the reader to look at the documentation available and figure out how these tasks work. What it does well, is give a general overview of what's available, allowing you to re-use the work of others.

Once you've built up the required critical mass of knowledge about MSBuild, this book really shines. This book walks you through the integration with Team Foundation Build. How TFS calls the MSBuild files. It also walks through a few cookbook examples of common problems. It will review the installation and configuration of Build Agents and Build Definitions.

Overall, I found the book provided the information as advertised. It's not a one-stop shop for MSbuild itself, but it doesn't claim to be. If you're looking for how to use MSBuild, this isn't the book. But, if you're looking for how to use Team Foundation Build with MSBuild, then this is a fantastic reference guide.

One of the problems I have noticed with Team Build adoption is that there were no good books covering Team Build is practical detail. The MSDN documentation is not adequate. Early adopters really relied mainly on Buck Hodges and Aaron Hallberg's blogs (and more recently Jim Lamb's). You could find a chapter or two in books covering TFS or VSTS, but not enough practical information to enable you to jump in and start using Team Build in real world scenarios and integrate it into your company's or project's development process.

In fact, this lack of resources on Team Build also resulted in a lack of good tools leveraging Team Build 2008's capabilities that have not been exposed out of the box. This actually was what prompted me to release the Buddy Build tool on CodePlex (http://codeplex.com/buddybuild) to help fill in one of those gaps, in particular the one related to buddy builds and gated checkins, prior to their appearance as first class citizens in TFS and Team Build 2010.

The first good contribution from a publication came with Jamil Azher's Team Foundation Server 2008 In Action, a relatively good book on TFS 2008. However, its coverage of Team Build left a lot to be desired. Then came this book.

I met William back in September 2008, through email when I was looking for a TFS MVP to co-own my Buddy Build project prior to releasing it on CodePlex (I met him also in person while he was in Redmond for the MVP Summit 2009). Back then, the Buddy Build tool was only an internal project used by a couple of groups at Microsoft. William was gracious and generous enough to accept to be a co-owner and dedicate some time to help release the project as open source to the community so that many more folks are leveraging and extending it. When William mentioned that he was working on a book on Team Build, I was anxious to see the result of that. And I have to say it was certainly much better than I expected. Now I can finally recommend a good book on Team Build 2008 when I am asked, rather than pointing folks to Buck's and Aaron's blogs and the MSDN documentation.

If you are someone new to Team Build 2008, or someone tasked to extend their development and build process and leverage Team Build 2008, then this book will help get you started in a well-paced way. Team Build's functionality in 2008 is based on MSBuild and most of that functionality is spread out between Team Build's core MSBuild script and the library of MSBuild tasks that the Team Build team has written. So, this book's focus on making sure that MSBuild is explained to the tiniest details is a big win. The explanation and coverage of MSBuild is something you will not find in any other book (or even MSDN). The cookbook recipes are also a good collection of reusable and practical code samples that you can reuse in your own applications. And most importantly, they are explained in detail! MSBuild is critically important to Team Build 2008, and it will continue to be so in Team Build 2010, even with Windows Workflow (WF) defining the core build process. The project/solution build process is still going to be MSBuild-centric. Also, the Team Build coverage in this book is unparalleled. This is the definitive guide on Team Build 2008. I was particularly impressed with the Team Build Cookbook chapter, especially the load balancing discussion of the tool that William wrote, as this is a topic I am very interested in and have had solutions addressing it in the Buddy Build tool. It is great to see a book that covers a product so well without presenting a rehash of the product documentation.

William and Sayed have also done a great job of pointing out the MSBuild features that are new to v 3.5 (see appendix A of the book) as a lot of people still don't leverage those so well. Also great was appendix C which describes some of the new features coming out in TFS/TB 2010, based on the CTP version. This is probably a good segway to William and Sayed's potential next book that would cover Team Build 2010 and the WF-based build process (hint, hint).

This book is well worth every penny you spend on it. I enjoyed it a lot, and I even learned from it. I also know other here at Microsoft that use it as an important guide. That's why I now highly recommend this book to anyone interested in understanding and leveraging Team Build, and I also link to its Amazon page from codeplex.com/BuddyBuild. There is currently no book that comes even close to covering the topic in such detail and with such immediate practical impact. It delivers the best bang for your buck, easily. Quite frankly, I never imagined that such a book will actually come from someone outside of the Raleigh-based Team Build team.

First off, this is a fantastic book. I used the 1st edition with TFS 2008. This new edition includes great content for the new, completely revamped, build workflow process in TFS 2010.

However, as a new Kindle user, when I went to purchase the second edition, I ended up with the wrong one. After returning it via the Amazon Kindle return process (which is pretty painless), I was able to get the correct version. I wish Amazon had a better way of classifying/naming their book versions. They should call the Kindle versions "Version 1" and Version 2" to coincide with the book versions. Instead, there is the regular Kindle version (which is the new one!) and the Kindle "November 11, 2009" edition. Hover your mouse cursor over the Kindle links to see which picture appears. If you want the newer edition, be sure to click on the Kindle link with a "2" appearing in the picture of the cover.

As with any IT books for the Kindle, watch for missing content. I've been seeing this problem with a lot of IT books from Amazon. Maybe we need to create a web site called MissingKindleContent.com or a way (unknown to me!) to report Kindle errors to Amazon so they can fix it.

So far, no problems with this book. Big thumbs up!

This book goes out of its way to both demystify the automated build procedure, and offer you a rich reference on all the custom XML "code" that can be used to better manage your Builds. The best part is that TFS uses the exact same build engine the developer uses on his or her workstation, the MSBuild engine. Which means that this guide can not only help you figure out how to tweak custom build definitions for a Team Foundation Server environment, it can also be used to define build rules for any Visual Studio Web Project, in particular a Web Deployment Project.

We had a problem in my shop in that our developers created Web Sites instead of Web Applications. It didn't make any difference to them, but it caused a huge amount of headache when it came to auto-deployment. One of the biggest hurdles, for example, was that TFS' Build would not be able to properly pick up third-party .dlls unless we added them to Source Control...which then created a Source Control headache for the developer as their own code would get 'locked out' if more than one developer was using the same .dll. Thanks to this book, I was able to add a Web Deployment Project to precompile their code, customize the rules, and then leave the work in a place for TFS' Build to pick up and deploy. The explanations of how it work helped me understand and troubleshoot some very intricate and low-level problems with the build process.

I highly recommend this book to anyone who plans on using any form of automated build system, be it custom Web Deployment Projects or automated build & deployment in a Visual Studio Team System environment: it demystifies both Visual Studio and Team Foundation Server. It isn't an easy read due to the subject, but the authors describe the material in the easiest way they can.

I got this book because I had been given the responsibilities of build manager in my org. We wanted continuous integration, automated builds, easier deployments (to dvlp, test, and prod). So I bought this and started getting familiar with MS Build. And it's helped. It got me from zero to running but not exactly polished in a few weeks.

The book is divided into two parts - MS Build and Team Foundation Server with MS Build. The first section goes over ms build basics such as .proj files - how they work and what you can do with them. The second section covers setting up and using TFS to handle your build management needs - automated builds, CI, etc.

This book is readable (this isn't faint praise if you've read some of the tech books I have) and has excellent, very helpful, examples. Like I said, it gets you going. The last thing I would say is that this book was very useful in helping me get started, but, MSBuild is a tricky thing. I have had many a frustrating day figuring out what it's trying to do and where I went wrong. The nature of the beast is that no book is going to be a silver bullet, but this book easily earns it's keep and I strongly recommend it if you are going to be working with MSBuild at all.