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
English
English
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
06:41

A quick introduction to the theory of how Git works.

How Git Works
04:02

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
05:13
+ 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
00:41

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

Chrome
03:33

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

Command Line
01:11

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
01:39

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

Git Configuration
01:59

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

Installation Notes
02:12
+ Git Bash
6 lectures 17:45

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

Overview
01:15

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
07:21

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
02:42

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.

Projects
01:11
+ 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.

Clone
03:21

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

First Local Commit
04:49

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

Edit Files
04:30

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

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

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

Overview
01:09

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

Command Prompt
04:22

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

Notepad
02:17

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

Start Locally
01:43

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

First Commit
02:38

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

Going Remote
05:41

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

PowerShell
04:40
+ 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.

Overview
02:06

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
02:24

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
02:02

Further configuring Atom to work well within Git Bash.

Atom with Git
02:03

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

Using Atom
04:31

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

Atom and Windows
02:06
+ Basics
12 lectures 43:08

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

Overview
00:46

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

Setup SSH
06:20

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
03:59

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

Start Local with an Existing Project
02:55

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
02:40

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

Delete
04:07

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

Rename
06:07

Understanding the history provided by the Git log command.

Git Log
03:46

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

Aliases
03:35

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

Ignore Unwanted File
03:57

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

Backout Changes
03:16

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
01:40
+ Compare
9 lectures 27:33

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

Overview
00:43

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

Install Diff and Merge Tool
06:07

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

The Setup
04:14

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

Comparing Differences
04:07

More advanced local comparisons with previous changes in our repository.

Compare Previous Changes
02:43

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

Git Show
01:54

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

Compare Previous Commits
02:42

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

Compare Remote Changes
04:06

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

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

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

Overview
01:05

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

Easy Branching
05:05

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

No Fast Forward Merges
03:58

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

Automatic Merges
05:35

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

Merge Conflicts
07:31

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

Delete Branches
02:26

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
02:49

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

GitHub Branch
06:27

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

Pull Request
06:53

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

Pull Request Conflict
03:44

Cleaning up our GitHub repository by deleting unnecessary branches.

GitHub Delete
04:30
+ Git GUI
12 lectures 48:38

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

Overview
01:46

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

Git GUI Start
04:22

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

Git GUI Tools
02:36

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

Git GUI with Existing Repo
04:54

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

Git GUI with New Repo
03:17

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

Backing out Changes
02:26

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

Git GUI with GitHub
03:08

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
05:05

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

Local Branches
03:59

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

Remote Branches
10:58

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

Git GUI History and Blame
03:16

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

Git Configuration
02:51
Requirements
  • Basic computer skills
  • Ability to install software on your computer
  • Admin rights may be required for software installation
Description

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