Course info

Rating

(358)

Level

Beginner

Updated

May 2, 2011

Duration

3h 49m

Description

This course teaches you how to use the Team Foundation Server 2010 version control services. It also covers team development practices for version control. Along the way, you will learn some tricks that will make your time spent using Team Foundation Server as productive as possible. While this course specifically covers TFS 2010, much of it is also applicable to previous releases.

About the author

Robert spent nearly 10 years at Microsoft creating software that made it easier for everyone else to write software. Most recently Robert worked on Team Foundation Server on the Administration and Version Control teams. Currently Robert can be found working in the utilities sector on Smart Grid technologies.

Section Introduction Transcripts

Getting StartedHello, this is Robert Horvick with Pluralsight, and welcome to the Team Foundation Server Version Control course. In this course you will learn how to use the Team Foundation Server version control services, we'll dig into some team development practices, and along the way we'll learn some tricks that will hopefully make your time spent using TFS as productive as possible. While this course specifically discusses Team Foundation Server 2010, much of it will be applicable to previous releases as well. So let's get started. This first module will lay out basic information about Team Foundation Server and will introduce some version control concepts that will be helpful as more advanced materials are covered. We'll start by looking at Team Foundation Server's 3-tier architecture. Next we'll look at the project collection and team project architecture. After that, we'll take a look at the version control models that are common and specifically which one Team Foundation Server uses. We'll look at the various client options you have when connecting to TFS, and finally we'll look at the Team Foundation Server workspace.

Fundamental OperationsHello, my name is Robert Horvick, and welcome to the second module of the Team Foundation Server Version Control course. In this module we'll cover the fundamental version control operations that you need to know to get started using Team Foundation Server right away. We'll begin by connecting to Team Foundation Server. In doing this we'll define not only which server we're connecting to, but also which team project collection we'll be connecting to. We'll be browsing through Team Foundation Server using the Team Explorer and Source Control Explorer. We'll be creating a workspace, and in doing so we'll discuss how active and cloak mappings can be used to create the workspace that's ideal for your development. We'll be getting source code from the version control server into our workspace, and we'll do some basic operations, such as adding a new file, editing a file, we'll view the changes we've made, and then we'll check those changes in. Alright so let's get started.

Fundamental Operations 2Hi this is Robert Horvick with Pluralsight and welcome to the Team Foundation Server Version Control Fundamental Operations 2 module. In this module we're going to dive a little deeper into Team Foundation Server Version Control by looking at a fairly broad set of commands. We'll start by learning how to review an items change history. Next, we'll look at how files and directories can be renamed or moved within Team Foundation Server. We'll spend some time talking about how items can be deleted and how a deleted item can be undeleted. We'll look at how we can undo pending changes in our Workspace. And after that, we'll look at one of my favorite features of Team Foundation Server, shelving pending changes. It's a very powerful behavior that I use frequently. After we've learned how to shelve items in version control, we'll learn how to unshelve them back into our Workspace. Finally, we'll revisit the Get operation and look at how we can use finer grain controls to download specific versions of content from the server to our local Workspace. It's a lot of ground to cover, so let's get started.

Using the Command LineHi, this is Robert Horvick with Pluralsight, and welcome to the Team Foundation Server Version Control module Using the Command Line. In this module, we're going to take everything we've learned so far and see how we can perform those tasks using the command line interface provided by Team Foundation Server. Developers tend to have fairly polarized opinions on command line interfaces. Some can't live with them and some can't live without them. Personally, I'm a big fan of command line interfaces. What I hope to convey during this module is that the Team Foundation Server command line interface provides a powerful way to interact with Team Foundation Server outside of Visual Studio, and that there's something here for every developer regardless of their opinion on using command line interfaces in general. During this module we're going to look at some high level concepts, and then dive deeper with some demos that show off how the command line can be used. We'll start with an overview of the command line interface. We'll see how to start a VS Command Shell and get a high level overview of the command line tool. After that we'll decompose the command line interface into three buckets, commands that help manage workspaces, commands that query information from the server, and commands that are used to perform modifications to source code. Throughout this module we'll be spending a majority of our time on the command line learning by example. So let's dive in with an overview of the Visual Studio Command Shell.

Team Development Practices 1Hello. This is Robert Horvick with Pluralsight. And welcome to the Team Development Practices module #1. This is the first of two modules that will focus on issues commonly seen when using TFS version control on a team with multiple developers. In this module, we'll look at three areas of TFS version control that will likely become a part of your day to day development workflow. First, we'll look at how conflicts can arise and what we can do about them. Next, we'll look at the annotate feature and we'll see how it can be used to learn how a file has changed over time. Finally, we'll look at how code reviews can be performed using shelvesets and we'll see a few different ways to streamline that workflow.

Team Development Practices 2Hello. I'm Robert Horvick with Pluralsight, and welcome to the Team Foundation Server Version Control Team Development Practices 2 module. This is part 2 of the Team Development module, and builds upon information from part 1. In this module, I'll be discussing some more team development tools that Team Foundation Server provides that can improve your development workflow. The first is change notifications. Change notifications provide a mechanism for you to subscribe to emails that are sent whenever a change occurs in its specific team project. We will look at how to set up TFS to provide email notifications, and how to subscribe to the checkin notifications. Next, we'll look at checkin policies, specifically we'll be looking at the scenario of requiring a comment on every checkin. Finally, we'll look at how checkin notes can be used to provide additional information about changesets, and specifically how to require that a code reviewer be indicated on every checkin.

Branch and MergeHello. This is Robert Horvick with Pluralsight, and this is the Team Foundation Server 2010 Version Control Branching and Merging module. In this module we'll be looking at the topics of branching and merging within Team Foundation Server. To start on a common ground, we'll begin with a conceptual overview of branching and merging. Next, we'll look in more detail at several ways to create a branch in Team Foundation Server, we'll dive deeper into the merge operations and see how it can be used to move changes between branches, and along the way we'll see some of the visualizations that Team Foundation Server provides. These allow you to view your branch history and follow changes as they're merged between branches. So let's get started by taking a very high level look into branching and merging.