Preface

Why I Wrote This Book

I joined Microsoft in 2003 to work on Visual Studio Team System (VSTS), the new product line that was just released at the end of 2005. As the group product planner, I have played chief customer advocate, a role that I have loved. I have been in the IT industry for twenty-some years, spending most of my career as a tester, project manager, analyst, and developer.

As a tester, I’ve always understood the theoretical value of advanced developer practices, such as unit testing, code coverage, static analysis, and memory and performance profiling. At the same time, I never understood how anyone had the patience to learn the obscure tools that you needed to follow the right practices.

As a project manager, I was always troubled that the only decent data we could get was about bugs. Driving a project from bug data alone is like driving a car with your eyes closed and only turning the wheel when you hit something. You really want to see the right indicators that you are on course, not just feel the bumps when you stray off it. Here too, I always understood the value of metrics, such as code coverage and project velocity, but I never understood how anyone could realistically collect all that stuff.

As an analyst, I fell in love with modeling. I think visually, and I found graphical models compelling ways to document and communicate. But the models always got out of date as soon as it came time to implement anything. And the models just didn’t handle the key concerns of developers, testers, and operations.

And in all these cases, I was frustrated by how hard it was to connect the dots for the whole team. I loved the idea in Scrum (one of the agile processes) of a “single product backlog”—one place where you could see all the work—but the tools people could actually use would fragment the work every which way. What do these requirements have to do with those tasks, and the model elements here, and the tests over there? And where’s the source code in that mix?

From a historical perspective, I think IT turned the corner when it stopped trying to automate manual processes and instead asked the question, “With automation, how can we reengineer our core business processes?” That’s when IT started to deliver real business value.

They say the cobbler’s children go shoeless. That’s true for IT, too. While we’ve been busy automating other business processes, we’ve largely neglected our own. Virtually all tools targeted for IT professionals and teams seem to still be automating the old manual processes. Those processes required high overhead before automation, and with automation, they still have high overhead. How many times have you gone to a one-hour project meeting where the first ninety minutes were an argument about whose numbers were right?

Now, with Visual Studio Team System, we are seriously asking, “With automation, how can we reengineer our core IT processes? How can we remove the overhead from following good process? How can we make all these different roles individually more productive while integrating them as a high-performance team?”

Who Should Read This Book

This book is written for a software team that is considering running a software project using VSTS. This book is about the why, not the how.¹ What are the guiding ideas behind VSTS? Why are certain ideas presented in certain ways? For example, why are so many things called work items? What does the metrics warehouse measure? Why would you use those particular reports?

It has been my experience time and time again that knowledgeable, skillful, experienced people bring uneven starting assumptions to software projects. What appear to be self-evident truths to one person are folk myths to another, and one person’s common wisdom is another’s discovery. This issue is exacerbated by a natural emphasis on functional roles, which are often baked into career ladders. I certainly believe that there are expert developers, expert testers, expert architects, expert business analysts, and expert project managers, but delivering customer value requires collaboration across all disciplines. Attempts to optimize one special role in isolation from the others do not necessarily improve the delivery of results as the customer sees them.

One way of solving the discrepancies has been to have an onsite coach who can lead the team through a consistent set of processes. Coaches are great, but not everyone has the luxury of working with one. So, because I cannot ship you an on-demand coach, I’ve written this book.

This is not a step-by-step tutorial in the sense of a user manual that tells you where to click in what sequence. Plenty of good documentation on those topics is available with VSTS, and I reference it where appropriate. Rather, this book offers a framework for thinking about software projects in a way that can be directly tooled by VSTS. Indeed, we built VSTS to run software projects this way.

This book is also not a survey of software engineering literature. Dozens, perhaps hundreds, of books have been written about software engineering in the last forty years. I do not recap them here, and I do not cover all the material that they do. I expect the criticism from many experts that some of my arguments go without saying nowadays. Unfortunately, as Freud pointed out, what goes without saying is often not said at all. As a result, differences in team members’ assumptions are not exposed until the wrong argument happens. So if you want to fault me for stating too many obvious things, I’m guilty as charged.

I present enough Team System theory and practice examples to describe a realistic process for most mainstream IT projects and teams. It may not be formal enough for avionics software that requires FAA approval; it may not be loose enough for a three-person team co-located in a garage.

How to Read This Book

VSTS includes process guidance called Microsoft Solutions Framework (MSF), which includes the central concept of a team model based on a team of peers. The team model allows for different scales of specialization. MSF defines seven constituencies, or points of view, that must be represented on a successful project, and it includes recommendations for scaling up and down. I call out these points of view throughout the book with icons that look like this:

Figure P.1. Microsoft Solutions Framework introduces a model of a team of peers, anchored in seven viewpoints that need to be represented for a successful project. MSF for CMMI Process Improvement specializes the seven into eighteen, whereas MSF for Agile Software Development realizes the seven with six roles, clustering product management and user experience, and offers guidelines to reduce the list to three.

This book is written for the team as a whole. It presents information in a style that will help all team members get a sense of each other’s viewpoint. However, role-specific sections are called out so that you can focus on or skim over portions as needed for your specific roles. I’ve tried to keep the topics at a level that is engaging to all team members and not arcane for any. (For some, this choice may reinforce the criticism of simplicity.) In this age of specialization, I think it is important to have at least this level of contract with and expectations of your colleagues in other specialties. If you’re in a hurry, you can use the constituency icons as a guide to the role-related topics that interest you most.

Pointers to Documentation

As I said, this is not a how-to book. Where details of VSTS or its documentation are appropriate, you will see a pointer to it, like this example:

I made this choice because I assume that most of the time that you are reading this book, you are not sitting in front of a computer, and occasionally you will want to go back and try something hands-on. When you’re just reading, you can skip these pointers.

Other People’s Ideas

My goal in this book is to introduce the ideas behind VSTS, not to claim the ideas as original. VSTS was designed from the ground up to enable different processes to be applied to fit different organizations and projects. VSTS, and correspondingly this book, make liberal use of good practices that have been developed by the software community. Where possible, I’ve tried to capture relevant sources in endnotes. If you’re not interested in the references, you don’t need to read the endnotes.

Enough About VSTS to Get You Started

Reviewers of early drafts of this book complained that I did not explain clearly enough what is in VSTS, so I’m putting a product introduction in the following sidebar, straight from a Microsoft Web page. There are currently four VSTS client products, and there may be more in the future, but I do not distinguish them because the value is in the Team Suite. Of course, Microsoft lets you buy the functionality à la carte, but I’m going to keep things simple.

So when I write about “VSTS” or “Team System,” assume that I am writing about the Team Suite.

Part of VSTS is Microsoft Solutions Framework (MSF), shown as the “Process Guidance” box in Figure P.2. MSF comes in two forms out of the box and can be customized into countless variations. The two standard ones are

• MSF for Agile Software Development

• MSF for CMMI Process Improvement

I’ll describe these in a little more depth later, but basically, if your organization is new to software process, start with MSF for Agile Software Development. If you need more formality due to geographic distribution, process improvement programs, compliance audits, or the desire for CMMI appraisal, then you should consider MSF for CMMI Process Improvement.

Unless it’s necessary to distinguish these variants, I will I stick to concepts that are common to both.

Figure P.2. Visual Studio 2005 Team System is comprised of four client products and one server product.

Introducing Visual Studio 2005 Team System

Disclaimer

Finally, I need to be clear that the views in this book are my own and not necessarily those of Microsoft Corporation. Although I am a Microsoft employee, I am writing on my own behalf, and not for the company. Don’t blame Microsoft for the opinions I express and the errors I make here (unless you want to tell them they made a bad hire), but blame me instead. You can flame me on my blog directly at http://blogs.mircosoft.com/sam/.

Endnotes