Skip to main content
CF

The Git & Github Bootcamp

16h 54m 2s
English
Paid

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

About the Author: Udemy

Udemy thumbnail

Udemy is the largest open marketplace for online courses on the internet. Founded in 2010 by Eren Bali, Oktay Caglar, and Gagan Biyani and headquartered in San Francisco, the company went public on the Nasdaq in 2021 under the ticker UDMY. The platform hosts well over two hundred thousand courses across software development, IT and cloud, data science, design, business, marketing, and creative skills, taught by tens of thousands of independent instructors. Roughly seventy million learners use it worldwide, and the corporate arm — Udemy Business — supplies a curated subset of that catalog to enterprise customers.

Because Udemy is a marketplace rather than a single editorial publisher, the catalog is uneven by design. The strongest material lives in the long-form, project-based courses authored by working engineers — full-stack JavaScript, React, Node.js, Python data science, AWS, Docker and Kubernetes, mobile development with Flutter and React Native, and cloud certification preparation. The CourseFlix listing under this source is the slice of that catalog that has been mirrored here for offline-friendly viewing, organized by topic and updated as new releases land. Pricing on Udemy itself swings dramatically with the site's near-permanent sales, which is why the platform is best treated as a deep reference catalog: pick instructors with strong reviews and a track record of updating their material rather than buying on the headline price alone.

Watch Online 185 lessons

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 185 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: Welcome To The Course!
All Course Lessons (185)
#Lesson TitleDurationAccess
1
Welcome To The Course! Demo
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
Unlock unlimited learning

Get instant access to all 184 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

Related courses

  • The Ultimate Git Course thumbnailUpdated 2y ago

    The Ultimate Git Course

    By: Mosh Hamedani (Code with Mosh)
    Git is the most popular Version Control System (VCS) in the world. It helps you track your project history, revert back your code in case of mistakes, and work
    5h 11m
  • Wizard zines. Zine 14 pack thumbnailUpdated 2y ago

    Wizard zines. Zine 14 pack

    By: Julia Evans
    Wizard zines is a little different from other tech publications. Here’s my approach: stick to fundamentals: wizard zines focuses on fundamentals: things.
  • Introduction to SVN thumbnailUpdated 3y ago

    Introduction to SVN

    By: Pluralsight
    Take your skills to the next level with courses on the most popular programming languages, developer tools, software practices and application development platf
    2h 56m

Frequently asked questions

What are the prerequisites for enrolling in this course?
There are no specific prerequisites mentioned for The Git & Github Bootcamp. The course includes a terminal crash course which covers basic navigation and file manipulation commands, suggesting it is suitable for beginners with no prior experience in command-line interfaces or version control systems.
What will I be able to build or accomplish by the end of the course?
By the end of the course, students will be capable of setting up and managing Git repositories, performing essential version control tasks such as staging and committing changes, and handling branching and merging processes, including resolving merge conflicts using tools like VSCode. The focus is on practical usage of Git and GitHub for real-world applications.
Who is the target audience for this course?
This course is designed for individuals working in any code-related field, such as data science, game development, or machine learning, who need to learn Git and GitHub for version control. It is also suitable for beginners who are new to version control systems and want to integrate Git into their workflow.
How does this course compare in depth and scope to similar courses?
The Git & Github Bootcamp offers a comprehensive introduction to Git and GitHub, covering everything from installation to advanced topics like branching, merging, and conflict resolution. With 185 lessons, it provides extensive coverage of both command-line and GUI tools, making it suitable for learners seeking an in-depth understanding of version control.
What specific tools or platforms will I learn to use?
Students will learn to use Git, a version control system, and GitHub, a platform for hosting and collaborating on Git repositories. The course also covers the use of GitKraken, a GUI for Git, and Visual Studio Code for resolving merge conflicts, providing a mix of command-line and graphical interface tools.
Are there any topics not covered in this course that I should be aware of?
The course provides a detailed introduction to Git and GitHub but does not cover advanced Git topics such as rebase, bisect, or advanced GitHub features like Actions or Pages. Students interested in these topics might need to seek additional resources after completing the course.
How much time should I expect to invest in this course?
While the total runtime of the course is not specified, with 185 lessons, students should be prepared to invest a significant amount of time to thoroughly engage with the material, complete exercises, and practice using Git and GitHub tools. The time commitment will vary depending on individual learning pace and prior experience.