TOIT Training

Facebook X-twitter Linkedin Instagram
Menu
Beginner
DevOps

Complete Git Guide: Understand and Master Git and GitHub

Overview
Curriculum

Overview

Complete with practical activities, this comprehensive Git and GitHub guide will help you understand how Git works. You’ll learn how to use Git features efficiently and fix issues in your development workflow. Starting with the internal structure of a Git repository, this course will take you through the four types of Git objects: blobs, trees, commits, and annotated tags. You’ll understand how each object has a unique SHA-1 hash and how all objects are stored in folders, files are stored in blobs, and filenames are stored in other Git objects called trees. You’ll even get to grips with creating new Git objects without using git commit and git add. Once you’ve created Git objects in the Git repository, you will add it to the staging area and working directory. By the end of this course, you’ll have become a Git and GitHub expert and be able to perform basic and advanced Git tasks seamlessly.

Curriculum

  • 19 Sections
  • 247 Lessons
  • 21h 50m Duration
Expand All
Introduction to Git and GitHub
3 Lessons
  1. Introduction to Git and GitHub
  2. What to Expect in the Course
  3. Git Versus GitHub
Installation of Git and Configuration of the Shell
6 Lessons
  1. Introduction to Installation of Git and Configuration of the Shell
  2. Installing Git on MacOS
  3. Installing Git on Windows
  4. Installing Git on Linux
  5. Installing iTerm2 on MacOS
  6. Installing Custom Z-Shell on MacOS
Basic Shell Commands
4 Lessons
  1. Introduction to Basic Shell Commands
  2. Shell Commands – Directory Management
  3. Shell Commands – File Management – Part 1
  4. Shell Commands – File Management – Part 2
How Git Works Under the Hood
29 Lessons
  1. Introduction to How Git Works Under the Hood
  2. Initializing a New Git Repository
  3. Overview of the .git Folder
  4. Git Object Types
  5. Writing a New Git Object with a git hash-object
  6. JSON Versus Git Database
  7. What is the Hash Function?
  8. Hash Function Overview
  9. SHA-1 Hash Function
  10. How Many Files can Git Store?
  11. Probability Theory in a Dice Game
  12. Git Hash Collision Probability
  13. More details on hash collision probability
  14. Exploring Git Objects with the git cat-file Command
  15. Creating a New Git Blob Based on a File
  16. Why Git Blobs do not Store File Names
  17. Contents of Git Objects
  18. What Have We Learned so Far?
  19. Tree Objects in Git
  20. Git Object Permissions
  21. Creating a Git Tree Object
  22. Examining Tree Object
  23. Overview of Current File Distribution
  24. Working Directory, Staging Area, and Git Repository
  25. Git Read-tree
  26. Reading Files in the Staging Area Using git ls-files
  27. Git Checkout-index
  28. Number of Folders Created for Objects
  29. How Git Works Under the Hood Summary
Basic Git Operations
14 Lessons
  1. Introduction to Basic Git Operations
  2. What is Commit?
  3. Configuring the Git Author Name and Email
  4. Creating Your First Commit
  5. Exploring a Commit Object
  6. Project’s Current State Overview
  7. Basic Git Commands
  8. Adding a New File to the Working Directory
  9. Git Files Lifecycle
  10. Stage File
  11. Unstage File using git rm
  12. Committing Changes
  13. Exploring Changes in a Git Repository
  14. Current Diagram of a Git Repository
Git Branches and HEAD
16 Lessons
  1. Introduction to Git Branches and HEAD
  2. Most Common Git Operations
  3. Project’s Current State Overview
  4. Installing GitHub Desktop
  5. GitHub Desktop Overview
  6. What is Branch in Git?
  7. What is HEAD in Git?
  8. Third Commit
  9. Git Repository Changes after a Third Commit
  10. Checking Out a Specific Commit
  11. Why Do We Need Branches?
  12. Git Branches Management
  13. Creating a New Branch
  14. Committing Changes in the New Branch
  15. Exploring Commit in the New Branch
  16. Why Git Reuses Blobs with the Same Contents?
Cloning, Exploring, and Modifying Public Repositories
10 Lessons
  1. Introduction to Cloning, Exploring, and Modifying Public Repositories
  2. Cloning Remote Repository
  3. Exploring the Contents of the Cloned Repository
  4. Unpacking Git Objects
  5. Exploring Cloned Repository in GitHub Desktop
  6. Installing the Text Editor Visual Studio Code
  7. Exploring Visual Studio Code
  8. Committing Changes in the Cloned Repository
  9. Git diff Command
  10. Overview of the Changes
Merging Branches
15 Lessons
  1. Introduction to Merging Branches
  2. Why Branch Merging is Needed
  3. Fast-Forward Merge
  4. Merging process
  5. Fast-Forward Merge in Action
  6. Three-Way Merge
  7. Performing a Three-Way Merge
  8. Observing a Git Repository after a Three-Way Merge
  9. Installing SourceTree
  10. SourceTree in Action
  11. What is Merge Conflict?
  12. Creating Merge Conflict
  13. Observing Conflicts in the Staging Area and Working Directory
  14. Resolving a Merge Conflict in Terminal
  15. Resolving Conflicts in Visual Studio Code
GitHub and Remote Repositories
10 Lessons
  1. Introduction to GitHub and Remote Repositories
  2. What is a Git Hosting Service?
  3. Creating a GitHub Account
  4. Exploring the First Repository in GitHub
  5. Creating Another Commit in GitHub
  6. Creating a New Branch in GitHub
  7. Making Changes in the New Branch
  8. Cloning a Remote Repository
  9. What is Remote Repository?
  10. How Remote Repository Empowers Collaboration?
Git Push, Fetch, and Pull
22 Lessons
  1. Introduction to Git Push, Fetch, and Pull
  2. Overview of the Push, Fetch, and Pull Git Commands
  3. What is Origin?
  4. Listing Remote and Local Branches
  5. What is Tracking Branch?
  6. Checking Out a Remote Branch
  7. Git Remote Show Origin
  8. Git Fetch in Action
  9. Git Pull Two-Step Process
  10. How to Perform Git Pull
  11. What is FETCH_HEAD?
  12. Git Pull with Fast-Forward Merge
  13. Fetching Remote Changes Manually
  14. Merging FETCH_HEAD Manually
  15. Resolving Conflicts Using Git Pull
  16. Pushing to a Remote Repository
  17. Committing Under Another Author
  18. How do Remote and Local Branches Sync?
  19. Creating a Remote Branch Based on a Local Branch
  20. Updating the Tracking Status of the Branches
  21. Removing a Remote Branch Using a Local Terminal
  22. Git Show-ref
Pull Requests
22 Lessons
  1. Introduction to Pull Requests
  2. Collaboration Between Contributors
  3. What is a Pull Request?
  4. Why was Pull Request Named Pull Request?
  5. Pull Request Versus Merge Request
  6. Pull Request Step-By-step
  7. Creating a New Repository in GitHub
  8. Changing the Author of the Last Commit
  9. Pushing Branch to Remote
  10. Opening a Pull Request
  11. Adding Comments and Approving a Pull Request
  12. Creating and Publishing a New Branch Using GitHub Desktop
  13. Signing into GitHub Using GitHub Desktop
  14. Creating and Merging a Pull Request
  15. Adding a New Collaborator in GitHub
  16. Exploring Your GitHub Account
  17. Opening and Merging a Pull Request Using a Collaborator
  18. Merging without Approvals
  19. Configuring a Protected Branch Rule
  20. Merging after Gaining Required Approval
  21. Exploring Pull Requests in the Public Repositories
  22. Working with Issues in GitHub
Forks and Contribution to the Public Repositories
13 Lessons
  1. Introduction to Forks and Contribution to the Public Repositories
  2. Creating a Fork
  3. Synching Changes from the Parent Repository
  4. Adding a New Upstream Remote Repository
  5. Fetching Changes from Upstream
  6. Synchronizing Changes from Upstream
  7. How to Open Pull Request from a Forked Repository
  8. Creating a Pull Request from a Forked Repository
  9. Removing a Repository Collaborator
  10. Forking Repository
  11. Committing Changes in a Forked Repository
  12. Opening Pull Request from a Forked Repository
  13. Approving and Merging a Pull Request from a Forked Repository
Git Tags
9 Lessons
  1. Introduction to Git Tags
  2. Git Tags Overview
  3. Staging Versus Production
  4. Semantic Versioning
  5. Lightweight Versus Annotated Tags
  6. Creating Lightweight Tags
  7. Creating Annotated Tags
  8. Exploring a Git Tag Object
  9. Pushing Tags to Remote
Rebasing
12 Lessons
  1. Introduction to Rebasing
  2. What is Rebasing?
  3. Merging Versus Rebasing
  4. How to Perform Rebasing
  5. Rebasing – Step 1
  6. Rebasing – Step 2
  7. Creating a New Repository
  8. Creating a Feature Branch and Making Changes
  9. Rebasing a Feature Branch on Top of Master Branch
  10. Completing Rebasing by Performing Merging
  11. Exploring Graphs and Commits in SourceTree
  12. Deleting a Feature Branch and Pushing to Remote
Ignoring Files in Git
8 Lessons
  1. Introduction to Ignoring Files in Git
  2. What is Git Ignore?
  3. Git File Statuses: Untracked, Tracked, and Ignored
  4. Basic Git ignore Rules
  5. Pushing Repository with Ignored Files to Remote
  6. Committing Previously Ignored Files
  7. Ignoring Previously Committed Files
  8. Git ignore Common Practices and Templates
Detached HEAD
4 Lessons
  1. Introduction to Detached HEAD
  2. Detached HEAD State
  3. Making Experimental Commits in Detached HEAD State
  4. Retaining Changes Made in the Detached HEAD State
Advanced Git
18 Lessons
  1. Introduction to Advanced Git
  2. Cloning One of the Public Repositories
  3. Git Log Options: Oneline, Graph, and Stat
  4. Git Shortlog
  5. Filtering Commits by Author or Keyword
  6. Pretty Formatting of Git Log
  7. Filtering Merge Commits in Git Log
  8. Git Reset
  9. Git Revert
  10. Modifying the Last Commit Using the Amend Option
  11. Cherry-picking Commits
  12. Reflog – Log of All Git Operations
  13. Stashing Changes Using Terminal
  14. Stashing Using GitHub Desktop
  15. Garbage Collection
  16. Squashing of Commits in GitHub
  17. Interactive Rebasing with Squashing in the Local Repository
  18. Git Development Workflow
GitHub Pages
9 Lessons
  1. Introduction to GitHub Pages
  2. Creating a Simple Website Using GitHub Pages
  3. Hosting any Repository Using GitHub Pages
  4. Creating a Basic React application
  5. Preparing the React Application for Publishing to the GitHub Pages
  6. Fixing Errors with Cached Credentials Using SSH Instead of HTTPS
  7. Verifying a React GitHub Page
  8. Configuring a Custom Domain for GitHub Pages
  9. Creating a Static GitHub Page Using Markdown
GitHub Hooks
23 Lessons
  1. Introduction to GitHub Hooks
  2. Normal Git Workflow without Hooks
  3. What are Git Hooks?
  4. How Git Hooks can Be Used in Practice
  5. Using a Pre-Commit Hook
  6. Enabling a Post-Commit Hook
  7. Disabling Rebasing Using a Pre-Rebase Hook
  8. Matching an Author’s Email against a Regular Expression
  9. Why Local Git Hooks are not Pushed to the Remote
  10. Cleaning Up the Local Git Hooks Repository
  11. Initializing a New Node.js Project
  12. Installing the Jest NPM Package for Testing
  13. Adding Multi and Sum Modules with Tests
  14. Using the Pre-Commit NPM Package for Automation of the Pre-commit Hook
  15. Cloning a Remote Repository and Verifying a Pre-Commit Hook
  16. Replacing a Pre-Commit NPM Package with Husky
  17. Skipping All Git Hooks Using the –no-verify Option
  18. Introduction to Linter and Running Linter in the Pre-Commit Hook
  19. Introducing a Lint-Staged Package to Check only Staged Files
  20. Verifying Selective Linting and Testing Using Lint-staged
  21. Adding a Post-Commit Hook
  22. Verifying Commit Message Using Commitlint
  23. Git Hooks Summary

Deleting Course Review

Are you sure? You can't restore this back

Course Access

This course is password protected. To access it please enter your password below:

Buy for group

Complete Git Guide: Understand and Master Git and GitHub
No groups Found

You don't have any groups yet

Create a group and add group members. Sync Group(s)
Choose Group(s)
Sync Group(s)
    Create a new group Go to Checkout