GitHub Ultimate: Master Git and GitHub - Beginner to Expert
4.3 (5,041 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.
30,885 students enrolled

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
Bestseller
4.3 (5,041 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.
30,885 students enrolled
Created by Jason Taylor
Last updated 3/2019
English
English, French [Auto-generated], 8 more
  • German [Auto-generated]
  • Indonesian [Auto-generated]
  • Italian [Auto-generated]
  • Polish [Auto-generated]
  • Portuguese [Auto-generated]
  • Romanian [Auto-generated]
  • Spanish [Auto-generated]
  • Thai [Auto-generated]
Current price: $69.99 Original price: $99.99 Discount: 30% off
5 hours left at this price!
30-Day Money-Back Guarantee
This course includes
  • 6.5 hours on-demand video
  • 3 articles
  • 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
  • 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
Course content
Expand all 151 lectures 06:25:50
+ Introduction
3 lectures 06:46

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

Preview 01:58

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.

Preview 02:27

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.

Using The Command Line
02:21
+ Core Concepts
5 lectures 05:22

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

Core Concepts Overview
00:29

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

What is Git
01:36

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.

The Repository
01:10

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

Commits and Files
00:50

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

What is GitHub
01:17
+ Quick Installations
5 lectures 22:16

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

Quick Installation Overview
01:02

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 Install on Windows
08:37
Quick Installation on Windows Notes
03:37

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
06:18
Quick Install on Mac OS X Notes
02:42
+ The Basics
14 lectures 31:59

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.

Preview 00:42

Creating our initial Git repository using basic commands in Git.

Preview 01:28

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.

Git States
01:23

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

First Commit
03:04

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

Repository and the Git Folder
01:59

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

Starting with Existing Project
01:56

Adding files to create differing commits within our Git repository.

Commits and Messages
02:01

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

Commit Details with Log and Show
01:16

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

Express Commits
02:58

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

Backing Out Changes
02:12

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

History and Making New Commands with Alias
03:50

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

Rename and Delete Files
03:08

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

Managing Files Outside of Git
03:06

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

Excluding Unwanted Files
02:56
+ Advanced: Beyond the Basics
9 lectures 25:57

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.

Preview 00:35

How to compare differences between two commit points within Git.

Preview 02:39

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

Branching and Merge Types
02:02

Special markers generally help refer to the heads of branches.

Special Markers
00:37

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

Simple Branching Example
04:56

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

Conflict Resolution
04:50

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

Marking Special Events with Tagging
02:38

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

Saving Work in Progress with Stashing
02:17

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

Time Travel with Reset and Reflog
05:23
+ Welcome to GitHub
8 lectures 15:08

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

Welcome to GitHub Overview
01:04

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

Signup for GitHub
02:06

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

GitHub Profile
02:23

Adjusting our general Git settings on GitHub.

GitHub Settings
02:34

Creating a new remote repository on GitHub.

Creating a GitHub Repository
01:13

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

Linking to our GitHub Repository
02:19

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

Pushing Changes to GitHub
02:29

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

Verifying our Changes on GitHub
01:00
+ SSH Authentication
4 lectures 07:28

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

Authentication Overview
00:41

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

SSH vs HTTPS
01:49

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.

Generating an SSH Key
02:21

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.

Verify SSH Authentication with GitHub
02:37
+ GitHub Repository
18 lectures 37:26

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

Preview 00:38

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

Preview 01:11

Downloading our remote repository from GitHub onto our local system.

Create a Local Copy with Clone
03:42

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

Seeding the Repository with Sample Content
03:03

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

Publish Back to GitHub
01:54

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

Fetch and Pull
03:53

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

Repository Features and Settings
02:58

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

Updating Repository and Remote References
01:55

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

Looking at Files and Folders on GitHub
00:55

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.

Directly Editing Files on GitHub
02:38

Using GitHub to add new files to the repository.

Creating a New Files on GitHub
02:40

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

Creating a New File on Master
01:10

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

Renaming and Deleting Files on GitHub
02:08

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

Synchronizing our Changes with our Local Repository
01:31

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

Reviewing Commits with the Commit List
00:58

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

Commit Details: Going Deeper
03:17

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

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

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

Using Commit IDs with the Local Repository
01:22
+ GitHub Repository Branches
11 lectures 40:29

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

Repository Branches Overview
00:18

Using GitHub to create branches on our remote repository.

Creating Branches on GitHub
02:54

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

Local Branches
03:33

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

Comparing and Pull Requests
05:23

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

Merging Locally
05:26

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

Locally Switch to a Branch on GitHub
03:57

Removing old unneeded branches and references from our GitHub repository.

Cleaning Up By Deleting Branches and References
03:49

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.

Pull with Rebase
04:36

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

GitHub Graphs
01:51

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.

Setting the Default Branch
05:08

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

Dealing with a Conflict while Pulling
03:34
+ GitHub Tags and Releases
9 lectures 24:54

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

Tags and Releases Overview
00:23

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.

Local Tags (a bit of Review)
04:27

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

Pushing Local Tags to GitHub
03:27

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

Tags on GitHub
02:18

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

Deleting Tags on GitHub
02:42

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.

Updating Tags: Creating a Floating Tag
03:56

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

Starting a Release on GitHub
02:52

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

Deleting a Release
01:30

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

Creating a Completely New Release
03:19
Requirements
  • Basic computer skills
  • Ability to install software on your computer
  • Admin rights may be required for software installation
Description

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

Introduction

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.

Bonuses

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!

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