Complete Git Guide: Understand and master Git and GitHub

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

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 Complete Git Guide: Understand and master Git and GitHub

Join premium to watch
Go to premium
# Title Duration
1 Section 1 Introduction 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

Similar courses to Complete Git Guide: Understand and master Git and GitHub

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
The Git & Github Bootcamp

The Git & Github Bootcampudemy

Duration 16 hours 54 minutes 2 seconds
Git & GitHub Full Course

Git & GitHub Full Coursefireship.io

Duration 1 hour 38 seconds
Wizard zines. Zine 14 pack