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