The Git & Github Bootcamp

Master the essentials and the tricky bits: rebasing, squashing, stashing, reflogs, blobs, trees, & more!
The Git & Github Bootcamp
File Size :
8.61 GB
Total length :
17h 2m



Colt Steele


Last update

Last updated 3/2021



The Git & Github Bootcamp

What you’ll 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 Git & Github Bootcamp


Basic computer skills


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 GitGithub & CollaborationThe Tricky BitsWe 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!


Section 1: Course Orientation

Lecture 1 Welcome To The Course!

Lecture 2 What The Course Covers

Lecture 3 A Note On The Exercises

Lecture 4 Accessing The Slides & Diagrams

Section 2: Introducing…Git!

Lecture 5 What Really Matters In This Section

Lecture 6 What Exactly Is Git?

Lecture 7 Visualizing Git

Lecture 8 A Quick History Of Git

Lecture 9 Who Uses Git?

Lecture 10 Git Vs. Github: What’s The Difference?

Section 3: Installation & Setup

Lecture 11 What Really Matters In This Section

Lecture 12 Installing Git: Terminal Vs. GUIs

Lecture 13 WINDOWS Git Installation

Lecture 14 MAC Git Installation

Lecture 15 Configuring Your Git Name & Email

Lecture 16 Installing GitKraken (Our GUI)

Lecture 17 Terminal Crash Course: Introduction

Lecture 18 Terminal Crash Course: Navigation

Lecture 19 Terminal Crash Course: Creating Files & Folders

Lecture 20 Terminal Crash Course: Deleting Files & Folders

Section 4: The Very Basics Of Git: Adding & Committing

Lecture 21 What Really Matters In This Section

Lecture 22 What Is A Git Repo?

Lecture 23 Our First Commands: Git Init and Git Status

Lecture 24 The Mysterious .Git Folder

Lecture 25 A Common Early Git Mistake

Lecture 26 The Committing Workflow Overview

Lecture 27 Staging Changes With Git Add

Lecture 28 Finally, The Git Commit Command!

Lecture 29 The Git Log Command (And More Committing)

Lecture 30 Committing Exercise

Section 5: Commits In Detail (And Related Topics)

Lecture 31 What Really Matters In This Section

Lecture 32 Navigating The Git Documentation

Lecture 33 Keeping Your Commits Atomic

Lecture 34 Commit Messages: Present Or Past Tense?

Lecture 35 Escaping VIM & Configuring Git’s Default Editor

Lecture 36 A Closer Look At The Git Log Command

Lecture 37 Committing With A GUI

Lecture 38 Fixing Mistakes With Amend

Lecture 39 Ignoring Files w/ .gitignore

Section 6: Working With Branches

Lecture 40 What Really Matters In This Section

Lecture 41 Introducing Branches

Lecture 42 The Master Branch (Or Is It Main?)

Lecture 43 What On Earth Is HEAD?

Lecture 44 Viewing All Branches With Git Branch

Lecture 45 Creating & Switching Branches

Lecture 46 More Practice With Branching

Lecture 47 Another Option: Git Checkout Vs. Git Switch

Lecture 48 Switching Branches With Unstaged Changes?

Lecture 49 Deleting & Renaming Branches

Lecture 50 How Git Stores HEAD & Branches

Lecture 51 Branching Exercise

Section 7: Merging Branches, Oh Boy!

Lecture 52 What Really Matters In This Section

Lecture 53 An Introduction To Merging

Lecture 54 Performing A Fast Forward Merge

Lecture 55 Visualizing Merges

Lecture 56 Generating Merge Commits

Lecture 57 Oh No! Merge Conflicts!

Lecture 58 Resolving Merge Conflicts

Lecture 59 Using VSCode To Resolve Conflicts

Lecture 60 Merging Exercise

Section 8: Comparing Changes With Git Diff

Lecture 61 What Really Matters In This Section

Lecture 62 Introducing The Git Diff Command

Lecture 63 A Guide To Reading Diffs

Lecture 64 Viewing Unstaged Changes

Lecture 65 Viewing Working Directory Changes

Lecture 66 Viewing Staged Changes

Lecture 67 Diffing Specific Files

Lecture 68 Comparing Changes Across Branches

Lecture 69 Comparing Changes Across Commits

Lecture 70 Visualizing Diffs With GUIs

Lecture 71 Diff Exercise

Section 9: The Ins and Outs of Stashing

Lecture 72 What Really Matters In This Section

Lecture 73 Why We Need Git Stash

Lecture 74 Stashing Basics: Git Stash Save & Pop

Lecture 75 Practicing With Git Stash

Lecture 76 Git Stash Apply

Lecture 77 Working With Multiple Stashes

Lecture 78 Dropping & Clearing The Stash

Lecture 79 Stashing Exercise

Section 10: Undoing Changes & Time Traveling

Lecture 80 What Really Matters In This Section

Lecture 81 Checking Out Old Commits

Lecture 82 Re-Attaching Our Detached HEAD!

Lecture 83 Referencing Commits Relative to HEAD

Lecture 84 Discarding Changes With Git Checkout

Lecture 85 Un-Modifying With Git Restore

Lecture 86 Un-Staging Changes With Git Restore

Lecture 87 Undoing Commits With Git Reset

Lecture 88 Reverting Commits With…Git Revert

Lecture 89 Undoing Changes Exercise

Section 11: Github: The Basics

Lecture 90 What Really Matters In This Section

Lecture 91 What Does Github Do For Us?

Lecture 92 Why You Should Use Github!

Lecture 93 Cloning Github Repos With Git Clone

Lecture 94 Cloning Non-Github Repos

Lecture 95 Github Setup: SSH Config

Lecture 96 Creating Our First Github Repo!

Lecture 97 A Crash Course on Git Remotes

Lecture 98 Introducing Git Push

Lecture 99 Touring A Github Repo

Lecture 100 Practice With Git Push

Lecture 101 A Closer Look At Git Push

Lecture 102 What does “git push -u” mean?

Lecture 103 Another Github Workflow: Cloning First

Lecture 104 Main & Master: Github Default Branches

Lecture 105 Github Basics Exercise

Section 12: Fetching & Pulling

Lecture 106 What Really Matters In This Section

Lecture 107 Remote Tracking Branches: WTF Are They?

Lecture 108 Checking Out Remote Tracking Branches

Lecture 109 Working With Remote Branches

Lecture 110 Git Fetch: The Basics

Lecture 111 Demonstrating Git Fetch

Lecture 112 Git Pull: The Basics

Lecture 113 Git Pull & Merge Conflicts

Lecture 114 A Shorter Syntax For Git Pull?

Section 13: Github Grab Bag: Odds & Ends

Lecture 115 What Really Matters In This Section

Lecture 116 Github Repo Visibility: Public Vs. Private

Lecture 117 Adding Github Collaborators

Lecture 118 Github Collaboration Demo

Lecture 119 What are READMEs?

Lecture 120 A Markdown Crash Course

Lecture 121 Adding a README To A Project

Lecture 122 Creating Github Gists

Lecture 123 Introducing Github Pages

Lecture 124 Github Pages Demo

Section 14: Git Collaboration Workflows

Lecture 125 What Really Matters In This Section

Lecture 126 The Pitfalls Of A Centralized Workflow

Lecture 127 Centralized Workflow Demonstration

Lecture 128 The All-Important Feature Branch Workflow

Lecture 129 Feature Branch Workflow Demo

Lecture 130 Merging Feature Branches

Lecture 131 Introducing Pull Requests

Lecture 132 Making Our First Pull Request

Lecture 133 Merging Pull Requests With Conflicts

Lecture 134 Configuring Branch Protection Rules

Lecture 135 Introducing Forking

Lecture 136 Forking Demonstration

Lecture 137 The Fork & Clone Workflow

Lecture 138 Fork & Clone Workflow Demonstration

Section 15: Rebasing: The Scariest Git Command?

Lecture 139 What Really Matters In This Section

Lecture 140 Why is Rebasing Scary? Is it?

Lecture 141 Comparing Merging & Rebasing

Lecture 142 Rebase Demo Pt 1: Setup & Merging

Lecture 143 Rebasing Demo Pt 2: Actually Rebasing

Lecture 144 The Golden Rule: When NOT to Rebase

Lecture 145 Handling Conflicts & Rebasing

Section 16: Cleaning Up History With Interactive Rebase

Lecture 146 What Really Matters In This Section

Lecture 147 Introducing Interactive Rebase

Lecture 148 Rewording Commits With Interactive Rebase

Lecture 149 Fixing Up & Squashing Commits With Interactive Rebase

Lecture 150 Dropping Commits With Interactive Rebase

Section 17: Git Tags: Marking Important Moments In History

Lecture 151 What Really Matters In This Section

Lecture 152 The Idea Behind Git Tags

Lecture 153 A Side Note On Semantic Versioning

Lecture 154 Viewing & Searching Tags

Lecture 155 Comparing Tags With Git Diff

Lecture 156 Creating Lightweight Tags

Lecture 157 Creating Annotated Tags

Lecture 158 Tagging Previous Commits

Lecture 159 Replacing Tags With Force

Lecture 160 Deleting Tags

Lecture 161 IMPORTANT: Pushing Tags

Section 18: Git Behind The Scenes – Hashing & Objects

Lecture 162 What Really Matters In This Section

Lecture 163 Working With The Local Config File

Lecture 164 Inside Git: The Refs Directory

Lecture 165 Inside Git: The HEAD file

Lecture 166 Inside Git: The Objects Directory

Lecture 167 A Crash Course On Hashing Functions

Lecture 168 Git As A Key-Value Datastore

Lecture 169 Hashing With Git Hash-Object

Lecture 170 Retrieving Data With Git Cat-File

Lecture 171 Deep Dive Into Git Objects: Blobs

Lecture 172 Deep Dive Into Git Objects: Trees

Lecture 173 Deep Dive Into Git Objects: Commits

Section 19: The Power of Reflogs – Retrieving “Lost” Work

Lecture 174 What Really Matters In This Section

Lecture 175 Introducing Reflogs

Lecture 176 The Limitations of Reflogs

Lecture 177 The Git Reflog Show Command

Lecture 178 Passing Reflog References Around

Lecture 179 Time-Based Reflog Qualifiers

Lecture 180 Rescuing Lost Commits With Reflog

Lecture 181 Undoing A Rebase w/ Reflog – It’s A Miracle!

Section 20: Writing Custom Git Aliases

Lecture 182 What Matters In This Section

Lecture 183 The Global Git Config File

Lecture 184 Writing Our First Git Alias

Lecture 185 Setting Aliases From The Command Line

Lecture 186 Aliases With Arguments

Lecture 187 Exploring Existing Useful Aliases Online

Anyone interested in learning Git in any capacity :),Anyone learning to code or hoping to enter a tech field,Web developers, data scientists, software engineers, mobile developers, game developers, etc.,Anyone who works with code or in a code-adjacent role

Course Information:

Udemy | English | 17h 2m | 8.61 GB
Created by: Colt Steele

You Can See More Courses in the Developer >> Greetings from

New Courses

Scroll to Top