Complete Git Guide: Understand and master Git and GitHub

Complete Git Guide: Understand and master Git and GitHub
Complete Git Guide: Understand and master Git and GitHub
English | MP4 | AVC 1280×720 | AAC 48KHz 2ch | 19.5 Hours | 8.32 GB

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:

  • Initialize new Git repository
  • Make changes, add them to staging area and commit
  • Create branches, checkout branches and merge branches
  • Perform fast-forward and 3-way merges of the branches
  • Resolve merge conflicts
  • Move into detached HEAD state and make experimental commits there
  • Perform rebasing of the branches

You will also learn and practice different GitHub features

  • Connect local and remote repositories
  • Pushing, fetching and pulling operations
  • Open Pull Request
  • Merge Pull Request
  • Add software versions using Git Tags
  • Create forks from other repositories
  • Contribute to public repositories using technique of forks and pull requests
  • 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

With this course you will get lifetime-long access to almost 200 lectures and tens of practical exercises. After the course you will become a guru of Git and GitHub and will be able easily perform basic and advanced Git tasks.

But most important is that you will UNDERSTAND Git.

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.
Table of Contents

Introduction to the Git and GitHub
1 Section 1 Introduction
2 Git vs GitHub

Installation of the Git and configuration of the Shell
3 Section 2 Introduction
4 Installing Git on MacOS
5 Installing Git on Windows
6 Installing Git on Linux
7 Installing iTerm2 on the Mac
8 Installing custom shell Z-Shell on the Mac

Basic Shell commands
9 Section 3 Introduction
10 Shell commands – directory management
11 Shell commands – file management – PART 1
12 Shell commands – file management – PART 2

How Git works under the hood
13 Section 4 Introduction
14 How many files Git could store
15 Probability theory in Dice game
16 Git hash collision probability
17 More details on hash collision probability
18 Exploring Git objects with git cat-file command
19 Create new Git Blob based on the file
20 Git blobs don’t store filenames
21 Contents of Git objects
22 What we have so far
23 Tree objects in Git
24 Initialize new Git repository
25 Git object permissions
26 Creating Git Tree object
27 Examining Tree Object
28 Working directory, Staging area and Git repository
29 Overview of current files distribution
30 Git read-tree
31 Read files in the staging area using git ls-files
32 Git checkout-index
33 How many folders could be created for objects
34 Section Summary
35 Overview of .git folder
36 Git object types
37 Writing new Git object with git hash-object
38 JSON vs Git database
39 What is hash function
40 Hash functions overview
41 SHA1 Hash Function

Basic Git operations
42 Section 5 Introduction
43 Stage file
44 Unstage file using git rm
45 Commit changes
46 Exploring changes in Git repository
47 Current diagram of Git repository
48 What is Commit
49 Configure Git author name and email
50 Creating first commit
51 Exploring commit object
52 Current project state overview
53 Basic Git commands
54 Adding new file to working directory
55 Git files lifecycle

Git branches and HEAD
56 Section 6 Introduction
57 Checkout specific commit
58 Why do we need branches
59 Git branches management
60 Create new branch
61 Commit changes in the new branch
62 Explore commit in the new branch
63 Git reuses blobs with the same contents
64 Most common Git operations
65 Overview of the current project state
66 Installing GitHub Desktop
67 GitHub Desktop Overview
68 What is branch in Git
69 What is HEAD in Git
70 Third commit
71 Git repository changes after third commit

Cloning, exploring and modifying public repositories
72 Section 7 Introduction
73 Overview of the changes
74 Cloning remote repository
75 Exploring contents of the cloned repository
76 Unpacking Git objects
77 Exploring cloned repository in GitHub Desktop
78 Installing text editor Visual Studio Code
79 Exploring Visual Studio Code
80 Commit changes in the cloned repository
81 Git diff command

Merging branches
82 Section 8 Introduction
83 SourceTree in action
84 What is merge conflict
85 Creating merge conflict
86 Observing conflicts in staging area and working directory
87 Resolving merge conflict in Terminal
88 Resolving conflicts in VS Code
89 Why branches merging is needed
90 Fast forward merge
91 Merging process
92 Fast forward merge in action
93 way merge
94 Performing 3-way merge
95 Observing Git repository after 3-way merge
96 Installing SourceTree

GitHub and remote repositories
97 Section 9 Introduction
98 How remote repository empowers collaboration
99 What is Git hosting service
100 Creating GitHub account
101 Exploring first repository at GitHub
102 Creating another commit at GitHub
103 Creating new branch at GitHub
104 Making changes in the new branch
105 Cloning remote repository
106 What is remote repository

Git push, fetch and pull
107 Section 10 Introduction
108 How to perform git pull
109 What is FETCH HEAD
110 Git pull with fast forward merge
111 Fetch remote changes manually
112 Merge FETCH HEAD manually
113 Resolving conflicts during Git pull
114 Pushing to remote repository
115 Commit under another author
116 Remote and local branches are in sync now
117 Create remote branch based on local branch
118 Overview of the push, fetch and pull Git commands
119 Update tracking statuses of the branches
120 Remove remote branch using local terminal
121 Git show-ref
122 What is origin
123 List remote and local branches
124 What is tracking branch
125 Checkout remote branch
126 Git remote show origin
127 Git fetch in action
128 Git pull is 2-step process

Pull requests
129 Section 11 Introduction
130 Open pull request
131 Adding comments and approving pull request
132 Creating and publishing new branch using GitHub Desktop
133 Signing in to GitHub in the GitHub Desktop
134 Creating and merging pull request
135 Adding new collaborator under GitHub
136 Exploring own GitHub account
137 Opening and merging PR by collaborator
138 By default merging is allowed without approvals
139 Configure protected branch rule
140 Collaboration between contributors
141 Merging after required approve
142 Exploring pull requests in the public repositories
143 Working with issues at GitHub
144 What is pull request
145 Why pull request was named pull request
146 Pull request or Merge request
147 Pull request step-by-step
148 Create new repository at GitHub
149 Changing author of the last commit
150 Pushing branch to remote

Forks and contribution to the public repositories
151 Section 12 Introduction
152 Forking repository
153 Committing changes in the forked repository
154 Open pull request from the forked repository
155 Approving and merging pull request from the forked repository
156 Creating Fork
157 How to sync changes from the parent repository
158 Adding new upstream remote repository
159 Fetching changes from upstream
160 Synchronizing changes from upstream
161 How to open pull request from the forked repository
162 Plan for creating pull request from the forked repository
163 Removing repository collaborator

Git Tags
164 Section 13 Introduction
165 Git tags overview
166 Staging vs Production
167 Semantic versioning
168 Lightweight vs Annotated tags
169 Creating lightweight tags
170 Creating annotated tag
171 Exploring git tag object
172 Pushing tags to remote

173 Section 14 Introduction
174 Completing rebasing by performing merging
175 Exploring graph and commits in SourceTree
176 Deleteing feature branch and pushing to remote
177 Introduction to Rebasing
178 Merging vs Rebasing
179 How to perform rebasing
180 Rebasing – STEP 1
181 Rebasing – STEP 2
182 Creating new repository
183 Creating feature branch and making changes
184 Rebasing feature branch on top of master branch

Ignoring files in Git
185 Section 15 Introduction
186 Introduction go Git ignore
187 Git file statuses – untracked, tracked and ignored
188 Basic gitignore rules
189 Pushing repository with ignored files to remote
190 Committing previously ignored file
191 Ignore previously committed file
192 Git ignore common practices and templates

Detached HEAD
193 Section 16 Introduction
194 Detached HEAD state
195 Making experimental commits in detached HEAD state
196 Retaining changes made in the detached HEAD state

Advanced Git
197 Section 17 Introduction
198 Modifying last commit using amend option
199 Cherry-picking commits
200 Reflog – log of all Git operations
201 Stashing changes using terminal
202 Stashing using GitHub Desktop
203 Garbage collection
204 Squashing of commits at GitHub
205 Interactive rebasing with squashing in the local repository
206 Git development workflow
207 Cloning one of the public repositories
208 Git log options – oneline, graph, stat
209 Git shortlog
210 Filtering commits by author or keyword
211 Pretty formatting of git log
212 Filter out merge commits in git log
213 Git reset
214 Git revert

GitHub Pages
215 Section 18 Introduction
216 Creating simple website using GitHub Pages
217 Hosting any Repository using GitHub Pages
218 Creating basic React application
219 Preparing React application for publish to the GitHub Pages
220 Fixing error with cached credentials by using SSH instead of HTTPS
221 Verifying React GitHub Page
222 Configuring custom domain for GitHub Pages
223 Creating static GitHub Page using markdown

Wrap Up
224 Wrap Up