Team Foundation Server 2008 in Action

This is an incredibly helpful book with the focus on real-world examples and a must-have for Application Lifecycle Management (ALM) practitioners. Succinct, clear, and comprehensive; this book provides you a solid foundation and practical insights on how to use Team Foundation Server (TFS) effectively in your organization. One of the highlights of this book is that it covers the key topics like Team Build, Branching Models, Customizing and Extending TFS at exactly the right level. The real world scenarios and practical code samples helps you to understand the power, complexity, and benefits of TFS. This is a, credible, engaging, and a well-written book. Simply a must-have!

While I'm a stronger advocate for Subversion due to it just being simpler to maintain (and just as powerful) and having used both in the past at several jobs, I will say that since my boss still did want to move to TFS 2008 :(, that this book is therefore however a must have. It is: 1) Quick and to the point chock full of very useful real-world information 2) A book that will save you a lot of hassle based on a lot of FYIs and tips that the author makes notice of that you typically hit your head against the wall with TFS. Example is all the different statuses and just weird process of checking in and out files. There are many times that myself and other developers at past jobs hated TFS and loved Subversion because TFS does all sorts of crap that you just don't get. There are weird things that just "happen" and are not obvious leading to sometimes a very highly frustrating experience when checking in, out, and merging files. That's one of the reason TFS is hated so much outside of just build management (yes it's improving but still a huge burden). So this book explains well the complexity of the check-in and out process and the hidden "wtfs" you often ask yourself when TFS doesn't do what you expect. 3) A nice compact & short book. Don't let this give you the impression that there is not much in it. It's quite the opposite but done in a fashion that's very easy to understand and read. I would highly recommend reading this book first before diving into 100 pages on TFS in MSDN which is just information overload at first. Again this is a HUGE application, whereas subversion is not but again just as powerful. So if you are goign to do TFS, read this book first over a weekend to save you a lot of future frustration and ? that will most definitely tie you down initially. 4) Gives you a decent amount of information in many aspects/topics of TFS 2008 including the DB schema and DB builds, TFS source control, builds, etc. It's amazing how this book covered so much in so little pages but did so by giving you still a good amount of understandable information. 5) A book with plenty of diagrams & screen shots to compliment the text. The author has done a nice job with diagrams & pics. Obviously we want color more and more but he has taken great time to really show screen shots and outline with text and lines in his drawings to explain what you are reading. He has a lot of process diagrams which is essential I think other than just reading plain text all the time in a book. Pictures mean a thousand words in tech books. I do not like books that are just all text. The more illustrations (pics), the better even if the book is fatter because of it. Everyone learns and remembers differently (hence why the Head First books are so effective). This is nowhere near a head first book but he has packed it full of pics and I applaud him for this especially with a system so vast as TFS. 6) Not just "how" book but a "why" book. Why do I say

Being one of the few books on TFS 2008 itself, doesn't try to be a tome on all things TFS. It covers specific topics that people trying to implement TFS would be interested in: branching, merging, automated builds, and customizing it to meet their needs. I really like the Team Build chapters. You get a bunch of information about how Team Build works, how to do builds from labels, and how to do distributed builds. It also offers some insight on the actual code within the TFSBuild.proj file through call-outs. If you're looking to expand TFS beyond what comes out of the box, he last two chapters are definitely worth looking into. The latter half of Chapter 9 covers how to add custom controls to work item templates. It's not just a "take a control and add it to the work item template" exercise, it provides the technical approach of how to build the control and how to add it to the template. It also covers how to extend the underlying TFS data warehouse to get additional business intelligence out of the repository. If you were interested in creating your own workflow within TFS above and beyond what you can do with the Work Item Templates, the last chapter covers how you can do that using Windows Workflow Foundation (WF). I had always thought it was possible and this chapter shows you how its done. There are a lot of reference links throughout the book to get further information, so the content certainly isn't stale, and the material certainly isn't just a rehash or a collection of material that you can search the Net for. Yes, all the material may already exist on the Net, but having it in one place with examples and annotations like that found in this book, in my opinion, is worth having this book in your collection. I definitely recommend this book for developers, development leads, and consultants who want to get more out of their TFS investment. NOTE: I rated this 4 stars for the general public. If you're a TFS users, consider this a 5-star book.