Professional Application Lifecycle Management with Visual Studio 2012 E-Book

Mickey Gousset

• Herausgeber: John Wiley & Sons
• Kategorie: Wissenschaft und neue Technologien
• Sprache: Englisch

Seitenzahl: 872

Veröffentlichungsjahr: 2012

Beschreibung

The authoritative and timely guide to ALM from Microsoft insiders and MVPs Focused on the latest release of Visual Studio, this edition shows you how to use the Application Lifecycle Management (ALM) capabilities of Visual Studio 2012 to streamline software design, development, and testing. Divided into six main parts, this timely and authoritative title covers Team Foundation Server, stakeholder engagement, project management, architecture, software development, and testing. Whether serving as a step-by-step guide or a reference for designing software solutions, this book offers a nuts-and-bolts approach to using Microsoft's flagship development tools to solve real-world challenges throughout the application lifecycle. Coverage includes: * INTRODUCTION TO APPLICATION LIFECYCLE MANAGEMENT WITH VISUAL STUDIO * INTRODUCTION TO TEAM FOUNDATION SERVER * TEAM FOUNDATION VERSION CONTROL * TEAM FOUNDATION BUILD * COMMON TEAM FOUNDATION SERVER * INTRODUCTION TO BUILDING * STORYBOARDING * CAPTURING STAKEHOLDER FEEDBACK * AGILE PLANNING AND TRACKING * INTRODUCTION TO SOFTWARE ARCHITECTURE * TOP-DOWN DESIGN WITH USE CASE * ANALYZING APPLICATIONS USING * USING LAYER DIAGRAMS TO MODEL * INTRODUCTION TO SOFTWARE DEVELOPMENT * UNIT TESTING * CODE ANALYSIS, CODE METRICS * PROFILING AND PERFORMANCE * DEBUGGING WITH INTELLITRACE * INTRODUCTION TO SOFTWARE TESTING * MANUAL TESTING * CODED USER INTERFACE TESTING * WEB PERFORMANCE AND LOAD TESTING * LAB MANAGEMENT Professional Application Lifecycle Management with Visual Studio 2012 offers a thoroughly revised and updated edition of the leading reference book on ALM.

Leseprobe

Table of Contents

Chapter 1: Introduction to Application Lifecycle Management with Visual Studio 2012

Application Lifecycle Management

Visual Studio 2012 Product Lineup

Application Lifecycle Management Challenges

Enter Visual Studio 2012

Application Lifecycle Management in Action

Summary

Part 1: Team Foundation Server

Chapter 2: Introduction to Team Foundation Server

What Is Team Foundation Server?

Acquiring Team Foundation Server

Team Foundation Server Core Concepts

Accessing Team Foundation Server

What's New in Team Foundation Server 2012

Adopting Team Foundation Server

Summary

Chapter 3: Team Foundation Version Control

Team Foundation Version Control and Visual SourceSafe (VSS) 2005

Setting Up Version Control

Using the Source Control Explorer

Check-In Pending Changes

Shelving

Command-Line Tools

Summary

Chapter 4: Branching and Merging

Branching Demystified

Common Branching Strategies

Implementing Branching Strategies

Summary

Chapter 5: Team Foundation Build

Team Foundation Build

What's New in Team Foundation Build 2012

Team Foundation Build Architecture

Working with Builds

Team Build Process

Summary

Chapter 6: Common Team Foundation Server Customizations

Object Models

Customizing Team Foundation Build

Customizing Team Foundation Version Control

Team Foundation Server Event Service

Customizing Work Item Tracking

Summary

Part 2: Building the Right Software

Chapter 7: Introduction to Building the Right Software

Stakeholders

Storyboarding

Capturing Stakeholder Feedback

Work Item Only View

Third-Party Requirements Management Solutions

Summary

Chapter 8: Storyboarding

Why Storyboarding?

PowerPoint Storyboarding

Summary

Chapter 9: Capturing Stakeholder Feedback

Requesting Feedback

Summary

Part 3: Project Management

Chapter 10: Introduction to Project Management

Project Management Enhancements in Team Foundation Server 2012

Work Items

Process Templates

Managing Work Items

Project Server Integration

Summary

Chapter 11: Agile Planning and Tracking

Defining a Team

Maintaining Product Backlogs

Planning Iterations

Tracking Work

Customization Options

Summary

Chapter 12: Using Reports, Portals, and Dashboards

Team Foundation Server Reporting

Working with Team Foundation Server Reports

Summary

Part 4: Architecture

Chapter 13: Introduction to Software Architecture

Designing Visually

Microsoft's Modeling Strategy

The Architecture Tools in Visual Studio Ultimate 2012

What's New with Architecture Tools in Visual Studio Ultimate 2012

Summary

Chapter 14: Top-Down Design with Use Case, Activity, Sequence, Component, and Class Diagrams

Wrox.com Code Download for this Chapter

Use Case Diagrams

Activity Diagrams

Sequence Diagrams

Component Diagrams

Class Diagrams

Summary

Chapter 15: Analyzing Applications Using Architecture Explorer and Dependency Graphs

Wrox.com Code Downloads for this Chapter

Understanding the Code Base

Architecture Explorer Basics

Dependency Graphs

Summary

Chapter 16: Using Layer Diagrams to Model and Enforce Application Architecture

Creating a Layer Diagram

Defining Layers on a Layer Diagram

Defining Dependencies

Validating the Layer Diagram

Layer Diagrams and the Build Process

Summary

Part 5: Software Development

Chapter 17: Introduction to Software Development

What's New for Developers in Visual Studio 2012

My Work

Summary

Chapter 18: Unit Testing

Wrox.com Code Downloads for this Chapter

Unit Testing Concepts

Visual Studio Unit Testing

Programming with the Unit Test Framework

Introduction to Microsoft Fakes

Test Adapters

Summary

Chapter 19: Code Analysis, Code Metrics, and Code Clone Analysis

Wrox.com Code Downloads for this Chapter

The Need for Analysis Tools

Using Code Analysis

Using the Command-Line Analysis Tool

Creating Code Analysis Rules

Code Metrics

Code Clone Analysis

Summary

Chapter 20: Profiling and Performance

Wrox.com Code Downloads for this Chapter

Introduction to Performance Analysis

Using the Profiler

Command-Line Profiling Utilities

Common Profiling Issues

Summary

Chapter 21: Debugging with IntelliTrace

wrox.com Code Downloads for this Chapter

IntelliTrace Basics

IntelliTrace in Production

Summary

Part 6: Testing

Chapter 22: Introduction to Software Testing

Role-Based Testing Tools

Types of Tests

Diagnostic Data Adapters

Microsoft Test Manager

Managing Automated Tests with Visual Studio

Summary

Chapter 23: Manual Testing

Microsoft Test Manager

Using Test Plans

Running Tests and Tracking Results

Exploratory Testing

Running Automated Tests

Summary

Chapter 24: Coded User Interface Testing

Wrox.com Code Downloads for this Chapter

Creating Coded UI Tests Using the Coded UI Test Builder

Creating Coded UI Tests Using Action Recordings

Supported Technologies

Summary

Chapter 25: Web Performance and Load Testing

Wrox.com Code Downloads for this Chapter

Web Performance Tests

Load Tests

Distributed Load Tests

Summary

Chapter 26: Lab Management

Lab Management Infrastructure

SCVMM Environments

Testing with Environments

Automated Build-Deploy-Test with Environments

Standard Environments

Summary

Title Page

Copyright

Dedication

Credits

About the Authors

Acknowledgments

Introduction

Advertisements

Chapter 1

Introduction to Application Lifecycle Management with Visual Studio 2012

What's In This Chapter?

Defining application lifecycle management

Learning about the Visual Studio 2012 product family

Understanding the structure of this book

In June of 1999, Microsoft started to re-evaluate how Visual Studio was being used as part of the software development process. Microsoft was continuing to serve the needs of an individual programmer through the highly productive “code-focused rapid-application-development” features of Visual Studio, but wasn't doing much to help programmers work together as a team. And what about software architects——how should they be working with the programming team? And testers? Project managers?

Many teams had begun to set up their own solutions using a mixture of third-party, in-house, and vendor-provided tools to address such challenges as version control, bug tracking, and team communications. But this mishmash of tools can be tricky to set up and maintain, and even more difficult to integrate. Microsoft sought to address this challenge by providing an integrated set of tools designed to address the needs of the entire software development team. Thus, Visual Studio Team System was born, and was first released with the Visual Studio 2005 product line.

At the heart of Team System, Team Foundation Server was created to provide a hub for all members of the development team to collaborate. Team Foundation Server is uniquely positioned from its predecessors across the industry by being the first tool of its kind built from the ground up to provide an integrated solution for many capabilities which had historically been offered as standalone tools. Team Foundation Server provides a unified solution for storing source code (along with a history of changes), work item tracking (which can include bugs, requirements, and so on), and automated builds. By providing a single solution with all of these capabilities, Microsoft delivered the ability to link all these artifacts for end-to-end traceability, reporting, process enforcement, and project management.

Team System also included “client” functionality, which surfaced in the various editions of Visual Studio development tools. Visual Studio seamlessly integrated with Team Foundation Server, but much of this tooling could also be used independently or with third-party source control solutions. Visual Studio Team System also introduced role-specific tooling that lived outside of the core Visual Studio development environment by recognizing that team members such as project managers are oftentimes more comfortable using tools such as Excel or Project, both of which could be used to manage and track work that lived in Team Foundation Server.

Team System was built from a foundation of tools and technologies that Microsoft had been using internally for many years to build some of the most complex software projects ever undertaken. Team System appealed not only to programmers, but to all members of the development team—architects, application developers, database developers, and project managers.

Three years later, Visual Studio 2008 Team System evolved from the previous version to include even more tools and functionality for all members of the project team to use. Two years after that, Visual Studio 2010 added even more functionality, including an entirely new set of tools for generalist testers (also referred to as manual testers), bringing a new audience of prospective users into the same set of tooling used by the rest of the team.

Application Lifecycle Management

Along with the release of Visual Studio 2010, Microsoft also stopped using the sub-brand “Team System” to describe these capabilities. Instead, Microsoft started referring to these tools as the application lifecycle management capabilities of Visual Studio. Application lifecycle management is a term that has gained momentum in the development industry to describe the way an application is managed from its conception, through its creation and deployment, to its eventual retirement.

It is important to note that application lifecycle management is a more comprehensive concept than its more popular predecessor, software development lifecycle (SDLC). SDLC is primarily focused on the core coding activities that comprise the creation of an application's life, beginning with a requirement for an application and ending when that application is built and delivered. Application lifecycle management recognizes that requirements aren't simply born out of thin air. They evolve based on business needs, or ideas for new opportunities, and stakeholders who are considered external to the development team may still play a role during the development of an application in helping to refine requirements and provide feedback on implementations. Application lifecycle management also recognizes that a development team's job isn't done the moment they hand off a “finished” application. The development team will likely be called upon to help troubleshoot the application when things go wrong in the production environment, or to create subsequent versions of the application based on feedback from users or analytics from the operations team. Visual Studio itself has matured over time to grow from being a tool targeted squarely at programmers during the software development lifecycle to becoming a true solution for end-to-end application lifecycle management.

Visual Studio 2012 Product Lineup

Table 1.1 outlines the product lineup for Visual Studio 2012.

Table 1.1 Visual Studio 2012 Product Lineup

Product Name

Description

Microsoft Visual Studio Ultimate 2012 with MSDN

The comprehensive suite of application lifecycle management tools for software teams to help ensure quality results from design to deployment.

Microsoft Visual Studio Premium 2012 with MSDN

A complete toolset to help developers deliver scalable, high-quality applications.

Microsoft Visual Studio Professional 2012 with MSDN

The essential tool for basic development tasks to assist developers in implementing their ideas easily.

Microsoft Visual Studio Test Professional 2012 with MSDN

The primary tool for manual and generalist testers who need to define and manage test cases, execute test runs, and file bugs.

Microsoft Visual Studio Team Foundation Server 2012

The server component for team development, version control, work item tracking, build automation, project management, lab management, and reporting.

Microsoft Visual Studio Team Foundation Server Express 2012

A free edition of Team Foundation Server that provides most of the same capabilities (including version control, work item tracking, and build automation) for a team of up to five users.

Visual Studio Premium contains all the functionality of Visual Studio Professional, and Visual Studio Ultimate contains all the functionality of Visual Studio Premium. Visual Studio Premium and Ultimate also include all of the functionality available in Visual Studio Test Professional.

There are a few additional standalone tools and technologies that comprise the Visual Studio 2012 family that are not listed. For example, in Chapter 9 you learn about the new Microsoft Feedback Client, which stakeholders use to provide rich feedback about an application that is stored in Team Foundation Server. In Chapter 2, you learn about Team Explorer Everywhere, which Eclipse developers use to work with Team Foundation Server. You learn about these additional tools throughout this book, but Table 1.1 showcases the primary products that Microsoft markets as part of the Visual Studio 2012 product family.

For a detailed breakdown of the functionality available in each product, a comparison chart is available at www.microsoft.com/VisualStudio.

Note

Software licensing is potentially a complex topic. It is important to ensure that the members of your team are adequately licensed to use Visual Studio and the related technologies that make up your development and testing environments. The Visual Studio Licensing Whitepaper attempts to synthesize all of the licensing requirements for Visual Studio, Team Foundation Server, and related technologies into an easy-to-read format. You can find the latest version of the Visual Studio Licensing Whitepaper at http://www.microsoft.com/visualstudio/licensing.

Application Lifecycle Management Challenges

Software developers share common challenges, regardless of the size of their teams. Businesses require a high degree of accountability—software must be developed in the least amount of time, and there is no room for failure.

Some of these challenges include the following:

Tool integration problems

—Most tools commonly used by software development teams come from third-party vendors. Integrating with those tools can pose a major challenge—in many cases, it requires duplicating or copying data into multiple systems. Each application has a learning curve, and transmitting information from one application to another (incompatible) application can be frustrating and time consuming.

Geographically distributed teams

—Many development and management tools don't scale for geographically distributed teams. Getting accurate reporting can be difficult, and there is often poor support for communication and collaborative tools. As a result, requirements and specifications might be captured incorrectly, causing delays and introducing errors. Global teams require solid design, process, and software configuration management to be integrated into one package. There aren't many software packages that can deliver all these features, and those that do exist tend to be incredibly expensive.

Segmentation of roles

—Specialization can be a huge problem on a team. Experts can assume that other departments are aware of information that doesn't end up in the status reports but that may greatly affect the project as a whole. Interdepartmental communication is a huge and prevalent challenge. These barriers exist between developers and testers, developers and stakeholders, developers and operations, and even developers and others developers.

Bad reporting

—This is an offshoot of the segmentation problem. In most cases, reports must be generated manually by each team, which results in a lack of productivity. There aren't any effective tools that can aggregate all the data from multiple sources. As a result, the project lead lacks the essential data to make effective decisions.

Lack of process guidance

—Ad hoc programming styles simply don't scale. If you introduce an off-cycle change to the code, it can cascade into a serious problem requiring hours and days of work. Today's software has a high level of dependencies. Unfortunately, most tools don't incorporate or enforce process guidance. This can result in an impedance mismatch between tools and process.

Testing as a second

-

class citizen

—Shorter cycles and lack of testing can introduce code defects late in the process. Additionally, poor collaboration between developers and testers often results in wasted back-and-forth effort and software defects.

Communication problems

—Most companies use a variety of communication methods (such as e-mail, instant messaging, memos, and sticky notes) to send information to team members. You can easily lose a piece of paper, or delete an important e-mail message, if you are not careful. There aren't many centralized systems for managing team communications. Frequent and time-consuming status meetings are required to keep the team on track, and many manual processes are introduced (such as sending e-mail, as well as cutting and pasting reports).

Companies introduce methodologies and practices to simplify and organize the software design process, but these methodologies must be balanced. The goal is to make the process predictable because, in a predictable environment, methodologies keep projects on track. It is often said that predictability reduces complexity. Conversely, methodologies add tasks to the process (such as generating reports). If your developers spend too much time doing these tasks, they'll be less productive, and your company won't be able to react competitively.

Enter Visual Studio 2012

There are three founding principles behind the application lifecycle management capabilities of Visual Studio 2012: productivity, integration, and extensibility.

Productivity is increased in the following ways:

Collaboration

—Team Foundation Server centralizes all team collaboration. Bugs, requirements, tasks, test cases, feedback, code reviews, source code, and builds are all managed via Team Foundation Server 2012. All reporting is also centralized, which makes it easy for project leads to track the overall progress of the project, regardless of where the metrics are coming from.

Manage complexity

—Software development projects are more complex than ever, and getting more complex year by year. Team Foundation Server helps to manage this complexity by centrally tracking your entire software development process, ensuring that the entire team can see the state and workflow of the project at any given time.

Integration is improved in the following ways:

Integrated tools

—These facilitate communication between departments. More importantly, they remove information gaps. With the Visual Studio 2012 family of products, integration isn't an afterthought—it's a core design consideration for the toolset.

Role

-

specific tools

—Instead of asking every member of an extended development team to conform to using the same tool, such as Visual Studio, Microsoft recognizes that many members of a team already have a preferred tool that they use every day. Correspondingly, Microsoft has integrated into those tools directly to provide comfortable interfaces back to Team Foundation Server—whether it's Visual Studio, Eclipse, Excel, Project, Project Server, or simply a web browser.

Visibility

—Visual Studio and Team Foundation Server increase the visibility of a project. Project leads can easily view metrics related to the project and can proactively address problems by identifying patterns and trends.

Extensibility is provided in the following ways:

Team Foundation Core Services API

—Most of the platform is exposed to the developer, providing many opportunities for extensibility and the creation of custom tools that integrate with Team Foundation Server.

IDE

—The Visual Studio integrated development environment (IDE) itself is extensible, allowing third parties and end users to add everything from additional tool capabilities to new language compilers to the development environment.

Application Lifecycle Management in Action

To best demonstrate how Visual Studio 2012 can help in the process of application lifecycle management, let's run through a typical scenario with a fictional software development company called eMockSoft. eMockSoft has recently signed a partnership with a distributor to release its catalog of products. The distributor has requested a secure website to manage inventory and pricing information for internal and external partner organizations.

Let's look at the scenario as it applies to application lifecycle management and the Visual Studio 2012 tools.

Requirements

The business analyst meets with the project sponsor and other stakeholders to obtain requirements for the project. During this discussion, the business analyst and an application designer use the new PowerPoint Storyboarding capabilities of Visual Studio 2012 to build a storyboard that visually models the application they believe their stakeholders are asking for. They share this storyboard with the stakeholders to review the proposed user interface, workflows, and transitions. The stakeholders provide valuable feedback that helps to refine the design, even before a single line of code is written.

The storyboard then becomes the basis of new requirements that inform the development team about what the project sponsor expects the software to deliver. The project manager uses the new web-based Agile planning tools to store these requirements in Team Foundation Server. She then works with the development team to decompose these requirements into tasks that the team will implement on an iterative basis. She also uses Microsoft Project to create a more detailed project schedule based on this work by importing work items.

The infrastructure architect can now begin the system design.

System Design and Modeling

Based on the client specifications, the infrastructure architect can use the UML tools in Visual Studio 2012 to define the architecture for the website. These designs help to inform the programming team about what to implement. As the architecture evolves, the infrastructure architect will use the dependency graph generation tools to analyze the application's architecture and propose architectural changes that can improve code maintainability and quality.

Code Generation

The developer receives work assignments and reviews the UML diagrams that were designed by the architect. The developer writes the necessary code, and does some preliminary testing, using the static code analysis and unit testing tools built into Visual Studio. Throughout the day, the developer checks the code and tests into Team Foundation Server 2012. As work is completed, the developer uses the new web-based task board provided with Team Foundation Server to track the progress of his work and keep the rest of the team updated about his status.

When necessary, the developer uses the built-in code review tooling to invite senior developers to view and comment on the code he is writing. This entire conversation is preserved within Team Foundation Server, making it possible to later conduct audits to discover why certain decisions were made about implementation choices.

Testing

The tester checks the progress of the development team by monitoring the nightly builds and automated tests. Using the lab management capabilities of Team Foundation Server 2012, each nightly build triggers the automatic creation of a virtual environment that is ready each morning for the tester to begin testing with. The tester uses Visual Studio Test Professional to author, manage, and execute a suite of manual test cases each day to surface potential bugs for the development team. The tester files bugs in Team Foundation Server that are assigned to development team to fix.

All bug reports are stored in Team Foundation Server, and provide team members and project sponsors with full visibility into the progress of the project. The bugs automatically contain a rich set of information for the developer, including a video of the test case being run by the tester, screenshots, an event log from the time the test was being run, and a pointer to a snapshot of the virtual environment where it was uncovered. The developer uses all this information to quickly diagnose and fix the bug.

Feedback

When the development team has finished an initial version of the website, they decide to ask the original stakeholders to review their progress to ensure that they are on the right track. The business analyst uses Team Foundation Server 2012 to request feedback from the appropriate stakeholders on the areas of the application that are ready for review. Each stakeholder receives an e-mail along with an invitation to provide feedback. The stakeholders use the new Microsoft Feedback Client to capture their feedback as they are using the new application. The Feedback Client enables each stakeholder to capture a video recording the application as they are using it, along with notes, screenshots, and audio annotations describing what they like and what they would like to see changed in the application. This feedback is rich and timely, helping the development team refine their implementation before the iteration is finished.

Operations

After the application has been built and signed off by the testing team, it's ready to be deployed in the on-premises datacenter. eMockSoft uses System Center 2012 to monitor the production servers, so the testing team is quickly alerted in the event that the application breaks or begins performing slowly. Using System Center Operations Manager, an operations engineer can choose to assign the issue to engineering, which automatically creates a bug in Team Foundation Server, including rich diagnostics from Operations Manager's application performance monitoring capabilities. If a developer needs even more information to diagnose an issue, he can ask the operations team to capture an IntelliTrace file from the running application, which he can use to review everything that happened during the application's execution and look for clues about how to resolve such an issue. By using these types of tools, the company can ensure better collaboration between the development and operations team than had been achieved in the past.

Putting It into Context

This is a simple example that examines just a few of the ways in which Visual Studio 2012 can assist with application lifecycle management. Throughout this book, you discover other examples that can help your team become a more cohesive unit and ship better software.

Summary

In this chapter you learned about the overall Visual Studio 2012 product family and how it has been designed to help you address the entire application lifecycle management of your development projects. The rest of this book will dive more deeply into how you can apply these tools to your own team.

Part 1

Team Foundation Server

Chapter 2

: Introduction to Team Foundation Server

Chapter 3

: Team Foundation Version Control

Chapter 4

: Branching and Merging

Chapter 5

: Team Foundation Build

Chapter 6

: Common Team Foundation Server Customizations

Chapter 2

Introduction to Team Foundation Server

What's In This Chapter?

What is Team Foundation Server

Core concepts central to Team Foundation Server

Getting access to Team Foundation Server and connecting to it for the first time

What's new in Team Foundation Server 2012

Planning your Team Foundation Server adoption

Because Team Foundation Server is so fundamental to the Application Lifecycle Management offering from Microsoft, later chapters go into more depth about utilizing different aspects of the product, such as how to use it to plan your work, how to use version control when developing software, and how to make use of the build automation capabilities. In each case, the use of Team Foundation Server is explained within the context of the task you are doing—but before we can do that you need to know what Team Foundation Server is, what it provides, and how to get it.

Although a full treatment of Team Foundation Server is therefore necessary in a book about Microsoft's Application Lifecycle Management solution, this book deliberately focuses on how to use Team Foundation Server to develop software and effectively organize your teams. Team Foundation Server is highly customizable and extensible by an administrator. The book Professional Team Foundation Server 2012 (Wrox, 2011) is targeted at administrators of Team Foundation Server and individuals who wish to customize their instance heavily, though Chapter 6 of this book will give you a taste of the customizations that are possible and provide a starting point to learn more.

What Is Team Foundation Server?

Developing software is difficult, a fact that is repeatedly proven by how many projects fail. Developing software is a creative endeavor, not a manufacturing process. Consequently, an essential factor in the success of any software development team is how well the members of the team communicate with each other and with the people who wanted the software developed in the first place.

Microsoft Visual Studio Team Foundation Server 2012 provides the core collaboration functionality for your software development teams in a very tightly integrated product. The functionality provided by Team Foundation Server includes the following:

Project management and planning

Work item tracking (WIT)

Version control

Test case management

Build automation

Reporting

Virtual lab management

Team Foundation Server is a server product separate from Visual Studio. Logically, Team Foundation Server is made up of the following two tiers, which can be physically deployed across one or many machines:

Application tier—

The

application tier

primarily consists of a set of web services with which the client machines communicate by using a highly optimized web service–based protocol.

Data tier—

The

data tier

is made up of a SQL Server database containing the database logic of the Team Foundation Server application, along with the data for your Team Foundation Server instance. The data stored in the database is used by Team Foundation Server's reporting functionality. All the data stored in Team Foundation Server is stored in this SQL Server database, thus making it easy to back up.

Team Foundation Server was designed with extensibility in mind. There are comprehensive APIs in .NET and Java for integrating with Team Foundation Server, and a set of events that enables outside tools to integrate with Team Foundation Server as first-class citizens. The same APIs and event system are used by Microsoft itself in the construction of Team Foundation Server, as well as the client integrations into Visual Studio, Microsoft Office, and Eclipse.

Team Foundation Server has competitors, including other enterprise Application Lifecycle Management suites and purpose-specific solutions (such as source control, a build server, or a work tracking system). As discussed in Chapter 1, the main benefit of having all these capabilities in one product is the tight integration that Microsoft has been able to achieve between the tools that you use to develop software and the tools that you use to communicate with your team and your stakeholders.