4.33 out of 5
2912 reviews on Udemy

GitHub Ultimate: Master Git and GitHub – Beginner to Expert

Go from complete novice to expert in Git and GitHub using step-by-step, no-assumptions learning
Jason Taylor
17,678 students enrolled
English More
Learn the key concepts of the Git source control system
Step through the entire Git workflow
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
Save work in progress with Stashes
Mark special events with Tags and Releases
Even a bit of time travel within Git repositories and on GitHub
Perform many of the same local Git operations directly on GitHub
Join other GitHub projects by Forking and contribute back using Pull Requests
Review and Accept Pull Requests from Others
Share code with Gists
Manage project defects or enhancement requests with GitHub Issues
Group related repositories together with GitHub Organizations

This course will comprehensively cover the GitHub hosting service as a companion to the Git source control tool, which means no prior knowledge or experience is required. Students will emerge at the end with a very solid understanding and hands-on experience with Git and GitHub.

Course Organization

The course is divided into four major components:

  • Introduction and Setup

  • Learning Git Source Control

  • All About GitHub

  • Bonuses

Each one of the above components spans multiple sections in this course.

New! Video explaining how to resolve Git breaking when upgrading macOS each year


The Introduction provides a welcome to the course including some useful tips for getting the most out of taking the course and how the course is designed. That is followed by the Core Concepts which go over some critical theory before diving straight into Git.

After the introduction and core concepts, the first thing we do is a Quick Installation for both Windows and Mac. The Bonus section has a more comprehensive, step-by-step process for those that prefer it.

Learning Git Source Control

In The Basics, 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 some more Advanced Git topics like comparing differences, branching and merge resolution, tagging special events, saving work in progress, and even a bit of time travel.

All About GitHub

The main part of this course is all about GitHub. We will explore GitHub indepth from a source control hosting repository perspective.

In Welcome to GitHub we start off exploring some of the basic features of GitHub by creating a fresh repository and associate our local repository with it. Then, we prepare for the remainder of the course by setting up SSH Authentication, which we will use from this point forward. After that, we continue looking at the GitHub Repository, including many of the same operations we performed locally, but done directly within GitHub. Then in GitHub Repository Branches we dive into how Branches on GitHub and our local system work with each other.

After we have comprehensively covered how GitHub repositories work, we focus on how GitHub Tags and Releases work and their relationship with local tags in Git. We can then use tags/releases while Comparing Differences on GitHub.

We start tying things together in Social Coding where we join other projects on GitHub by forking and then submitting our contributions back using pull requests.

Once part of a team, you might use GitHub Issues to track defects or enhancement requests.

Sometimes you just need to share small parts of a file or a set of files, but don’t want to bother with a full Git repository. That where GitHub Gists help out — share just a snip of code or entire files.

Finally, group related GitHub repositories with GitHub Organizations and manage permissions and access using teams.


The bonuses sections and lectures provide additional information, more comprehensive instructions, or non-critical lectures.

Course Features

All tools have installation and configuration sections to ensure no one is left behind.
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 nearly 5 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. 

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 feature!


Course Welcome

An overview of what we will be covering in this course, including Git basics, advanced git techniques, sharing code snippets, and organizations within Git.

Audience and Approach

A guide to the technical level this course is targeted at, as well as an explanation of the pace and step-by-step command line approach used by this course.

Using The Command Line

We will be using the command line due to it's rich feature set and ability to teach concepts in more depth than would be otherwise possible.

Core Concepts

Core Concepts Overview

An overview of the core Git concepts we will explain in this section.

What is Git

A quick explanation of how Git works as a decentralized version control system.

The Repository

An explanation of how Git uses a repository to keep track of all of the changes we will make to the code throughout this section.

Commits and Files

A guide to the way that Git archives individual file history in order to preserve the total history of the repository.

What is GitHub

A quick overview of the remote repository service GitHub, including the limitations of only allowing public repositories for free (which has recently been changed).

Quick Installations

Quick Installation Overview

An overview to the tools we will install in this quick installation section of the course.

Quick Install on Windows

A quick guide to installing and configuring Git for Windows, Notepad++, and P4Merge on your system to be ready for the rest of this course.

Quick Installation on Windows Notes
Quick Install on Mac OS X

A quick guide to installing and configuring Git from Apple, TextMate 2, and P4Merge on your system to be ready for the rest of this course.

Quick Install on Mac OS X Notes

The Basics

The Basics Overview

An overview of the topics covered in this section, including creating a new repository, getting support, performing a basic workflow, working with files, excluding files from Git, and undoing mistakes.


Creating our initial Git repository using basic commands in Git.

Git States

An overview of the three local sates in Git, including the working directory, staging area, and Git repository, as well as the possible fourth state of remote.

First Commit

Making our first commit in Git in order to start our repository's history.

Repository and the Git Folder

A guide to the way the Git repository manages history inside it's ".git" folder.

Starting with Existing Project

Adding Git source control to an already existing project, just in case you forgot to initialize source control before starting your project.

Commits and Messages

Adding files to create differing commits within our Git repository.

Commit Details with Log and Show

Using the "git log" and "git show" commands in order to view our Git history so far.

Express Commits

Using options with the commit command to make committing faster when we update one of our files.

Backing Out Changes

Backing out our changes in order to undo changes we might not want before we add them to our Git Repository.

History and Making New Commands with Alias

Viewing our Git History in more practical ways and creating an alias to shorten that command down to be easier to use.

Rename and Delete Files

An explanation of how Git keeps track of files through renames and deletions.

Managing Files Outside of Git

Using external tools to manage files and seeing the impact this has on our Git Repository.

Excluding Unwanted Files

Using our ".gitignore" in order to only keep a history for the files we wish to keep track of.

Advanced: Beyond the Basics

Advanced Overview

An overview of the advanced topics covered in this section, such as comparing differences, branching, merging, resolving conflicts, creating milestones, and traveling through time in our repository.

Comparing Differences

How to compare differences between two commit points within Git.

Branching and Merge Types

An overview of the theory of how branching works within Git.

Special Markers

Special markers generally help refer to the heads of branches.

Simple Branching Example

Creating a branch to work on a feature and then merging that branch back into master and finally deleting it.

Conflict Resolution

Creating a conflict in our repository in order to view the various ways in which Git can show us the details of the conflict.

Marking Special Events with Tagging

Adding tags to commits in order to bookmark them for later.

Saving Work in Progress with Stashing

Saving our changes by stashing allows us to modify other things without committing our current changes.

Time Travel with Reset and Reflog

Using "reset" and "reflog" in order to go back to previous commit points in our Git history.

Welcome to GitHub

Welcome to GitHub Overview

An overview of why we will be using GitHub to back up our project and history remotely.

Signup for GitHub

Creating our GitHub account so we can back up our repositories throughout the rest of this course.

GitHub Profile

Setting up our GitHub profile in order to up or trust level when committing on repositories.

GitHub Settings

Adjusting our general Git settings on GitHub.

Creating a GitHub Repository

Creating a new remote repository on GitHub.

Linking to our GitHub Repository

Linking our local Git repository to our remote repository on GitHub using the command line on our local system.

Pushing Changes to GitHub

Pushing our source files, changes, and history from our local Git repository to our remote GitHub repository.

Verifying our Changes on GitHub

Verifying that the changes we pushed up in the previous lesson actually made it up to GitHub.

SSH Authentication

Authentication Overview

An overview of why SSH authentication, which we will set up in this section, is faster and more secure.


A quick overview of the differences between the HTTPS and SSH authentication strategies, and how it will practically affect using the remote repository.

Generating an SSH Key

Using our system's terminal to generate a public and private SSH keypair that will allow us to use SSH authentication to log into our remote GitHub repository.

Verify SSH Authentication with GitHub

Using our newly generated GitHub key in order to set up SSH authentication to ease the process of pushing upto GitHub from our local system.

GitHub Repository

GitHub Repository Overview

An overview of the topics covered in this section, mainly about doing operations to our remote repository on GitHub.

Starting Remote with a Starter Repository

Creating a new repository on GitHub so that we can use it throughout this section.

Create a Local Copy with Clone

Downloading our remote repository from GitHub onto our local system.

Seeding the Repository with Sample Content

Adding dummy HTML files to the local copy of our GitHub repository from initializr in order to have sample files on our repository.

Publish Back to GitHub

Pushing our changes from our local system back onto our GitHub repository.

Fetch and Pull

Understanding the differences between the fetch and pull command when getting changes from GitHub.

Repository Features and Settings

Exploring the features that GitHub provides, such as commits, branches, cloning, downloading, renaming and deleting repositories.

Updating Repository and Remote References

Updating our remote references on our local system in order to keep the local project synced up with the remote GitHub project.

Looking at Files and Folders on GitHub

Various ways of viewing the files and folders on our GitHub repository.

Directly Editing Files on GitHub

Although it isn't recommended, GitHub offers the capacity to directly edit files on GitHub, which may sometimes be the most convenient way of doing things.

Creating a New Files on GitHub

Using GitHub to add new files to the repository.

Creating a New File on Master

Creating a file on GitHub and making sure that it is created onto our main (master) branch.

Renaming and Deleting Files on GitHub

Showing how GitHub handles the renaming and deletion of files both in terms of it's repository and history.

Synchronizing our Changes with our Local Repository

Pushing the files we created on GitHub down to our local repository by pulling the changes down from GitHub.

Reviewing Commits with the Commit List

Using the list of commits to view the history of commits we have made throughout this section.

Commit Details: Going Deeper

Looking at specific commits on GitHub to get a more detailed look at our commit history.

GitHub Time Travel: Reviwing Your Repository as of a Particular Commit

Using GitHub to roll back our repository to an earlier commit.

Using Commit IDs with the Local Repository

Using GitHub's interface to find commit IDs and then viewing them on our local system.

GitHub Repository Branches

Repository Branches Overview

An overview of the branching we will do in this section, including interactions between GitHub and our local repository.

Creating Branches on GitHub

Using GitHub to create branches on our remote repository.

Local Branches

Starting locally by creating a branch on our local system before pushing it up to GitHub for future work.

Comparing and Pull Requests

Using GitHub to initiate pull requests in order to merge in branches from within the GitHub interface.

Merging Locally

Using out local copy of the GitHub repository to merge before pushing up the merge to GitHub.

Locally Switch to a Branch on GitHub

Checking out a remote branch from GitHub onto our local system.

Cleaning Up By Deleting Branches and References

Removing old unneeded branches and references from our GitHub repository.

Pull with Rebase

Using rebase to pull down commits from GitHub, stepping through the individual commits on our local system in order to more fully integrate the history of our remote branch with our local branch.

GitHub Graphs

Using our local system to view a graph of our history before comparing that to the GUI graph that is provide on GitHub.

Setting the Default Branch

Changing the default branch of a repository from the master branch to another long living branch, due to the master branch commonly not being ideal for active development.

Dealing with a Conflict while Pulling

Comparing conflicts between a remote (GitHub) copy of repository and local copy of a repository in order to resolve them.

GitHub Tags and Releases

Tags and Releases Overview

The uses of Git tags we will go over in this section, including marking project milestones and making release notes on GitHub.

Local Tags (a bit of Review)

Using our local repository to create tags and annotated tags for important commits, which we will use in the next few videos on our GitHub repository.

Pushing Local Tags to GitHub

Using our local repository to push up the tags on our local system to our remote repository.

Tags on GitHub

Viewing how the tags we created on our local system look on our remote GitHub repository.

Deleting Tags on GitHub

Using both our remote GitHub repository as well as our local Git repository to remove tags that are no longer applicable or wanted.

Updating Tags: Creating a Floating Tag

Using more advanced techniques to create floating tags that move along with development, say to keep track of which is the most up to date version of the unstable build.

Starting a Release on GitHub

Using more advanced tagging features to create a tag that specifies release information about a build we want to release.

Deleting a Release

Observing the information GitHub has about releases, as well as deleting releases that are no longer relevant or wanted.

Creating a Completely New Release

Using a more complicated feature in GitHub to create both a tag and a release at the same time, instead of creating them separately.

Comparing Differences

Comparing Differences Overview

An overview of the ways in which we will use GitHub to compare differences, including comparing between branches, tags, and commits, as well as integration with pull requests.

Comparing with Pull Requests

Using the pull request feature to make commit comparison easy on GitHub.

Comparing Commits

Using GitHub to compare changes between two arbitrary commits.

You can view and review the lecture materials indefinitely, like an on-demand channel.
Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don't have an internet connection, some instructors also let their students download course lectures. That's up to the instructor though, so make sure you get on their good side!
4.3 out of 5
2912 Ratings

Detailed Rating

Stars 5
Stars 4
Stars 3
Stars 2
Stars 1
30-Day Money-Back Guarantee


6 hours on-demand video
3 articles
Full lifetime access
Access on mobile and TV
Certificate of Completion