Git for Windows: Step-By-Step Mastery using Commands and GUI
4.6 (256 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
8,561 students enrolled

Git for Windows: Step-By-Step Mastery using Commands and GUI

Start from nothing and master the foundation of Git source control, GitHub service, graphical clients and related tools
4.6 (256 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
8,561 students enrolled
Created by Jason Taylor
Last updated 1/2019
Current price: $139.99 Original price: $199.99 Discount: 30% off
5 hours left at this price!
30-Day Money-Back Guarantee
This course includes
  • 8 hours on-demand video
  • 1 article
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
Training 5 or more people?

Get your team access to 4,000+ top Udemy courses anytime, anywhere.

Try Udemy for Business
What you'll learn
  • Learn the key concepts of the Git source control system
  • Step through the entire Git workflow
  • Install Git and configure a text editor for efficient use with Git
  • Compare the different states in Git
  • Manage files inside and outside the control of Git and GitHub
  • Create and manage repositories on GitHub
  • Create branches and resolve conflicts with confidence
  • Work with branches on GitHub
  • Walk through the pull request workflow on GitHub
  • Perform many of the same local Git operations directly on GitHub
  • Use various Git graphical clients in addition to and in combination with the command line
Course content
Expand all 129 lectures 07:50:00
+ Introduction
6 lectures 25:17

A general overview of the course objectives. This course takes a step by step approach to the fundamentals of using Git and GitHub within the Windows 10 environment.

Preview 02:28

A detailing of the target audience for this course. Specifically, students new to Git using the Windows environment. The videos are short and to the point, using hands on demos to explore concepts.

Preview 02:40

A short bio of the instructor, Jason Taylor.

Preview 04:13

A quick overview of why you should be using version control! Source control is a centralized backup system that not only preserves code, but a history of changes to the code. This enables many critical features that improve any development cycle.

Why Source Control

A quick introduction to the theory of how Git works.

How Git Works

A quick explanation of why this course starts first from the command line. Many Git features work best on the command line. And, even if you do use graphical clients, understanding the commands that make those clients work makes any developer's job a lot easier.

Command Line Start
+ Installation
8 lectures 19:14

A general overview of what installation videos will be featured in this section. Students should feel free to skip over or skim through these lectures as long as they are confident in their setup.

Preview 01:46

A quick look at the importance of 64 vs 32 bit in installing software for your computer.

System Setup

A quick guide to installing Google Chrome and setting it up for the rest of this course.


A quick guide to creating shortcuts to easily access the command line environment within windows.

Command Line

A guide to installing and setting up Git and the Git Bash environment in windows for use as the heart of this course.

Preview 06:13

A quick introduction to the internal guide provided within the Git Bash environment.

Git Help

A quick guide to providing the minimum configuration needed to be able to start using Git on Windows.

Git Configuration

A text-based guide on how to configure your system for this course.

Installation Notes
+ Git Bash
6 lectures 17:45

A quick explanation of the critical concepts of this section of the course.


A guide to using the Git bash terminal environment to navigate through your file system.

Preview 03:01

A guide to how Git bash functions within Windows and how to use the help command in order to get an overview of the commands you may want to use.

Preview 02:15

A basic overview of how to manage files and folders within the Git Bash terminal environment.

Files and Folders

Most students won't ever want to use the command line based text editor VI, but knowing the basics will help get you out of a sticky situation if it's ever forced upon you!

Vi Survival Guide

A final guide to file management within Git Bash, showing how and where to set up a folder to contain all example projects we will be working with in this course.

+ Quick Start
7 lectures 22:56

An overview of the goals of going through this quick start git workflow.

Preview 00:34

A short guide on setting up a GitHub account. Having a remote place to store your files is a vital part of source control, as it provides the best type of backup for these projects. Feel free to skip if you already have a GitHub account.

Preview 02:16

A quick guide to creating your first remote repository on GitHub.

Preview 03:32

A quick explanation of how to get your remote repository onto your local system. This is the most important step when using a "starting remote" workflow in Git.


Creating our first commit on our local system in order to better understand the workflow between Git and Git Hub.

First Local Commit

Editing a file in order to simulate work being done locally on our Git repository.

Edit Files

Completing the workflow cycle through backing up our progress to our remote hosting service, GitHub.

Push Back to GitHub
+ Command Shell
7 lectures 22:30

A quick overview of the topics covered in this section on the Windows Command Shell.


Getting used to the way the Windows command prompt functions in comparison to the bash environment.

Command Prompt

Setting up the default Windows program, notepad, to be the default editor in the command prompt to avoid using the VI editor.


Starting a new repository locally in the Windows command prompt environment.

Start Locally

Creating the initial commit for our local Git repository in order to legitimize it as a repository.

First Commit

Setting up and associating a remote repository with our local repository using the windows command prompt.

Going Remote

Using the third command line option, Power Shell, in order to further modify our Git repository.

+ Text Editor
6 lectures 15:12

A quick explanation as to why we will be installing the HTML based text editor Atom to do more advanced work in the rest of this course.


A quick guide to installing the Atom text editor and integrating it into all three command line interfaces: Git Bash, PowerShell, and Command Prompt.

Atom Install

A quick guide to modifying the look of text in Atom to make it easier to work with for the rest of this course.

Atom Fonts

Further configuring Atom to work well within Git Bash.

Atom with Git

A quick-start guide to using the feature set of the Atom text editor.

Using Atom

A quick guide to setting up and using Atom from within the windows file explorer.

Atom and Windows
+ Basics
12 lectures 43:08

An overview of the Git basics that are introduced in this section.


A guide to setting up SSH authentication in order to establish a more secure connection between our local and remote repositories.

Setup SSH

A quick guide to improving the security of our repositories by moving them over to our newly set up SSH authentication method.

Working with Remotes

A guide to creating a new repository initialized with the basic structure of a web page.

Start Local with an Existing Project

A guide to more efficiently add files to our Git repository using recursion, before finally pushing up those changes to our remote repository.

Recursive Add

A guide to the slightly more complicated nature of deleting files within Git while retaining Git's file tracking.


A guide to the similarly complicated nature of moving files within Git while retaining Git's file tracking.


Understanding the history provided by the Git log command.

Git Log

A guide to simply our history commands into simpler custom aliases that perform the same actions.


A guide to automatically excluding files that you do not wish to track with Git.

Ignore Unwanted File

A guide to undoing changes you don't want using Git's history management.

Backout Changes

Backing up all of the changes we've made within this section, so to make sure we all start on the same foot in the next sections.

Going Remote to GitHub
+ Compare
9 lectures 27:33

An overview to the types of Git comparisons we will be doing in this section.


A guide to installing and integrating the comparison and merge tool, P4Merge.

Install Diff and Merge Tool

Setting up our repository with easily understandable changes to use as comparison examples throughout the next few lectures.

The Setup

The first basic level of comparison; comparing files within our local environment.

Comparing Differences

More advanced local comparisons with previous changes in our repository.

Compare Previous Changes

A detailed explanation of how the Git show command is used to understand our Git commit history.

Git Show

Comparing changes between two arbitrary commits in our local Git repository.

Compare Previous Commits

Using our local system to compare changes between our local and remote repositories.

Compare Remote Changes

Cleaning up our changes in order to make things ready for the next section.

Just a bit of Cleanup
+ Branching
11 lectures 50:03

An overview of the types of bracing we will be working with in this section.


A quick overview of the simple way to create and use branches within Git.

Easy Branching

Learning how to preserve branches in history by disabling fast forward merges.

No Fast Forward Merges

A guide to getting the most out of automatic merges in our Git repository.

Automatic Merges

Creating conflicts in order to show how merging will most often work within an active (chaotic) development environment.

Merge Conflicts

Deleting branches in order to clean up the history of our Git repository.

Delete Branches

Creating forks of remote repositories in order to work with them. This is the most common method used when getting started working on software projects, especially open source ones.

GitHub Fork

Learning how to use GitHub itself to create and manage branches for our Git repository.

GitHub Branch

Learning how to compare and merge local and remote repositories together using pull requests.

Pull Request

Resolving conflicts created in the local repository when pulling from the remote repository using our difftool.

Pull Request Conflict

Cleaning up our GitHub repository by deleting unnecessary branches.

GitHub Delete
+ Git GUI
12 lectures 48:38

A quick overview of the goals of this section on the Git GUI.


A quick-start guide to the setting up and using basic features of the Git GUI client.

Git GUI Start

A guide to the tools in Git GUI, specifically focusing on integrating our Atom text editor to the Git GUI environment.

Git GUI Tools

A guide to a basic Git workflow within Git GUI using an existing repository.

Git GUI with Existing Repo

A guide to using Git GUI to create a fresh repository.

Git GUI with New Repo

A guide to making and then undoing those changes within our Git GUI client.

Backing out Changes

Setting up our GitHub repository with our new repository through the Git GUI client.

Git GUI with GitHub

A guide to starting remote by creating a repository on GitHub and then cloning it down to our local system using the Git GUI client.

Clone with Git GUI

A guide to using Git GUI to create branches on our local system.

Local Branches

A guide to integrating branches between GitHub and our local Git GUI client.

Remote Branches

A guide to viewing our repository history, as well as blame, from within our Git GUI client.

Git GUI History and Blame

Configuring our Git GUI client to be better suited to our workflow for future projects.

Git Configuration
  • Basic computer skills
  • Ability to install software on your computer
  • Admin rights may be required for software installation

This course is designed to be a comprehensive, step-by-step approach to learning the Git source control specifically designed for Windows users, which means no prior knowledge or experience is required but students will emerge at the end with a very solid understanding and hands-on experience with Git and related source control concepts. Since this course is design for Windows users in mind, we will cover both command line and graphical clients for Git while learning the underlying concepts. If you use other operating systems too, most of the concepts will transfer over without much effort.

Course Outline

Course Introduction and Overview provides an introduction to this course and the Git source control system and sets the stage for the rest of the course.

After the introduction, this first thing we do is run through the Installation process. If you don’t want to watch installation videos, you can simply follow the installation notes at the end of that section.

For those not familiar with the command line or Bash shell environment, I provide a handy Git Bash section for those interested.

Quick Start a very quick (15 minutes), hands-on introduction to Git. We start off by signing up for GitHub, creating a repository there, the makiing a local copy (clone), local changes (add/commit) and then update GitHub with our changes (push). This is the most common workflow developers will do using Git.

Once we have worked through the basic add/commit/push workflow, we can do the same steps, and a few more, using the Windows Command Prompt and PowerShell— really to show how the Git-related command work identically regardless of the shell used.

To prepare for the rest of the course, and a more common developer setup, we will install and configure a Text Editor (Atom) to work seamlessly with Git.

In Basic Commands, we walk through all the foundational commands needed to start a new project managed by Git (or enable Git for an existing project) all the way through making commits, including common file operations like moving and deleting files. We also cover how to exclude the wrong files from accidentally being committed and how to review your repository's history.

With a strong foundation in place, we explore ways to make Comparisons in Git, including all the different local states, between commits, and between local and remote repositories.

We give great attending to Branching and Merging in Git. We start off with the simple "happy path" and learn about "Fast-Forward" merges and how to control them. The we walk through common "automatic" merges. Then, we cause trouble on purpose so we can step through resolving conflicting merges with our visual merge tool. Finally, we work with branches on the GitHub hosting service.

With a solid foundation in place using Git on the command line, we will look at various Git graphical clients starting with the official Git GUI client on Windows. With Git GUI, we cover many of the same commands, but simply using the graphical client instead of the command line.

Another way to interact with Git is via the Windows Shell or Windows File Explorer in which we can use the default Git integration provided by Git for Windows and even deeper integration using TortoiseGit.

Course Features

Presentations provide audio/video training of conceptual ideas. Since few like slide-ware presentations, slide-presentations are kept to a minimum.  

Screencasts provide a video of the instructor's computer system with any actions, commands, or screens displayed and narrated. There is over 6 hours of screencast based video training in order to step through each command or action in sufficient detail.

All videos are available in high quality 1080p / Full HD resolution for sharp and clear viewing on modern desktops and tablets although resolution delivery is dependent on student’s device capabilities detected by the Udemy video player.

Several attachments and document lectures throughout the course provide supplemental information, illustrations, or other reference material.

Moving Forward

This course will expand periodically to include more topics, supporting materials and bonus content! Some content may be in direct response to student feedback or discussions -- so get engaged with the course discussions  (Q&A) feature!

Who this course is for:
  • Anyone interested in using source control and specifically Git and GitHub, especially Windows users
  • Software engineers, developers, programmers new to Git or GitHub
  • IT Managers or technical leads considering Git or GitHub for version control on their team