CourseFlix

Complete Git Guide: Understand and master Git and GitHub

19h 21m 2s
English
Paid
Complete Git and GitHub guide. Master basic and advanced Git features: commits, branches, merging, rebasing, squashing.

This course is all about Git and GitHub.

Understand HOW Git works and learn all Git features from basic commits to squashing and rebasing.

  • Blobs, Trees, Annotated tags, SHA1 hashes

If those terms are new to you - jump in and you will learn all about Git internals and afterwards practice basic and advanced Git features using multiple practice activities.

Become a master of Git, GitHub, GitHub Desktop, SourceTree and Visual Studio Code.


This is the most complete practical Git and GitHub guide here on Udemy that includes tons of practical activities. Most important is that you will learn how Git works and knowing it you will be able much more easier use Git features and fix mistakes in your development workflow. You can have zero knowledge about Git and GitHub. All will be taught from scratch, from basic to advanced features. If you want to get deep knowledge of Git and GitHub this course is for you!


We will start by exploring internal structure of the Git repository. You will learn that Git has 4 types of objects: blobs, trees, commits and annotated tags. Each object has unique SHA1 hash. Also all objects are stored in the folders. Every object has just single reference to it - SHA1 hash. Files are stored in blobs. Filenames are stored in other Git objects called trees.

I will explain you how to create new Git objects without using git commit and git add. After creating Git object in the Git repository you will checkout it to staging area and working directory (opposite direction to traditional Git flow)

Afterwards we will jump into tons of practice activities and use different Git and GitHub features

In practice sections you will perform multiple practice Git activities:

  1. Initialize new Git repository

  2. Make changes, add them to staging area and commit

  3. Create branches, checkout branches and merge branches

  4. Perform fast-forward and 3-way merges of the branches

  5. Resolve merge conflicts

  6. Move into detached HEAD state and make experimental commits there

  7. Perform rebasing of the branches

You will also learn and practice different GitHub features

  1. Connect local and remote repositories

  2. Pushing, fetching and pulling operations

  3. Open Pull Request

  4. Merge Pull Request

  5. Add software versions using Git Tags

  6. Create forks from other repositories

  7. Contribute to public repositories using technique of forks and pull requests

  8. Perform rebasing with squashing

You will use not just terminal and shell commands for performing Git operations. In parallel you will also use GUI applications that simplify routine day-by-day Git operations:

  • GitHub Desktop

  • SourceTree

  • VisualStudio Code

Requirements:
  • We will start from the very beginning, from basic Git features and move on to advanced techniques and operations
  • Prepare only your Mac, Windows or Linux/Unix computer. Anything will work.
  • If you are new to Git, please start from the very beginning: learn how Git works and how to perform basic operations (git add, git commit, git branch)
  • If you are advanced Git user I highly recommend you to watch "How Git works under the hood" section and then jump to advanced Git features like squashing, cherry-picking etc.
  • Complete Git and GitHub guide. Master basic and advanced Git features: commits, branches, merging, rebasing, squashing.


Who this course is for:
  • You could be either complete beginner or experienced developer with years of usage of Git
  • You may know how to USE Git but you may not know HOW Git works
  • If you want to learn HOW and WHY Git and GitHub work - this course is for you!

What you'll learn:

  • Deeply understand how Git works under the hood
  • Use Git not just in terminal but also in graphical user interfaces like GitHub Desktop, SourceTree, Visual Studio Code
  • Learn different GIt objects - blobs, trees, commits and annotated tags
  • Create local and remote Git repositories
  • Perform basic and advanced Git operations
  • Learn how to perform rebasing and merging of the branches
  • Learn what is pull request and how to create pull request at GitHub
  • Contribute to public repositories using technique of forks and pull requests from the forked repository
  • Understand what is semantic versioning and how to use Git Tags in order to create software release versions
  • Learn advanced Git operations - squashing, cherry-picking, amending, reverting commits.

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 224 lessons

This is a demo lesson (10:00 remaining)

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

View Pricing
0:00
/
#1: Section 1 Introduction
All Course Lessons (224)
#Lesson TitleDurationAccess
1
Section 1 Introduction Demo
01:29
2
Git vs GitHub
05:31
3
Section 2 Introduction
00:43
4
Installing Git on MacOS
02:25
5
Installing Git on Windows
10:42
6
Installing Git on Linux
08:21
7
Installing iTerm2 on the Mac
05:37
8
Installing custom shell Z-Shell on the Mac
05:33
9
Section 3 Introduction
00:44
10
Shell commands - directory management
09:39
11
Shell commands - file management - PART 1
09:00
12
Shell commands - file management - PART 2
08:26
13
Section 4 Introduction
00:58
14
Initialize new Git repository
04:13
15
Overview of .git folder
04:02
16
Git object types
03:03
17
Writing new Git object with git hash-object
06:46
18
JSON vs Git database
03:58
19
What is hash function
03:53
20
Hash functions overview
03:30
21
SHA1 Hash Function
10:19
22
How many files Git could store
04:10
23
Probability theory in Dice game
04:12
24
Git hash collision probability
05:57
25
More details on hash collision probability
27:14
26
Exploring Git objects with git cat-file command
05:25
27
Create new Git Blob based on the file
07:57
28
Git blobs don't store filenames
02:41
29
Contents of Git objects
10:15
30
What we have so far
01:57
31
Tree objects in Git
02:42
32
Git object permissions
02:26
33
Creating Git Tree object
09:53
34
Examining Tree Object
04:53
35
Working directory, Staging area and Git repository
01:56
36
Overview of current files distribution
03:51
37
Git read-tree
03:52
38
Read files in the staging area using git ls-files
01:59
39
Git checkout-index
03:12
40
How many folders could be created for objects
02:21
41
Section Summary
04:21
42
Section 5 Introduction
00:54
43
What is Commit
04:00
44
Configure Git author name and email
04:01
45
Creating first commit
05:37
46
Exploring commit object
05:09
47
Current project state overview
03:35
48
Basic Git commands
05:44
49
Adding new file to working directory
08:38
50
Git files lifecycle
02:00
51
Stage file
02:58
52
Unstage file using git rm
02:08
53
Commit changes
07:54
54
Exploring changes in Git repository
06:16
55
Current diagram of Git repository
03:51
56
Section 6 Introduction
01:13
57
Most common Git operations
06:18
58
Overview of the current project state
01:24
59
Installing GitHub Desktop
03:37
60
GitHub Desktop Overview
04:59
61
What is branch in Git
06:45
62
What is HEAD in Git
05:32
63
Third commit
05:23
64
Git repository changes after third commit
07:13
65
Checkout specific commit
13:50
66
Why do we need branches
10:37
67
Git branches management
03:05
68
Create new branch
07:21
69
Commit changes in the new branch
04:36
70
Explore commit in the new branch
05:32
71
Git reuses blobs with the same contents
07:35
72
Section 7 Introduction
00:56
73
Cloning remote repository
06:02
74
Exploring contents of the cloned repository
07:53
75
Unpacking Git objects
04:07
76
Exploring cloned repository in GitHub Desktop
05:19
77
Installing text editor Visual Studio Code
02:46
78
Exploring Visual Studio Code
06:06
79
Commit changes in the cloned repository
11:35
80
Git diff command
13:57
81
Overview of the changes
03:44
82
Section 8 Introduction
01:15
83
Why branches merging is needed
03:28
84
Fast forward merge
04:16
85
Merging process
01:54
86
Fast forward merge in action
06:58
87
3-way merge
06:00
88
Performing 3-way merge
12:39
89
Observing Git repository after 3-way merge
06:41
90
Installing SourceTree
04:01
91
SourceTree in action
06:35
92
What is merge conflict
03:06
93
Creating merge conflict
09:49
94
Observing conflicts in staging area and working directory
06:45
95
Resolving merge conflict in Terminal
03:01
96
Resolving conflicts in VS Code
09:01
97
Section 9 Introduction
00:56
98
What is Git hosting service
03:36
99
Creating GitHub account
03:33
100
Exploring first repository at GitHub
11:01
101
Creating another commit at GitHub
02:57
102
Creating new branch at GitHub
01:26
103
Making changes in the new branch
04:23
104
Cloning remote repository
05:15
105
What is remote repository
02:56
106
How remote repository empowers collaboration
04:04
107
Section 10 Introduction
01:36
108
Overview of the push, fetch and pull Git commands
06:16
109
What is origin
04:18
110
List remote and local branches
03:05
111
What is tracking branch
05:00
112
Checkout remote branch
03:56
113
Git remote show origin
03:09
114
Git fetch in action
06:23
115
Git pull is 2-step process
03:55
116
How to perform git pull
05:09
117
What is FETCH_HEAD
08:25
118
Git pull with fast forward merge
07:38
119
Fetch remote changes manually
09:10
120
Merge FETCH_HEAD manually
06:06
121
Resolving conflicts during Git pull
11:59
122
Pushing to remote repository
09:28
123
Commit under another author
02:43
124
Remote and local branches are in sync now
03:35
125
Create remote branch based on local branch
08:53
126
Update tracking statuses of the branches
08:00
127
Remove remote branch using local terminal
03:53
128
Git show-ref
04:25
129
Section 11 Introduction
01:04
130
Collaboration between contributors
04:30
131
What is pull request?
02:36
132
Why pull request was named pull request
06:12
133
Pull request or Merge request
04:56
134
Pull request step-by-step
07:50
135
Create new repository at GitHub
06:54
136
Changing author of the last commit
02:33
137
Pushing branch to remote
05:01
138
Open pull request
07:31
139
Adding comments and approving pull request
09:25
140
Creating and publishing new branch using GitHub Desktop
05:30
141
Signing in to GitHub in the GitHub Desktop
01:25
142
Creating and merging pull request
09:14
143
Adding new collaborator under GitHub
03:56
144
Exploring own GitHub account
04:50
145
Opening and merging PR by collaborator
06:37
146
By default merging is allowed without approvals
02:24
147
Configure protected branch rule
04:19
148
Merging after required approve
02:57
149
Exploring pull requests in the public repositories
05:59
150
Working with issues at GitHub
11:31
151
Section 12 Introduction
00:51
152
Creating Fork
04:47
153
How to sync changes from the parent repository
05:14
154
Adding new upstream remote repository
02:05
155
Fetching changes from upstream
02:27
156
Synchronizing changes from upstream
10:56
157
How to open pull request from the forked repository
02:33
158
Plan for creating pull request from the forked repository
02:00
159
Removing repository collaborator
02:08
160
Forking repository
03:01
161
Committing changes in the forked repository
03:18
162
Open pull request from the forked repository
04:32
163
Approving and merging pull request from the forked repository
11:44
164
Section 13 Introduction
00:55
165
Git tags overview
03:17
166
Staging vs Production
06:53
167
Semantic versioning
11:09
168
Lightweight vs Annotated tags
04:24
169
Creating lightweight tags
09:33
170
Creating annotated tag
02:51
171
Exploring git tag object
03:05
172
Pushing tags to remote
10:20
173
Section 14 Introduction
01:27
174
Introduction to Rebasing
01:34
175
Merging vs Rebasing
05:14
176
How to perform rebasing
01:57
177
Rebasing - STEP 1
02:49
178
Rebasing - STEP 2
02:40
179
Creating new repository
02:16
180
Creating feature branch and making changes
04:51
181
Rebasing feature branch on top of master branch
03:06
182
Completing rebasing by performing merging
01:56
183
Exploring graph and commits in SourceTree
05:10
184
Deleteing feature branch and pushing to remote
01:39
185
Section 15 Introduction
01:12
186
Introduction go Git ignore
02:19
187
Git file statuses - untracked, tracked and ignored
02:08
188
Basic gitignore rules
08:02
189
Pushing repository with ignored files to remote
02:37
190
Committing previously ignored file
02:54
191
Ignore previously committed file
04:09
192
Git ignore common practices and templates
05:32
193
Section 16 Introduction
01:24
194
Detached HEAD state
04:23
195
Making experimental commits in detached HEAD state
08:28
196
Retaining changes made in the detached HEAD state
08:04
197
Section 17 Introduction
00:51
198
Cloning one of the public repositories
03:14
199
Git log options - oneline, graph, stat
05:42
200
Git shortlog
01:44
201
Filtering commits by author or keyword
02:52
202
Pretty formatting of git log
03:07
203
Filter out merge commits in git log
03:05
204
Git reset
10:18
205
Git revert
08:33
206
Modifying last commit using amend option
03:52
207
Cherry-picking commits
05:53
208
Reflog - log of all Git operations
07:13
209
Stashing changes using terminal
05:26
210
Stashing using GitHub Desktop
02:25
211
Garbage collection
03:20
212
Squashing of commits at GitHub
07:59
213
Interactive rebasing with squashing in the local repository
07:40
214
Git development workflow
06:20
215
Section 18 Introduction
01:33
216
Creating simple website using GitHub Pages
04:22
217
Hosting any Repository using GitHub Pages
08:27
218
Creating basic React application
09:50
219
Preparing React application for publish to the GitHub Pages
08:43
220
Fixing error with cached credentials by using SSH instead of HTTPS
10:43
221
Verifying React GitHub Page
07:27
222
Configuring custom domain for GitHub Pages
10:58
223
Creating static GitHub Page using markdown
04:59
224
Wrap Up
00:24
Unlock unlimited learning

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

Learn more about subscription

Course content

224 lessons · 19h 21m 2s
Show all 224 lessons
  1. 1 Section 1 Introduction 01:29
  2. 2 Git vs GitHub 05:31
  3. 3 Section 2 Introduction 00:43
  4. 4 Installing Git on MacOS 02:25
  5. 5 Installing Git on Windows 10:42
  6. 6 Installing Git on Linux 08:21
  7. 7 Installing iTerm2 on the Mac 05:37
  8. 8 Installing custom shell Z-Shell on the Mac 05:33
  9. 9 Section 3 Introduction 00:44
  10. 10 Shell commands - directory management 09:39
  11. 11 Shell commands - file management - PART 1 09:00
  12. 12 Shell commands - file management - PART 2 08:26
  13. 13 Section 4 Introduction 00:58
  14. 14 Initialize new Git repository 04:13
  15. 15 Overview of .git folder 04:02
  16. 16 Git object types 03:03
  17. 17 Writing new Git object with git hash-object 06:46
  18. 18 JSON vs Git database 03:58
  19. 19 What is hash function 03:53
  20. 20 Hash functions overview 03:30
  21. 21 SHA1 Hash Function 10:19
  22. 22 How many files Git could store 04:10
  23. 23 Probability theory in Dice game 04:12
  24. 24 Git hash collision probability 05:57
  25. 25 More details on hash collision probability 27:14
  26. 26 Exploring Git objects with git cat-file command 05:25
  27. 27 Create new Git Blob based on the file 07:57
  28. 28 Git blobs don't store filenames 02:41
  29. 29 Contents of Git objects 10:15
  30. 30 What we have so far 01:57
  31. 31 Tree objects in Git 02:42
  32. 32 Git object permissions 02:26
  33. 33 Creating Git Tree object 09:53
  34. 34 Examining Tree Object 04:53
  35. 35 Working directory, Staging area and Git repository 01:56
  36. 36 Overview of current files distribution 03:51
  37. 37 Git read-tree 03:52
  38. 38 Read files in the staging area using git ls-files 01:59
  39. 39 Git checkout-index 03:12
  40. 40 How many folders could be created for objects 02:21
  41. 41 Section Summary 04:21
  42. 42 Section 5 Introduction 00:54
  43. 43 What is Commit 04:00
  44. 44 Configure Git author name and email 04:01
  45. 45 Creating first commit 05:37
  46. 46 Exploring commit object 05:09
  47. 47 Current project state overview 03:35
  48. 48 Basic Git commands 05:44
  49. 49 Adding new file to working directory 08:38
  50. 50 Git files lifecycle 02:00
  51. 51 Stage file 02:58
  52. 52 Unstage file using git rm 02:08
  53. 53 Commit changes 07:54
  54. 54 Exploring changes in Git repository 06:16
  55. 55 Current diagram of Git repository 03:51
  56. 56 Section 6 Introduction 01:13
  57. 57 Most common Git operations 06:18
  58. 58 Overview of the current project state 01:24
  59. 59 Installing GitHub Desktop 03:37
  60. 60 GitHub Desktop Overview 04:59
  61. 61 What is branch in Git 06:45
  62. 62 What is HEAD in Git 05:32
  63. 63 Third commit 05:23
  64. 64 Git repository changes after third commit 07:13
  65. 65 Checkout specific commit 13:50
  66. 66 Why do we need branches 10:37
  67. 67 Git branches management 03:05
  68. 68 Create new branch 07:21
  69. 69 Commit changes in the new branch 04:36
  70. 70 Explore commit in the new branch 05:32
  71. 71 Git reuses blobs with the same contents 07:35
  72. 72 Section 7 Introduction 00:56
  73. 73 Cloning remote repository 06:02
  74. 74 Exploring contents of the cloned repository 07:53
  75. 75 Unpacking Git objects 04:07
  76. 76 Exploring cloned repository in GitHub Desktop 05:19
  77. 77 Installing text editor Visual Studio Code 02:46
  78. 78 Exploring Visual Studio Code 06:06
  79. 79 Commit changes in the cloned repository 11:35
  80. 80 Git diff command 13:57
  81. 81 Overview of the changes 03:44
  82. 82 Section 8 Introduction 01:15
  83. 83 Why branches merging is needed 03:28
  84. 84 Fast forward merge 04:16
  85. 85 Merging process 01:54
  86. 86 Fast forward merge in action 06:58
  87. 87 3-way merge 06:00
  88. 88 Performing 3-way merge 12:39
  89. 89 Observing Git repository after 3-way merge 06:41
  90. 90 Installing SourceTree 04:01
  91. 91 SourceTree in action 06:35
  92. 92 What is merge conflict 03:06
  93. 93 Creating merge conflict 09:49
  94. 94 Observing conflicts in staging area and working directory 06:45
  95. 95 Resolving merge conflict in Terminal 03:01
  96. 96 Resolving conflicts in VS Code 09:01
  97. 97 Section 9 Introduction 00:56
  98. 98 What is Git hosting service 03:36
  99. 99 Creating GitHub account 03:33
  100. 100 Exploring first repository at GitHub 11:01
  101. 101 Creating another commit at GitHub 02:57
  102. 102 Creating new branch at GitHub 01:26
  103. 103 Making changes in the new branch 04:23
  104. 104 Cloning remote repository 05:15
  105. 105 What is remote repository 02:56
  106. 106 How remote repository empowers collaboration 04:04
  107. 107 Section 10 Introduction 01:36
  108. 108 Overview of the push, fetch and pull Git commands 06:16
  109. 109 What is origin 04:18
  110. 110 List remote and local branches 03:05
  111. 111 What is tracking branch 05:00
  112. 112 Checkout remote branch 03:56
  113. 113 Git remote show origin 03:09
  114. 114 Git fetch in action 06:23
  115. 115 Git pull is 2-step process 03:55
  116. 116 How to perform git pull 05:09
  117. 117 What is FETCH_HEAD 08:25
  118. 118 Git pull with fast forward merge 07:38
  119. 119 Fetch remote changes manually 09:10
  120. 120 Merge FETCH_HEAD manually 06:06
  121. 121 Resolving conflicts during Git pull 11:59
  122. 122 Pushing to remote repository 09:28
  123. 123 Commit under another author 02:43
  124. 124 Remote and local branches are in sync now 03:35
  125. 125 Create remote branch based on local branch 08:53
  126. 126 Update tracking statuses of the branches 08:00
  127. 127 Remove remote branch using local terminal 03:53
  128. 128 Git show-ref 04:25
  129. 129 Section 11 Introduction 01:04
  130. 130 Collaboration between contributors 04:30
  131. 131 What is pull request? 02:36
  132. 132 Why pull request was named pull request 06:12
  133. 133 Pull request or Merge request 04:56
  134. 134 Pull request step-by-step 07:50
  135. 135 Create new repository at GitHub 06:54
  136. 136 Changing author of the last commit 02:33
  137. 137 Pushing branch to remote 05:01
  138. 138 Open pull request 07:31
  139. 139 Adding comments and approving pull request 09:25
  140. 140 Creating and publishing new branch using GitHub Desktop 05:30
  141. 141 Signing in to GitHub in the GitHub Desktop 01:25
  142. 142 Creating and merging pull request 09:14
  143. 143 Adding new collaborator under GitHub 03:56
  144. 144 Exploring own GitHub account 04:50
  145. 145 Opening and merging PR by collaborator 06:37
  146. 146 By default merging is allowed without approvals 02:24
  147. 147 Configure protected branch rule 04:19
  148. 148 Merging after required approve 02:57
  149. 149 Exploring pull requests in the public repositories 05:59
  150. 150 Working with issues at GitHub 11:31
  151. 151 Section 12 Introduction 00:51
  152. 152 Creating Fork 04:47
  153. 153 How to sync changes from the parent repository 05:14
  154. 154 Adding new upstream remote repository 02:05
  155. 155 Fetching changes from upstream 02:27
  156. 156 Synchronizing changes from upstream 10:56
  157. 157 How to open pull request from the forked repository 02:33
  158. 158 Plan for creating pull request from the forked repository 02:00
  159. 159 Removing repository collaborator 02:08
  160. 160 Forking repository 03:01
  161. 161 Committing changes in the forked repository 03:18
  162. 162 Open pull request from the forked repository 04:32
  163. 163 Approving and merging pull request from the forked repository 11:44
  164. 164 Section 13 Introduction 00:55
  165. 165 Git tags overview 03:17
  166. 166 Staging vs Production 06:53
  167. 167 Semantic versioning 11:09
  168. 168 Lightweight vs Annotated tags 04:24
  169. 169 Creating lightweight tags 09:33
  170. 170 Creating annotated tag 02:51
  171. 171 Exploring git tag object 03:05
  172. 172 Pushing tags to remote 10:20
  173. 173 Section 14 Introduction 01:27
  174. 174 Introduction to Rebasing 01:34
  175. 175 Merging vs Rebasing 05:14
  176. 176 How to perform rebasing 01:57
  177. 177 Rebasing - STEP 1 02:49
  178. 178 Rebasing - STEP 2 02:40
  179. 179 Creating new repository 02:16
  180. 180 Creating feature branch and making changes 04:51
  181. 181 Rebasing feature branch on top of master branch 03:06
  182. 182 Completing rebasing by performing merging 01:56
  183. 183 Exploring graph and commits in SourceTree 05:10
  184. 184 Deleteing feature branch and pushing to remote 01:39
  185. 185 Section 15 Introduction 01:12
  186. 186 Introduction go Git ignore 02:19
  187. 187 Git file statuses - untracked, tracked and ignored 02:08
  188. 188 Basic gitignore rules 08:02
  189. 189 Pushing repository with ignored files to remote 02:37
  190. 190 Committing previously ignored file 02:54
  191. 191 Ignore previously committed file 04:09
  192. 192 Git ignore common practices and templates 05:32
  193. 193 Section 16 Introduction 01:24
  194. 194 Detached HEAD state 04:23
  195. 195 Making experimental commits in detached HEAD state 08:28
  196. 196 Retaining changes made in the detached HEAD state 08:04
  197. 197 Section 17 Introduction 00:51
  198. 198 Cloning one of the public repositories 03:14
  199. 199 Git log options - oneline, graph, stat 05:42
  200. 200 Git shortlog 01:44
  201. 201 Filtering commits by author or keyword 02:52
  202. 202 Pretty formatting of git log 03:07
  203. 203 Filter out merge commits in git log 03:05
  204. 204 Git reset 10:18
  205. 205 Git revert 08:33
  206. 206 Modifying last commit using amend option 03:52
  207. 207 Cherry-picking commits 05:53
  208. 208 Reflog - log of all Git operations 07:13
  209. 209 Stashing changes using terminal 05:26
  210. 210 Stashing using GitHub Desktop 02:25
  211. 211 Garbage collection 03:20
  212. 212 Squashing of commits at GitHub 07:59
  213. 213 Interactive rebasing with squashing in the local repository 07:40
  214. 214 Git development workflow 06:20
  215. 215 Section 18 Introduction 01:33
  216. 216 Creating simple website using GitHub Pages 04:22
  217. 217 Hosting any Repository using GitHub Pages 08:27
  218. 218 Creating basic React application 09:50
  219. 219 Preparing React application for publish to the GitHub Pages 08:43
  220. 220 Fixing error with cached credentials by using SSH instead of HTTPS 10:43
  221. 221 Verifying React GitHub Page 07:27
  222. 222 Configuring custom domain for GitHub Pages 10:58
  223. 223 Creating static GitHub Page using markdown 04:59
  224. 224 Wrap Up 00:24

Related courses

  • Master Git & GitHub thumbnail

    Master Git & GitHub

    By: Beto Moedano
    Master Git & GitHub is a practical course that will teach you to work confidently with the Git version control system and the GitHub platform. The course is str
    2 hours 57 minutes 15 seconds
  • The Ultimate Git Course thumbnail

    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
    5 hours 11 minutes 52 seconds
  • Introduction to SVN thumbnail

    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
    2 hours 56 minutes 46 seconds

Frequently asked questions

What is Complete Git Guide: Understand and master Git and GitHub about?
Complete Git and GitHub guide. Master basic and advanced Git features: commits, branches, merging, rebasing, squashing.
Who teaches Complete Git Guide: Understand and master Git and GitHub?
Complete Git Guide: Understand and master Git and GitHub is taught by Udemy. You can find more courses by this instructor on the corresponding source page.
How long is Complete Git Guide: Understand and master Git and GitHub?
Complete Git Guide: Understand and master Git and GitHub contains 224 lessons with a total runtime of 19 hours 21 minutes. All lessons are available to watch online at your own pace.
Is Complete Git Guide: Understand and master Git and GitHub free to watch?
Complete Git Guide: Understand and master Git and GitHub is part of CourseFlix's premium catalog. A CourseFlix subscription unlocks the full video player; the course description, table of contents, and preview information are available to everyone.
Where can I watch Complete Git Guide: Understand and master Git and GitHub online?
Complete Git Guide: Understand and master Git and GitHub is available to watch online on CourseFlix at https://courseflix.net/course/complete-git-guide-understand-and-master-git-and-github. The page hosts every lesson with the integrated video player; no download is required.