Development Tools


The Git & Github Bootcamp

Master the essentials and the tricky bits: rebasing, squashing, stashing, reflogs, blobs, trees, & more!

4.80 (2695 reviews)


17 hours


Mar 2021

Last Update
Regular Price


What you will learn

Understand how Git works behind the scenes

Explain the difference Git objects: trees, blobs, commits, and annotated tags

Master the essential Git workflow: adding & committing

Work with Git branches

Perform Git merges and resolve merge conflicts

Use Git diff to reveal changes over time

Master Git stashing

Undo changes using git restore, git revert, and git reset

Work with local and remote repositories

Master collaboration workflows: pull requests, "fork & clone", etc.

Squash, clean up, and rewrite history using interactive rebase

Retrieve "lost" work using git reflogs

Write custom and powerful Git aliases

Mark releases and versions using Git tags

Host static websites using Github Pages

Create markdown READMEs

Share code and snippets using Github Gists


The following sentence is annoying, but also true: the best time to learn Git was yesterday. Fortunately, the second best time is today!  Git is an essential tool for work in any code-related field, from data science to game development to machine learning.  This course covers everything you need to know to start using Git and Github in the real-world today!

The course's 20+ sections are broken down into four separate units:

  • Git Essentials

  • Next Level Git

  • Github & Collaboration

  • The Tricky Bits

We start off with Git Essentials.  The goal of this unit is to give you all the essential Git tools you need for daily use.  We start off talking about version control software, what it is, why it matters, and the history of Git.  Then we install Git and run through the Unix commands you'll need to work with Git (you can skip this if you're already familiar).  The bulk of this unit is focused on teaching the core Git mechanics like committing and branching and the associated concepts: the working directory, the repository, the staging area, etc.    We cover Git commands including: git init, git add, git commit, git status, git log, git branch, and git merge.  We end with a detailed look at branching, merging, and resolving conflicts.

Then we move on to out Next Level Git unit, where we cover additional commands and Git concepts that are extremely useful, but maybe not as "core" as the Git Essentials.  We start with a comprehensive look at the gif diff command and the various comparisons that we can make between commits, branches, the working directory, the staging area, and more!  We pay special attention to reading and parsing the dense output generated by diffs.  Then we shift our focus to stashing with the git stash command, a "convenience command" that many users love incorporating into their Git workflow.  Finally, we dive deep into undoing changes and time traveling with Git.  We learn how to revisit earlier work, detach and re-attach HEAD, and discard changes.  We cover git commands that help us undo changes including git checkout, git restore, git reset, and git revert.

Next up, we change gears to focus on Github & Collaboration.  We start by exploring Github (and similar tools) that host remote repositories and discussing the benefits they provide.  We create our own Github repositories and sync up changes between our remote and local repositories using the git push, git pull, and git fetch commands.  We then focus on commonly used collaboration workflows that students may encounter in the real world: feature branching, pull requests, forking & cloning, and more! We discuss contributing to open source projects and configuring Github repositories for collaboration. We also spend some time learning about useful Github features including Github Gists and Github Pages for free static hosting.

The last unit in the course, The Tricky Bits, is really just a collection of useful Git command and advanced topics.  We start by covering one of the "scarier" Git commands: rebasing!  We discuss the potential benefits and pitfalls of rebasing and compare it to merging.  Then we learn how to clean up our Git history by rewording, editing, dropping, and squashing commits using the interactive rebase command.  Next, we discuss Git tags (lightweight and annotated tags) semantic versioning and tagging workflows.  After that, we move on to a deep dive into the inner workings of Git.  We discuss the files and folders Git uses internally, the role of hashing functions in Git, and the role of Git objects (blobs, trees, etc.). Next, we talk about reference logs and the git reflog command.  Specifically, we learn how we can use reflogs to rescue "lost" commits and undo rebases.  Finally, we learn how to write custom and powerful Git aliases!

Throughout the course, you'll find tons and tons of diagrams and visual references I've created to try and explain Git.  The course also includes exercises I've tested on my in-person students, to give you an opportunity to practice the concepts in the course along the way.  If you are reading this sentence, I congratulate you on making it this far :) I hope you enjoy the course!


The Git & Github Bootcamp
The Git & Github Bootcamp
The Git & Github Bootcamp
The Git & Github Bootcamp


Course Orientation

Welcome To The Course!

What The Course Covers

A Note On The Exercises

Accessing The Slides & Diagrams


What Really Matters In This Section

What Exactly Is Git?

Visualizing Git

A Quick History Of Git

Who Uses Git?

Git Vs. Github: What's The Difference?

A Quick Git Intro Quiz!

Installation & Setup

What Really Matters In This Section

Installing Git: Terminal Vs. GUIs

WINDOWS Git Installation

MAC Git Installation

Configuring Your Git Name & Email

Installing GitKraken (Our GUI)

Terminal Crash Course: Introduction

Terminal Crash Course: Navigation

Terminal Crash Course: Creating Files & Folders

Terminal Crash Course: Deleting Files & Folders

The Very Basics Of Git: Adding & Committing

What Really Matters In This Section

What Is A Git Repo?

Our First Commands: Git Init and Git Status

The Mysterious .Git Folder

A Common Early Git Mistake

The Committing Workflow Overview

Staging Changes With Git Add

Finally, The Git Commit Command!

The Git Log Command (And More Committing)

Committing Exercise

Commits In Detail (And Related Topics)

What Really Matters In This Section

Navigating The Git Documentation

Keeping Your Commits Atomic

Commit Messages: Present Or Past Tense?

Escaping VIM & Configuring Git's Default Editor

A Closer Look At The Git Log Command

Committing With A GUI

Fixing Mistakes With Amend

Ignoring Files w/ .gitignore

Working With Branches

What Really Matters In This Section

Introducing Branches

The Master Branch (Or Is It Main?)

What On Earth Is HEAD?

Viewing All Branches With Git Branch

Creating & Switching Branches

More Practice With Branching

Another Option: Git Checkout Vs. Git Switch

Switching Branches With Unstaged Changes?

Deleting & Renaming Branches

How Git Stores HEAD & Branches

Branching Exercise

Merging Branches, Oh Boy!

What Really Matters In This Section

An Introduction To Merging

Performing A Fast Forward Merge

Visualizing Merges

Generating Merge Commits

Oh No! Merge Conflicts!

Resolving Merge Conflicts

Using VSCode To Resolve Conflicts

Merging Exercise

Comparing Changes With Git Diff

What Really Matters In This Section

Introducing The Git Diff Command

A Guide To Reading Diffs

Viewing Unstaged Changes

Viewing Working Directory Changes

Viewing Staged Changes

Diffing Specific Files

Comparing Changes Across Branches

Comparing Changes Across Commits

Visualizing Diffs With GUIs

Diff Exercise

The Ins and Outs of Stashing

What Really Matters In This Section

Why We Need Git Stash

Stashing Basics: Git Stash Save & Pop

Practicing With Git Stash

Git Stash Apply

Working With Multiple Stashes

Dropping & Clearing The Stash

Stashing Exercise

Undoing Changes & Time Traveling

What Really Matters In This Section

Checking Out Old Commits

Re-Attaching Our Detached HEAD!

Referencing Commits Relative to HEAD

Discarding Changes With Git Checkout

Un-Modifying With Git Restore

Un-Staging Changes With Git Restore

Undoing Commits With Git Reset

Reverting Commits With...Git Revert

Undoing Changes Exercise

Github: The Basics

What Really Matters In This Section

What Does Github Do For Us?

Why You Should Use Github!

Cloning Github Repos With Git Clone

Cloning Non-Github Repos

Github Setup: SSH Config

Creating Our First Github Repo!

A Crash Course on Git Remotes

Introducing Git Push

Touring A Github Repo

Practice With Git Push

Another Github Workflow: Cloning First

Main & Master: Github Default Branches

Github Basics Exercise

Fetching & Pulling

What Really Matters In This Section

Remote Tracking Branches: WTF Are They?

Checking Out Remote Tracking Branches

Working With Remote Branches

Git Fetch: The Basics

Demonstrating Git Fetch

Git Pull: The Basics

Git Pull & Merge Conflicts

A Shorter Syntax For Git Pull?

Github Grab Bag: Odds & Ends

What Really Matters In This Section

Github Repo Visibility: Public Vs. Private

Adding Github Collaborators

Github Collaboration Demo

What are READMEs?

A Markdown Crash Course

Adding a README To A Project

Creating Github Gists

Introducing Github Pages

Github Pages Demo

Git Collaboration Workflows

What Really Matters In This Section

The Pitfalls Of A Centralized Workflow

Centralized Workflow Demonstration

The All-Important Feature Branch Workflow

Feature Branch Workflow Demo

Merging Feature Branches

Introducing Pull Requests

Making Our First Pull Request

Merging Pull Requests With Conflicts

Configuring Branch Protection Rules

Introducing Forking

Forking Demonstration

The Fork & Clone Workflow

Fork & Clone Workflow Demonstration

Rebasing: The Scariest Git Command?

What Really Matters In This Section

Why is Rebasing Scary? Is it?

Comparing Merging & Rebasing

Rebase Demo Pt 1: Setup & Merging

Rebasing Demo Pt 2: Actually Rebasing

The Golden Rule: When NOT to Rebase

Handling Conflicts & Rebasing

Cleaning Up History With Interactive Rebase

What Really Matters In This Section

Introducing Interactive Rebase

Rewording Commits With Interactive Rebase

Fixing Up & Squashing Commits With Interactive Rebase

Dropping Commits With Interactive Rebase

Git Tags: Marking Important Moments In History

What Really Matters In This Section

The Idea Behind Git Tags

A Side Note On Semantic Versioning

Viewing & Searching Tags

Comparing Tags With Git Diff

Creating Lightweight Tags

Creating Annotated Tags

Tagging Previous Commits

Replacing Tags With Force

Deleting Tags

IMPORTANT: Pushing Tags

Git Behind The Scenes - Hashing & Objects

What Really Matters In This Section

Working With The Local Config File

Inside Git: The Refs Directory

Inside Git: The HEAD file

Inside Git: The Objects Directory

A Crash Course On Hashing Functions

Git As A Key-Value Datastore

Hashing With Git Hash-Object

Retrieving Data With Git Cat-File

Deep Dive Into Git Objects: Blobs

Deep Dive Into Git Objects: Trees

Deep Dive Into Git Objects: Commits

The Power of Reflogs - Retrieving "Lost" Work

What Really Matters In This Section

Introducing Reflogs

The Limitations of Reflogs

The Git Reflog Show Command

Passing Reflog References Around

Time-Based Reflog Qualifiers

Rescuing Lost Commits With Reflog

Undoing A Rebase w/ Reflog - It's A Miracle!

Writing Custom Git Aliases

What Matters In This Section

The Global Git Config File

Writing Our First Git Alias

Setting Aliases From The Command Line

Aliases With Arguments

Exploring Existing Useful Aliases Online


Julian19 March 2021

I had a basic understanding of git before I took the course, but it has taught me a lot more about git and how it works

John18 March 2021

This is definitely a well made course, i can suggest it to anyone who is not confident with the usage of git and github. Colt is a great instructor and he respond to questions as well.

David8 March 2021

I'm feel much more confident about joining a team of developers now and collaborating -- thanks Colt!

Ishank7 March 2021

Whatever colt does, he does it with passion, and it can be truly reflected in his courses, I had taken multiple git courses before, but this one just kills them all, the presentations, illustrations, clarity in each of the line that colt speaks is just amazing !

Rod6 March 2021

A teaching style that will surely meet the needs of many learning styles and all levels of aptitude. Colt Steele has made a valuable but mundane topic positively interesting. Love it!

Atchyut6 March 2021

Great course! I'm beyond 50%, in the GitHub sections now. I think it's a great course and Colt is an excellent instructor. Hope he makes a NextJS course someday.

Christopher5 March 2021

Colt is a great teacher. I have also taken other courses by him. I can't say yet whether this one meets his usual high standards. But I am confident that the course will, otherwise I wouldn't have bought another course from him.

Edward5 March 2021

I am a systems administrator that was assigned to a Cloud Devops team. I wish I had access to this course on day one. I asked many times about rebasing stashing etc, but no one explained it very well. Books were great, but they are long and not knowing what is in the course made it hard to pick out what I needed. This course gives you a baseline of knowledge all teams should posses. If I were still working I would tell the group all team members should take this class.

Alison5 March 2021

Like Colt’s other courses this course has been straight-forward, engaging and easy to understand from the get-go.

Percy4 March 2021

This was a no-brainer of a purchase. Finding the inner workings of Git anywhere on the web is arduous and worse than pulling teeth with hemorrhoids. I always end up with more questions than answers. And how easy is it to mess up the entire repo in one fell swoop. This course is essential, I believe, in getting employers to take an entry level applicant seriously. Anything by Colt is worth its weight in gold, so go ahead buy $this !

David4 March 2021

My second course from Colt Steele. I'm about 12% through and so far it is very beginner friendly and well laid out. - The first quiz was a really easy 1-question checkpoint, I hope the future quizzes and activities are more substantial. - I spend quite a lot of time using Sublime as an Editor in the last course (because Colt told me to, but it is nagware, not really free) and now he says to use something else as an editor and has us install GitKraken (which is Freemium, not free). <.<

Benjamin4 March 2021

Colt Steele is one of the leading instructors on Udemy, He is super motivated in what he is doing. His passion for teaching is why you will love this course, his passions is super contagious and you will also be passionate about Git and Github. And you will probably be addicted to his way of teaching like every one of us who love and enjoy his energy...

Gevorg3 March 2021

I think Colt is truly one of the best instructors I've ever had.... He is simply Awesome! I don't think that there is something else to add to it...

Ilya2 March 2021

I´ve only watched first 5 videos but I´m sure the course is great because I know the teacher. I took some of his courses in the past.

David2 March 2021

He is really passionate teacher and covers each and every bit of Git where I do not have to commit to memory . Thanks Colt


3/2/202193% OFFExpired
3/23/202191% OFFExpired


Udemy ID


Course created date


Course Indexed date
Course Submitted by