The Git & Github Bootcamp

16h 54m 2s
English
Paid
November 1, 2023

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!

More

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 checkoutgit restoregit 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 pushgit pull, and git fetch commands.  We then focus on commonly used collaboration workflows that students may encounter in the real world: feature branchingpull requestsforking & 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 (blobstrees, 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!

Watch Online The Git & Github Bootcamp

Join premium to watch
Go to premium
# Title Duration
1 Welcome To The Course! 04:27
2 What The Course Covers 03:53
3 A Note On The Exercises 02:08
4 Accessing The Slides & Diagrams 01:10
5 What Really Matters In This Section 01:25
6 What Exactly Is Git? 03:09
7 Visualizing Git 06:50
8 A Quick History Of Git 05:04
9 Who Uses Git? 06:00
10 Git Vs. Github: What's The Difference? 03:26
11 What Really Matters In This Section 01:56
12 Installing Git: Terminal Vs. GUIs 06:17
13 WINDOWS Git Installation 08:54
14 MAC Git Installation 03:28
15 Configuring Your Git Name & Email 04:14
16 Installing GitKraken (Our GUI) 03:47
17 Terminal Crash Course: Introduction 03:05
18 Terminal Crash Course: Navigation 12:19
19 Terminal Crash Course: Creating Files & Folders 09:48
20 Terminal Crash Course: Deleting Files & Folders 06:43
21 What Really Matters In This Section 01:13
22 What Is A Git Repo? 04:06
23 Our First Commands: Git Init and Git Status 03:55
24 The Mysterious .Git Folder 03:35
25 A Common Early Git Mistake 03:33
26 The Committing Workflow Overview 06:25
27 Staging Changes With Git Add 07:16
28 Finally, The Git Commit Command! 04:52
29 The Git Log Command (And More Committing) 08:25
30 Committing Exercise 07:51
31 What Really Matters In This Section 02:14
32 Navigating The Git Documentation 04:07
33 Keeping Your Commits Atomic 06:21
34 Commit Messages: Present Or Past Tense? 03:10
35 Escaping VIM & Configuring Git's Default Editor 09:02
36 A Closer Look At The Git Log Command 04:07
37 Committing With A GUI 06:26
38 Fixing Mistakes With Amend 05:00
39 Ignoring Files w/ .gitignore 10:42
40 What Really Matters In This Section 02:06
41 Introducing Branches 05:33
42 The Master Branch (Or Is It Main?) 04:44
43 What On Earth Is HEAD? 05:38
44 Viewing All Branches With Git Branch 01:23
45 Creating & Switching Branches 07:57
46 More Practice With Branching 05:28
47 Another Option: Git Checkout Vs. Git Switch 04:39
48 Switching Branches With Unstaged Changes? 03:57
49 Deleting & Renaming Branches 05:34
50 How Git Stores HEAD & Branches 05:28
51 Branching Exercise 08:10
52 What Really Matters In This Section 01:47
53 An Introduction To Merging 05:17
54 Performing A Fast Forward Merge 04:32
55 Visualizing Merges 04:37
56 Generating Merge Commits 09:44
57 Oh No! Merge Conflicts! 03:19
58 Resolving Merge Conflicts 08:14
59 Using VSCode To Resolve Conflicts 07:42
60 Merging Exercise 11:07
61 What Really Matters In This Section 01:52
62 Introducing The Git Diff Command 04:30
63 A Guide To Reading Diffs 10:26
64 Viewing Unstaged Changes 03:52
65 Viewing Working Directory Changes 03:29
66 Viewing Staged Changes 02:06
67 Diffing Specific Files 02:41
68 Comparing Changes Across Branches 04:45
69 Comparing Changes Across Commits 02:10
70 Visualizing Diffs With GUIs 06:26
71 Diff Exercise 11:15
72 What Really Matters In This Section 01:47
73 Why We Need Git Stash 07:46
74 Stashing Basics: Git Stash Save & Pop 03:44
75 Practicing With Git Stash 03:26
76 Git Stash Apply 04:11
77 Working With Multiple Stashes 06:42
78 Dropping & Clearing The Stash 02:13
79 Stashing Exercise 05:05
80 What Really Matters In This Section 02:10
81 Checking Out Old Commits 07:10
82 Re-Attaching Our Detached HEAD! 05:35
83 Referencing Commits Relative to HEAD 04:03
84 Discarding Changes With Git Checkout 05:17
85 Un-Modifying With Git Restore 06:06
86 Un-Staging Changes With Git Restore 04:04
87 Undoing Commits With Git Reset 07:46
88 Reverting Commits With...Git Revert 06:27
89 Undoing Changes Exercise 10:06
90 What Really Matters In This Section 01:40
91 What Does Github Do For Us? 06:24
92 Why You Should Use Github! 04:37
93 Cloning Github Repos With Git Clone 08:15
94 Cloning Non-Github Repos 02:56
95 Github Setup: SSH Config 07:32
96 Creating Our First Github Repo! 06:03
97 A Crash Course on Git Remotes 07:05
98 Introducing Git Push 08:49
99 Touring A Github Repo 03:42
100 Practice With Git Push 04:00
101 Another Github Workflow: Cloning First 04:21
102 Main & Master: Github Default Branches 06:11
103 Github Basics Exercise 10:26
104 What Really Matters In This Section 01:21
105 Remote Tracking Branches: WTF Are They? 06:00
106 Checking Out Remote Tracking Branches 07:20
107 Working With Remote Branches 09:34
108 Git Fetch: The Basics 05:47
109 Demonstrating Git Fetch 09:27
110 Git Pull: The Basics 04:14
111 Git Pull & Merge Conflicts 05:13
112 A Shorter Syntax For Git Pull? 05:09
113 What Really Matters In This Section 02:31
114 Github Repo Visibility: Public Vs. Private 05:38
115 Adding Github Collaborators 04:04
116 Github Collaboration Demo 07:17
117 What are READMEs? 04:29
118 A Markdown Crash Course 09:48
119 Adding a README To A Project 04:42
120 Creating Github Gists 05:57
121 Introducing Github Pages 05:04
122 Github Pages Demo 09:57
123 What Really Matters In This Section 02:32
124 The Pitfalls Of A Centralized Workflow 07:42
125 Centralized Workflow Demonstration 11:37
126 The All-Important Feature Branch Workflow 07:13
127 Feature Branch Workflow Demo 13:14
128 Merging Feature Branches 04:34
129 Introducing Pull Requests 09:07
130 Making Our First Pull Request 06:26
131 Merging Pull Requests With Conflicts 11:34
132 Configuring Branch Protection Rules 06:22
133 Introducing Forking 03:29
134 Forking Demonstration 05:30
135 The Fork & Clone Workflow 06:31
136 Fork & Clone Workflow Demonstration 11:21
137 What Really Matters In This Section 01:33
138 Why is Rebasing Scary? Is it? 02:37
139 Comparing Merging & Rebasing 07:13
140 Rebase Demo Pt 1: Setup & Merging 07:15
141 Rebasing Demo Pt 2: Actually Rebasing 09:24
142 The Golden Rule: When NOT to Rebase 05:09
143 Handling Conflicts & Rebasing 06:28
144 What Really Matters In This Section 01:09
145 Introducing Interactive Rebase 03:14
146 Rewording Commits With Interactive Rebase 10:45
147 Fixing Up & Squashing Commits With Interactive Rebase 07:18
148 Dropping Commits With Interactive Rebase 03:28
149 What Really Matters In This Section 01:42
150 The Idea Behind Git Tags 03:42
151 A Side Note On Semantic Versioning 06:59
152 Viewing & Searching Tags 06:24
153 Comparing Tags With Git Diff 04:23
154 Creating Lightweight Tags 03:57
155 Creating Annotated Tags 03:36
156 Tagging Previous Commits 01:36
157 Replacing Tags With Force 01:34
158 Deleting Tags 00:52
159 IMPORTANT: Pushing Tags 03:41
160 What Really Matters In This Section 02:02
161 Working With The Local Config File 09:56
162 Inside Git: The Refs Directory 06:58
163 Inside Git: The HEAD file 02:25
164 Inside Git: The Objects Directory 02:52
165 A Crash Course On Hashing Functions 07:02
166 Git As A Key-Value Datastore 03:53
167 Hashing With Git Hash-Object 08:43
168 Retrieving Data With Git Cat-File 08:52
169 Deep Dive Into Git Objects: Blobs 03:09
170 Deep Dive Into Git Objects: Trees 08:58
171 Deep Dive Into Git Objects: Commits 14:06
172 What Really Matters In This Section 01:35
173 Introducing Reflogs 06:25
174 The Limitations of Reflogs 01:19
175 The Git Reflog Show Command 07:06
176 Passing Reflog References Around 04:51
177 Time-Based Reflog Qualifiers 05:28
178 Rescuing Lost Commits With Reflog 07:09
179 Undoing A Rebase w/ Reflog - It's A Miracle! 09:45
180 What Matters In This Section 01:06
181 The Global Git Config File 04:25
182 Writing Our First Git Alias 03:13
183 Setting Aliases From The Command Line 01:35
184 Aliases With Arguments 04:20
185 Exploring Existing Useful Aliases Online 05:36

Similar courses to The Git & Github Bootcamp

Git & GitHub Full Course

Git & GitHub Full Coursefireship.io

Duration 1 hour 38 seconds
The Ultimate Git Course

The Ultimate Git Coursecodewithmosh (Mosh Hamedani)

Duration 5 hours 11 minutes 52 seconds
Git From Start to Finish

Git From Start to Finishiamtimcorey.com (Tim Corey)

Duration 6 hours 1 minute 52 seconds