Visual Studio Team System: Better Software Development for Agile Teams [Paperback]

Will W. Stott (Author), James W. Newkirk (Author)

Book Description

Publication Date: May 27, 2007 | ISBN-10: 0321418506 | ISBN-13: 978-0321418500 | Edition: 1

<>Make the Most of Visual Studio Team System in Real-World Agile Development

Visual Studio Team System (VSTS) gives Microsoft development teams a powerful, integrated toolset for Agile development. Visual Studio Team System: Better Software Development for Agile Teams is a comprehensive, start-to-finish guide to making the most of VSTS in real-world Agile environments.

Using a book-length case study, the authors show how to use VSTS to improve every aspect of software development, step by step–from project planning through design and from coding through testing and deployment.

Agile consultant Will Stott and Microsoft development lead James Newkirk carefully integrate theory and practice, offering hands-on exercises, practical insights into core Extreme Programming (XP) techniques, and much more.

Coverage includes

• Using VSTS to support the transition to Agile values and techniques

• Forming Agile teams and building effective process frameworks

• Leveraging Team Foundation Version Control to help teams manage change and share their code effectively

• Implementing incremental builds and integration with Team Foundation Build

• Making the most of VSTS tools for Test-Driven Development and refactoring

• Bringing agility into software modeling and using patterns to model solutions more effectively

• Using the FIT integrated testing framework to make sure customers are getting what they need

• Estimating, prioritizing, and planning Agile projects

Preface
Acknowledgments
About the Authors

Introduction: Broken Process
Section 1: Apply Sharp Tools and Values
Chapter 1: Introduction to Visual Studio Team System
Chapter 2: Agile Values
Review of Section 1: Sharp Tools and Values

Section 2: Introduce Agile Development
Chapter 3: Overview of Agile Development
Chapter 4: Forming an Agile Team
Chapter 5: Team Foundation Process Frameworks
Chapter 6: Improving Your Process Framework 
Review of Section 2: Introduce Agile Development

Section 3: Use Version Control
Chapter 7: Managing Change
Chapter 8: Setting Up TFS Version Control
Chapter 9: Using TFVC in Your Project
Chapter 10: Policing Your Project with TFVC
Review of Section 3: Use Version Control

Section 4: Build and Integrate Often
Chapter 11: Building and Integrating Software
Chapter 12: Working with Team Foundation Build
Review of Section 4: Build and Integrate Often

Section 5: Practice Test-Driven Development 
Chapter 13: Introduction to TDD
Chapter 14: Developing Your First Tests
Chapter 15: Learning to Refactor
Chapter 16: Code Coverage and Performance
Chapter 17: Integrating TFP Code with a User Interface
Review of Section 5: Practice Test-Driven Development

Section 6: Explore by Modeling
Chapter 18: Modeling with Agility
Chapter 19: Creating Models
Chapter 20: Using Models in an Agile Project
Chapter 21: Modeling Solutions with Patterns
Review of Section 6: Explore by Modeling

Section 7: Implement Customer Testing
Chapter 22: Involving Customers in Testing
Chapter 23: Creating FIT Fixtures
Chapter 24: Running FIT with Team Foundation Build
Review of Section 7: Implement Customer Testing

Section 8: Estimate, Prioritize, and Plan
Chapter 25: Estimating and Prioritizing Stories
Chapter 26: Agile Planning
Chapter 27: Managing Agile Projects
Review of Section 8: Estimate, Prioritize, and Plan

Section 9: Practice for Deployment
Chapter 28: Moving into Production
Chapter 29: Developing Installation Programs
Chapter 30: Deployment of Distributed Systems
Review of Section 9: Practice for Deployment

Section 10: Provide and Reveal Value
 Chapter 31: Producing Technical Reports
Chapter 32: Generating Business Value
Review of Section 10: Provide and Reveal Value
Retrospective: Fixing the Process

Appendixes
Appendix A: Setting Up VSTS for the Exercises
Appendix B: Software Project Environment for a Small Team
Appendix C: Agile Workspace 753 List of Exercises
List of Extreme Programming Practices
Glossary 
Bibliography
Resources 
Index 

This book is for working software developers, architects, testers, and managers in real teams–professionals who are either transitioning to VSTS or considering doing so. It will help you start deriving value from VSTS immediately, as you lay a solid foundation for ongoing process improvement.

Editorial Reviews

About the Author

Will Stott is an associate of Exoftware, a consulting group specializing in Agile practices, and a freelance consultant based in Montreux, Switzerland. Will has worked with Microsoft technologies since the early days of MS-DOS and now specializes in C++ and C# development using Visual Studio. He has published a number of articles about Agile development and has spoken at various conferences in the United Kingdom and Europe.

James Newkirk is the product unit manager for CodePlex, Microsoft's community open source project hosting site. He is the coauthor of Test-Driven Development in Microsoft .NET (Microsoft Press, 2004). Prior to joining Microsoft he coauthored "Enterprise Solution Patterns in .NET" (Microsoft patterns & practices) and Extreme Programming in Practice (Addison-Wesley, 2001).

Excerpt. © Reprinted by permission. All rights reserved.

Science is founded on the principle of creating experiments that give the same results each time they are performed. Unfortunately, a software development project isn't like a scientific experiment because the outcome is always different. Even teams that use the same tools and process will still produce different solutions to the same task, each unique in terms of code set, bugs, performance, and so forth. This variability arises because the results of software development depend upon individuals and their interactions as much as the process and tools they employ.

The idea that the outcome of a software project is largely dependent upon people and the way they work together caused Kent Beck to observe the habits of successful teams and then put them into a framework of values and practices, which he called Extreme Programming (XP). This provided an alternative to the decades-old notion that the only way to impose order upon software development was to apply expensive tools and a well-prescribed process. XP joined a number of similar lightweight approaches to software development, collectively known as Agile, which shared the common aim of satisfying customers through the early and continuous delivery of valuable software. Over the past five years, this Agile movement has grown to become a significant driver of change in our industry.

Agile seems to have successfully captured the middle ground of software development methodologies. Teams with too little process to guide them have found that embracing Agile allows them to make significant improvements in the outcome of their projects, without creating the sort of bloated bureaucracy they fear. Teams with too much process have found that adopting an Agile approach has made them much more productive and responsive, but without their projects descending into the sort of chaotic hacking they fear. Thousands of projects have been run along Agile lines. They haven't all succeeded, but this is to be expected because any worthwhile software project involves a degree of risk. However, plenty of these projects have produced spectacular results, and once people have tried Agile, they seldom want to return to their old ways of doing things. We suspect this is simply because most people find it, as we do, to be a more pleasurable and rewarding way to develop software.

Note: This book is primarily based on the values and practices of Extreme Programming as described in Kent Beck's book, Extreme Programming Explained. We apply them in the context of a five-developer team using Microsoft's Visual Studio 2005 Team System.

Who Should Read This Book?

This is a book for people on real teams who are transitioning to Microsoft's Visual Studio Team System (VSTS), but who might not yet be ready to fully embrace a process such as MSF for Agile Software Development. It is written for people who want an easy way to gain value from the tools and at the same time lay the foundations for future process improvement. We envision our readers to include the following:

• People new to software development—Teaches you how to use VSTS and gives you the core skills you need in order to work effectively on an Agile team. There are few assumptions about your technical background, but some knowledge of using Visual Studio will help when completing the exercises.

• Experienced developers—Puts what you already know into the context of an Agile project and explains how to make good use of the new tools provided by VSTS. People who are encountering Microsoft technology for the first time should find the exercises and glossary particularly useful.

• Architects—Explains the new VSTS tools for software architects, but its real value lies in helping you to adapt your skills so that you can add value to an Agile team.

• Testers—Helps you understand the expanded role of testers on an Agile team and explains how to use the basic VSTS tools needed to test software in this new Software Project Environment.

• Business analysts and customers—Explains how an Agile approach can give your business a better return on investment. You'll also learn how an Agile team works to make sure you get the software you want, when you need it.

• Project managers—Describes how to transition your people onto a small Agile team so that they can deliver better-quality software, in less time and for less cost. In addition, you'll discover how VSTS gathers information about a project into one place to make the running of the project more transparent.

• Software entrepreneurs—Provides you with a road map for setting up a small, top-performing software team. It reveals the key technical and people issues you need to address through a series of anecdotes and comments gleaned from the decades we've spent working in the industry.

This book is not about process improvement applied from the top of an organization downward, it's about empowering teams to change things for themselves from the bottom up.

Tools Needed

In order to follow the exercises in this book, you will need access to an existing installation of VSTS or have the ability to install Visual Studio Team Suite in one of the following environments:

• Desktop PC able to host the Microsoft Virtual PC

• Single-server PC running Windows Server 2003 (SP2 or R2)

• Network comprising a server and several desktop PCs

You will be glad to hear that Visual Studio Team Suite is freely available from Microsoft's technical Web site as a trial edition (full functionality, but expires after 180 days) as well as for purchase from your usual Microsoft reseller. In addition, MSDN subscribers can obtain Team System VPC, which is a "ready to run" virtual machine image of VSTS for use with the freely available Microsoft Virtual PC. Appendix A covers how to set up VSTS in all of these environments.

Note: Framework for Integrated Test (FIT) is required for Section 7, but it is freely available from the C2 Web site. InstallShield and Installation Collaboration are needed for the exercises in Chapter 29, but free evaluation editions are available on the Macrovison Web site.

Structure of the Book

The book's Introduction contains a story about a fictional software team called OSPACS that has a broken process; the team always delivers late, has high staff turnover, and is surprised to discover that its software is full of bugs and has gone three times over budget. The rest of the book is about how the team fixed these problems, but along the way we aim to give you insight into the use of VSTS and the meaning of better software development for a small Agile team. The main body of the book is divided into ten sections, each concerned with a specific aspect of software development as practiced by Agile teams. These sections are ordered into a sequence that helps build up a team's proficiency in a step-by-step manner. For example, we don't present information about project planning until we've covered material such as testing and Team Build because clearly your team's plans will not be very reliable until you can dependably deliver quality software. However, with that said, each section is largely self-contained, so you can read them in any order that makes sense to you. Indeed, we expect this to happen as each reader will have different priorities for things they want to learn about.

Each section starts with a short story and ends with a review describing how the OSPACS team put the ideas into practice, the team's impressions about the material, and its relationship to a set of Agile values. In this way, we provide you with some light relief from the technical stuff while presenting another perspective on the subject matter that might help you apply it on your own team. Within each section, the chapters usually start by explaining some basic concepts and then put them in a practical context by giving you a series of exercises to follow using the tools provided by VSTS. You will also *nd sidebars in various chapters that summarize particular XP practices relevant to what is being discussed. In this way, theory and practice are put together into something that is hopefully reasonably entertaining and interesting to read.

Note: At the back of the book is information about relevant resources, a glossary, a bibliography, and a number of appendixes, as well as a list of the XP practices and a complete list of all the exercises.

About the Book's Web Site

We have created a Web site for this book that contains most of the code created for the exercises, information about any errors in the text found after publication, and other supplementary material which we feel might be useful to readers:

http://www.BetterSoftwareDevelopment.org

We strongly encourage people to visit this site for the latest information about both VSTS and Agile software development. We would be delighted to receive feedback from readers and will try to respond to you as promptly as our other work commitments allow.

Product Details

• Paperback: 864 pages
• Publisher: Addison-Wesley Professional; 1 edition (May 27, 2007)
• Language: English
• ISBN-10: 0321418506
• ISBN-13: 978-0321418500
• Product Dimensions: 7 x 1.6 x 9.2 inches
• Shipping Weight: 2.6 pounds (View shipping rates and policies)
• Average Customer Review: 4.7 out of 5 stars  See all reviews (3 customer reviews)
• Amazon Best Sellers Rank: #1,535,473 in Books (See Top 100 in Books)

More About the Author

Discover books, learn about writers, read author blogs, and more.

Most Helpful Customer Reviews

6 of 6 people found the following review helpful

4.0 out of 5 stars Solid work on doing Agile in the VSTS/TFS world November 13, 2007

By James Holmes

Format:Paperback

This book covers a wide range of cool things in VSTS wrapped up in a solid introduction to and roadmap through agile practices. Read the book and you'll get great guidance to working with agile planning, test driven development, refactoring, agile modeling, and a number of other topics.

I have two small gripes with the book. First is that it includes the seemingly mandatory, maddening "meet the development team and walk through each day in the project with them" storyline. This book does no better than any of the other weak attempts at the novelization of a working team. Leave that stuff off for novellas and focus on the technical aspects instead. My second gripe is the book's organization. Planning is way back in section 8, modelling's in 6, etc. It seems a bit disjointed.

Those gripes aside, the content in the book is just great. The walk-through of test driven development is solid, and the emphasis on having an environment and code base that can rapidly change to requirements is very nice.

The technical side relating to Team Systems is also solid. The guidance on using source control is well-written, and the section on working with team build is as good as it can be (I'm NOT a fan of team build). The section on using and working with the process frameworks are solid, although I wished they'd covered the process editor add on.

I'm also very happy to see that the Framework for Integrated Testing (FIT) was included -- I've been a long-time proponent of FIT and love seeing it in more books.

Overall this is a very solid book. I like their approach to discussing agile, and I like their tie-ins to VSTS/TFS. They gloss over some of the things I don't like about VSTS/TFS, but hey, those are more my issues, not theirs.

This book is a good addition to your bookshelf if you're looking to do agile in the VSTS/TFS world.

0 of 1 people found the following review helpful

5.0 out of 5 stars Great book on Agile and VSTS November 14, 2008

By Ivan Fioravanti

Format:Paperback

I liked the book very much, it dives deeply in Agile principles and the best way to use VSTS to apply them.
I was really please by the scetion dedicated to FIT.

0 of 9 people found the following review helpful

5.0 out of 5 stars Practical and useful September 25, 2007

By Fabio M. C. Castro

Format:Paperback|Amazon Verified Purchase

From the first chapter, you want to be with the book in a hand and VSTS in the another making all of the taught examples.