Leveraging Visual Studio Team System Course

Course Code: IN 571
Course Abstract: This course provides participants with the knowledge and skills to effectively use Visual Studio 2005 Team System to manage their entire Software Development Life Cycle (SDLC) in a team-based environment. The course focuses on teaching project managers, software architects, software developers, and testers the various features and capabilities of Team System and Team Foundation Server. This course also dives deep into the areas of customization, version control, and Team Build, providing participants with the best practice knowledge and skills to effectively customize process templates, understand the advanced usage of the version control and check-in policies in a parallel development environment, and customize Team Build.
Audience: This course is intended for current software development professionals, including project managers, architects, developers, and testers who are involved in building Windows or Web-based .NET applications. Regardless of the participant’s role, he or she will be able to learn and get hands-on experience with all of the role-based features of Visual Studio 2005 Team System.
Duration: 5 days
Learning Outcomes: Upon completion of this course, the participant will be able to:
> Recognize Team System’s capabilities
> Identify Team System’s support for the Software Development Life Cycle
> Identify the architecture of Team Foundation Server
> Plan and create a team project
> Manage and secure a team project
> Choose an appropriate software development methodology
> Creating and querying work items
> Use the various distributed system designers to architect a connected .NET solution
> Validate solution deployment and generate a deployment report
> Leverage Visual Studio 2005’s new software development features
> Protect Visual Studio projects by placing them under Team Foundation Version Control
> Work with Version Control in a multi-user environment
> Improve the quality of .NET code through unit testing, code analysis, and profiling
> Test Web applications using automated tools
> Load test applications using automated tools
> Automate the software build process using Team Build
> Understand the architecture of a process template
> Customize a process template
> Create a new work item type
> Alter work item types for existing team projects
> Recognize parallel development
> Identify Team Foundation Server’s support for parallel development
> Setup and manage workspaces
> Detect and resolve conflicts in a parallel development environment
> Apply the correct branching pattern to for a given SCM environment
> Use branching and merging effectively
> Use shelving and unshelving effectively
> Secure version control assets
> Use alternate compare and merge tools
> Use Team Foundation Server Power Tools (f.k.a. Power Toys) effectively
> Use the MSSCCI provider from SQL Server Management Studio
> Create and use work item, code analysis, and unit testing check-in policies
> Create and deploy a custom check-in policy
> Manage check-in policy failure and overrides
> Configure check-in policy failure notifications
> Create and execute a Team Build manually
> Schedule a Team Build using Windows Scheduler
> Run code analysis as part of a Team Build
> Configuration Team Build notifications
> Implement Continuous Integration using Team Build
> Customize Team Build
> Create custom MSBuild tasks
> Configure Team Build to build and deploy a Web application
Course Topics:

Module 1: Introduction
This module introduces Visual Studio 2005 Team System from a business and technical point of view.
Lessons
> The challenges with building software
> What is Team System
> Architectural overview of Team System and Team Foundation Server
> Team System features by role
Lab
First look at Visual Studio 2005 Team System

Module 2: Project Management
This module introduces the Project Manager role and team projects. Participants will learn how to create and configure team projects using the Team Explorer and other client applications.
Lessons
> The Project manager role
> What are team projects
> Creating and configuring team projects
> Team Explorer and other client applications
Lab
Configuring and creating team projects

Module 3: Methodologies and Work Items
This module introduces participants to the methodology support in Team System. Participants will also learn about the improvements in Microsoft Solutions Framework version 4.0 and its two methodology templates that accompany Team System and the work items defined by each methodology.

Lessons
> What is a methodology
> Microsoft Solutions Framework 4.0
> Methodology support in Team System
> Work Items

Lab
Exploring methodologies and working with work items
 
Module 4: Architecture
This module introduces the Architect role and the tools found in the Software Architect edition. Participants will learn how to use the various Distributed System Designers to create models of their application and deployment environment and validate their design.

Lessons
> The Architect Role
> Logical Datacenter Designer
> Application Designer
> Trial Deployment

Lab
Creating and validating infrastructure and application architecture models

Module 5: Software Development
This module introduces the Developer role and the tools found in the Software Developer edition that will help improve code quality. Participants will learn how to use the new developer features of Visual Studio 2005, including the class designer. Participants will also learn how to use the version control capabilities of Team Foundation Server.

Lessons
> The Developer Role
> New Visual Studio 2005 features
> Team Foundation Version Control architecture
> Using Version Control

Lab
Using Team Foundation Version Control and code profiling tools

Module 6: Unit Testing and Code Analysis
This module introduces the concept of Test Driven Development (TDD) and the tools that support it in Team System. Participants will learn how to create proper unit tests that have adequate code coverage. In addition, the participants will learn how to analyze their code for common defects and best practice violations.

Lessons
> Unit Testing
> Code Coverage
> Code Analysis

Lab
Using Team Foundation Version Control and code analysis tools

Module 7: Web Testing
This module introduces the Tester role and some of the tools found in the Software Tester edition that will help test Web applications for defects. Participants will learn how to record and configure HTTP-based tests and play them back, looking for the desired results. They will also learn how to drive those Web tests from an existing data source, such as Microsoft Access or SQL Server.

Lessons
> The Tester Role
> Web Testing
> Configuring Web Tests
> Advanced Web Tests

Lab
Create Web tests and data-driven Web tests on an ASP.NET Web site

Module 8: Load Testing
This module continues the coverage of the tools found in the Software Tester edition. Participants will learn how to create load tests of existing unit tests or Web tests, in order to baseline performance, discover defects, and realize the performance limits of their code and infrastructure.

Lessons
> Load Testing
> Configuring Load Tests
> Advanced Load Tests

Lab
Create load tests of existing Web tests and also explore manual tests

Module 9: Team Build
This module covers the Team Build features of Team Foundation Server. Participants will learn the architecture and execution process of Team Build as well as how to create, configure, and execute build scripts. They will also learn how to retrieve and analyze the build reports.

Lessons
> Team Build
> Team Build Process
> Executing Team Build Scripts
> Reporting

Lab
Creating, configuring, executing, and scheduling team build scripts
 
Module 10: Customizing Process Templates
This module introduces process templates and the tools and techniques to customize and tailor them for a team’s specific needs.
Lessons
> Customizing vs. Extending
> Process Template Architecture
> Modifying Process Guidance
> Modifying Process Templates
> Work Item Type Schema
> Configuring Work Item State Workflow

Lab
Download and explore a process template
Create a new process template
Upload and test a process template
Alter work item types of existing team projects
Use the Process Template Editor (optional)

Module 11: Parallel Development
This module dives deep into Team Foundation Version Control, and its support for teams working in a parallel development environment.
Lessons
> Understanding Parallel Development
> Version Control Locking Models
> Terminology
> Branching and Merging
> Branching Patterns
> Shelving and Unshelving
> Version Control Security
> Team Foundation Power Tools (f.k.a. Power Toys)

Lab
Create and manage workspaces
Place an existing project under version control
Label version control artifacts
Detect and resolve a version conflict
Branch a version control folder
Merge changes between branches
Perform a “baseless merge”
Configure version control security
Shelve and unshelve changes
Configure and use a 3rd party compare and merge tool (optional)
Explore Team Foundation Power Tools (optional)

Module 12: Check-In Policies
This module dives deep into check-in policies, examining all of the built-in policy types, policy failure, managing failure overrides, and custom check-in policies.

Lessons
> Built-in Check-In Policy Types
> Check-In Policy Failure
> Managing Overrides
> Custom Check-In Policies

Lab
Configure check-in notes
Configure a check-in policy for unit testing
Configure a check-in policy for code analysis
Create and deploy a custom check-in policy
Explore the policy override notification tool (optional)

Module 13: Advanced Team Build
This module dives deep into Team Build and its underlying MSBuild framework, focusing on automation and customization.
Lessons
> Automating Team Build
> Continuous Integration (CI)
> Customizing Team Build
> MSBuild Architecture
> Targets and Tasks
> Custom Tasks

Lab
Create a Team Build type (script)
Execute a Team Build manually and from the command-line
Schedule a Team Build using Windows Scheduler
Run code analysis as part of a team build
Setup email notifications
Enable continuous integration
Customize the Team Build script
Create, register, and call a custom MSBuild task
Configure Team Build to publish an ASP.NET Web site (optional)

Module 14: Patterns, Best-Practices, and How-To’s
This comprehensive module covers various Visual Studio Team System and Team Foundation Server patterns and best practices, and also examines how to solve many of the frequently asked questions and problems.

Lessons
> SCM Patterns
> Accessing Shared Code and Components
> Organizing Team Projects
> Configuring Areas and Iterations
> Bulk Copying and Moving Work Items and Artifacts
> Moving an Application Through Major and Minor Version Changes
> Workspace Best Practices
> Branching and Merging Best Practices
> Working Offline
> Achieving Traceability
> Capacity Planning
> Team Build How-To’s
> Resources

Prerequisites: Before attending this course, participants must have experience working on a team-based software development project and be familiar with the Software Development Lifecycle.
> Have played one or more roles in the SDLC: PM, architect, developer, tester
> Have familiarity with one or more methodologies. For example: MSF, XP, Scrum, RUP
> Have familiarity with distributed application design. For example: client/server, Web applications, Web services, etc.
> Have used Visual Studio
> Be comfortable reading user requirements and business-need documents. For example: functional requirements, technical requirements, or business analysis reports.
> Understand the basic foundations of .NET
> Be able to read Visual C# code (all source code will be provided)
> Understand Microsoft Windows operating system basics
> Understand Microsoft Windows security basics
> Have some experience with a reporting tool. For example: SQL RS, Access, Crystal
Note: All fields are required
At the present time we do not offer training for individuals or groups less then 6 individuals. We apologize for any inconvenience.


We Value Your Privacy!

Ready to get started or in need of more information? Contact us today.

Go To Blog Virtual Learning

Testimonials

“56% of IT leaders plan to train their staff this year to better manage third-party relationships, negotiate contracts, assess vendor risk, and monitor service-level agreements” (“Trends 2007: Hot IT Skill Areas”, Forrester Research, Inc., March 2007).