Complete Git Guide: Understand and master Git and GitHub

19h 21m 2s
English
Paid

Course description

Complete Git and GitHub guide. Master basic and advanced Git features: commits, branches, merging, rebasing, squashing.
Read more about the course

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.

Watch Online

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

Watch Online Complete Git Guide: Understand and master Git and GitHub

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

Comments

0 comments

Want to join the conversation?

Sign in to comment

Similar courses

The Git & Github Bootcamp

The Git & Github Bootcamp

Sources: udemy
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 an...
16 hours 54 minutes 2 seconds
Wizard zines. Zine 14 pack

Wizard zines. Zine 14 pack

Sources: 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 that...
Git From Start to Finish

Git From Start to Finish

Sources: iamtimcorey.com (Tim Corey)
Git is the world's most popular Version Control System, but a lot of developers don't know how to use it. You need to understand Git to be a software developer. When you do, you...
6 hours 1 minute 52 seconds