It's been a long time coming and my latest Pluralsight course is finally out!  DevOps Skills for Developers with Visual Studio & Team Foundation Server (TFS)!

TL;DR -- DevOps using Visual Studio 2015 and Team Foundation Server 2015 – How do you do it and why you should care?

This course will change your focus from "software development" to "software delivery".  If your code hasn’t been delivered so that someone can use it, it’s not very valuable.  And the faster that you can build and deliver great features, the sooner that you’ll start capturing that value.  The process of going from an idea for a feature to developing a feature to delivering a feature is called ‘DevOps’.

This course will show you how to use the tools and features of Visual Studio 2015 and Team Foundation Server 2015 to automate and improve your DevOps "flow".

Here's what you'll see in the course.

Module 1: What Is Devops? Why Do I Care?

What Is DevOps? Why Should I Care About DevOps? DevOps with Microsoft Tools

Module 2: Consolidating Your Team's Source Code with Version Control

Version Control (aka. Source Control) is at the center of any successful team-based development project.  We'll discuss the core version control features that are available in Team Foundation Server 2015 including how to choose between Team Foundation Server Version Control or Git.

Why Version Control? Version Control Options in TFS Team Projects Team Project Collections TFVC Overview & Demos Git + TFS Overview Git + TFS Demo, Part 1: Basics Git + TFS Demo, Part 2: Fetch & Pull Git + TFS Demo, Part 3: Associated Work Items Git + TFS Demo, Part 4: Merge Conflicts Git + TFS Demo, Part 5: Multiple Repositories Git or TFVC?

Module 3: Work & Constraints

This module discusses the types of work you'll see in IT, the dangers of multitasking, rework, bottlenecks in your process, and the Theory of Constraints.

Work & DevOps Multitasking & Work In Progress Theory of Constraints

Module 4: Planning and Tracking Your Team's Work

This module will show you how to use Scrum and/or Kanban to plan, track, and manage your work using Team Foundation Server 2015.

Scrum and Kanban Demo: Kanban with TFS Demo: Scrum Backlog Management with TFS Demo: Forecasting and Velocity Demo: Scrum Sprint Planning with TFS Demo: Running and Monitoring a Sprint with TFS Demo: Project Dashboards Demo: Work Item Queries and Charting

Module 5: Unit Testing and DevOps

Quality is not something that can be added later.  You need to think about software quality early and a great way to do that is to start by developing code using Unit Tests.

Unit Test Demo and What Is a Unit Test? Why Unit Testing and DevOps?

Module 6: Managing & Deploying SQL Server Database Code

If you want to be successful at DevOps, you'll need to get your database code under version control and have a way to deploy it.

SQL Server Data Tools: What & Why? Demo: SQL Server Data Tools Demo: Comparisons & Updates Demo: Lookup Data Demo: Deploy & automate using SqlPackage.exe

Module 7: Automating Builds and Deployments

If you want to get good at DevOps, you need to have an automated way to bring your team's code together to build it, test it, and deploy it.  The core of this is going to be your TFS build servers and your automated builds.  In this module, we'll discuss Team Foundation Server 2015's new build system including how to set up a build server, how to create a build, and how to customize the build to deploy your code automatically.

Why Automated Builds and DevOps? Demo: Create a TFS Build Demo: Build Failures and Bugs Demo: Builds and the Project Dashboard Demo: Configure Build Agents and Capabilities Demo: Deploy Database Updates from a Build Demo: Deploy an ASP.NET Application to IIS from a Build

Module 8: Managing 'Hot Fixes' & Code Quality: Branches and Code Reviews

What Is Branching & Merging? Demo: Branching with TFVC Demo: Branching with Git Branching Risks Code Reviews Demo: Code Reviews with Git Pull Requests Demo: Branch Policies with Git Pull Requests Demo: Code Reviews with TFVC Demo: Hot Fixes & Release Branches with TFVC Demo: Hot Fixes with Git Tags

Module 9: QA Testing & Automated UI Tests with Coded UI

What about "QA testing"?  Where does that fit in to a DevOps world?  Well, in any complex application, you’ll almost definitely have manual test cases – aka. "QA Tests" – that will initially need to be run and tracked by humans.  Conveniently enough, Team Foundation Server has a whole set of features that help you to manage, track, and (eventually) automate your manual testing (aka. "QA Testing") efforts.  In this module, we’re going to show you how to use the testing features of Team Foundation Server to plan, execute, and track your manual testing efforts.  Since DevOps craves automation, we’ll also show you how to use Visual Studio Coded UI Tests to automate the work of human QA testers and incorporate it into your automated builds.

A New Kind of QA for Devops & TFS Demo: QA Test Cases in TFS Demo: QA Test Parameters & Data Demo: Run Test Cases & Create Bugs via the Web Demo: Shared Test Steps & Shared Parameters Demo: Run QA Test Cases via the MTM Client Demo: Assigning Test Cases + Test Suite Charts DevOps + UI Automation Tests Demo: Automated Smoke Test with Coded UI, Part 1 Demo: Automated Smoke Test with Coded UI, Part 2

Module 10: Simplifying Feature Deployments and Feedback

This module focuses on some of the architectural aspects of making your application participate in your DevOps flow.  First we'll talk about how to implement Feature Flag deployments in your application.  Feature flags separates the production deployment of a feature from the 'enablement' of a feature using configuration.  Put another way, you can deploy code for a feature to your production servers but then only turn it on when you think it's ready for human consumption.  Finally, we'll talk about how to gather and track user feedback about your application.

Limits of Source Control-based Releases Feature Flags Demo: Feature Flag Infrastructure Demo: Using Feature Flags to Implement a Feature Demo: Deploying Two Features at the Same Time with Feature Flags Demo: Implementing a Private Beta with Feature Flags DevOps, Product Ownership, & Feedback Demo: Capturing Feedback & Feature Utilization

Module 11: DevOps Release Pipelines with Visual Studio Release Management

At some point, your DevOps deployment needs get complex and using just your TFS automated builds alone just won't be enough.  This is where Visual Studio Release Management comes in.  Release Management (RM) builds on top of what you already have in TFS build and then allows you to define environments, approval workflows, and security policies that help you to manage and track your deployments.  In this module, we'll show you how to implement a more robust DevOps flow using Release Management.

What is TFS Release Management? Demo: Create a Release, Part 1 Demo: Create a Release, Part 2 Demo: Add an Environment Demo: Triggers & Continuous Deployment Demo: Approvals

Here's the link to the course: DevOps Skills for Developers with Visual Studio & Team Foundation Server (TFS)

-Ben

-- Looking for help with DevOps?  Need DevOps training and want to run an on-site version of this class for your company?  Trying to make sense of TFS Release Management?  We can help.  Drop us a line at info@benday.com.