Git Branches and HEAD | Complete Git Guide: Understand and Master Git and GitHub

Book Overview & Buying
Table Of Contents

Complete Git Guide: Understand and Master Git and GitHub

By : Bogdan Stashchuk

Buy this Video

Complete Git Guide: Understand and Master Git and GitHub

By: Bogdan Stashchuk

Buy this Video

Overview of this book

Effective version control is a must-have skill for developers, and this course takes you from Git fundamentals to expert-level proficiency. It starts with installation and configuration, then dives into essential concepts such as repositories, commits, branches, and merging. You will gain a strong grasp of Git’s architecture and internal mechanisms while practicing real-world commands to track and manage changes efficiently. As you progress, you’ll explore remote collaboration through GitHub, mastering pull requests, forks, and repository management. The course covers workflows for teams, introduces advanced Git strategies like rebasing and interactive commits, and teaches techniques for resolving merge conflicts. You’ll also learn about GitHub Pages for hosting projects, automation with hooks, and best practices for maintaining repositories. By the end, you will confidently navigate version control, leveraging Git and GitHub to streamline development workflows. From basic file tracking to complex branching strategies, this course ensures you gain hands-on expertise in managing projects efficiently. Whether working independently or in a team, you’ll be well-equipped to handle any version control challenge with confidence.

Introduction to Git and GitHub

Introduction

Section 1 Introduction

Git Versus GitHub

Installation of Git and Configuration of the Shell

Section 2 Introduction

Installing Git on macOS

Installing Git on Windows

Installing Git on Linux

Installing iTerm2 on macOS

Installing Custom Z-Shell on macOS

Basic Shell Commands

Section 3 Introduction

Shell Commands - Directory Management

Shell Commands - File Management - Part 1

Shell Commands - File Management - Part 2

How Git Works Under the Hood

Section 4 Introduction

Initializing a New Git Repository

Overview of the .git Folder

Git Object Types

Writing a New Git Object with a git hash-object

JSON Versus Git Database

What is the Hash Function?

Hash Function Overview

SHA-1 Hash Function

How Many Files Can Git Store?

Probability Theory in a Dice Game

Git Hash Collision Probability

More Details on Hash Collision Probability (Optional)

Exploring Git Objects with the git cat-file Command

Creating a New Git Blob Based on a File

Why Git Blobs Do Not Store File Names

Contents of Git Objects

What Have We Learned So Far?

Tree Objects in Git

Git Object Permissions

Creating a Git Tree Object

(Free Preview) Examining Tree Object

Working Directory, Staging Area, and Git Repository

Overview of Current File Distribution

Git Read-tree

Reading Files in the Staging Area Using git ls-files

Git Checkout-index

Number of Folders Created for Objects

Section Summary

Basic Git Operations

Section 5 Introduction

What is a Commit?

Configuring the Git Author Name and Email

Creating Your First Commit

Exploring a Commit Object

Project's Current State Overview

Basic Git Commands

Adding a New File to the Working Directory

Git Files Lifecycle

Stage File

Unstage File using git rm

Committing Changes

Exploring Changes in a Git Repository

Current Diagram of a Git Repository

Git Branches and HEAD

Section 6 Introduction

Most Common Git Operations

Project's Current State Overview

Installing GitHub Desktop

GitHub Desktop Overview

What is a Branch in Git?

What is HEAD in Git?

Third Commit

Git Repository Changes after a Third Commit

Checking Out a Specific Commit

Why Do We Need Branches?

Git Branches Management

Creating a New Branch

Committing Changes in the New Branch

Exploring Commit in the New Branch

Why Git Reuses Blobs with the Same Contents?

Cloning, Exploring, and Modifying Public Repositories

Section 7 Introduction

Cloning a Remote Repository

Exploring the Contents of the Cloned Repository

Unpacking Git Objects

Exploring a Cloned Repository in GitHub Desktop

Installing the Text Editor Visual Studio Code

Exploring Visual Studio Code

Committing Changes in the Cloned Repository

Git diff Command

Overview of the Changes

Merging Branches

Section 8 Introduction

Why Branch Merging is Needed

Fast-Forward Merge

Merging Process

Fast-Forward Merge in Action

Three-Way Merge

Performing a Three-Way Merge

Observing a Git Repository after a Three-Way Merge

Installing SourceTree

SourceTree in Action

What is a Merge Conflict?

Creating a Merge Conflict

Observing Conflicts in the Staging Area and Working Directory

Resolving a Merge Conflict in Terminal

Resolving Conflicts in Visual Studio Code

GitHub and Remote Repositories

Section 9 Introduction

What is a Git Hosting Service?

Creating a GitHub Account

Creating GitHub Personal Access Tokens

Exploring the First Repository in GitHub

Creating Another Commit in GitHub

Creating a New Branch in GitHub

Making Changes in the New Branch

Cloning a Remote Repository

What is a Remote Repository?

How a Remote Repository Empowers Collaboration

Git Push, Fetch, and Pull

Section 10 Introduction

Overview of the Push, Fetch, and Pull Git Commands

What is Origin?

Listing Remote and Local Branches

What is a Tracking Branch?

Checking Out a Remote Branch

Git Remote Show Origin

Git Fetch in Action

Git Pull Two-Step Process

How to Perform Git Pull

What is FETCH_HEAD?

Git Pull with Fast-Forward Merge

Fetching Remote Changes Manually

Merging FETCH_HEAD Manually

Resolving Conflicts Using Git Pull

Pushing to a Remote Repository

Committing Under Another Author

How Remote and Local Branches Sync

Creating a Remote Branch Based on a Local Branch

Updating the Tracking Status of the Branches

Removing a Remote Branch Using a Local Terminal

Git Show-Ref

Pull Requests

Section 11 Introduction

Collaboration Between Contributors

What is a Pull Request?

Why Was Pull Request Named Pull Request?

Pull Request Versus Merge Request

Pull Request Step-By-Step

Creating a New Repository in GitHub

Changing the Author of the Last Commit

Pushing Branch to Remote

Opening a Pull Request

Adding Comments and Approving a Pull Request

Creating and Publishing a New Branch Using GitHub Desktop

Signing into GitHub Using GitHub Desktop

Creating and Merging a Pull Request

Adding a New Collaborator in GitHub

Exploring Your GitHub Account

Opening and Merging a Pull Request Using a Collaborator

Merging Without Approvals

Configuring a Protected Branch Rule

Merging After Gaining Required Approval

Exploring Pull Requests in Public Repositories

Working with Issues in GitHub

Forks and Contribution to Public Repositories

Section 12 Introduction

Creating a Fork

Syncing Changes from the Parent Repository

Adding a New Upstream Remote Repository

Fetching Changes from Upstream

Synchronizing Changes from Upstream

How to Open a Pull Request from a Forked Repository

Creating a Pull Request from a Forked Repository

Removing a Repository Collaborator

Forking a Repository

Committing Changes in a Forked Repository

Opening a Pull Request from a Forked Repository

Approving and Merging a Pull Request from a Forked Repository

Git Tags

Section 13 Introduction

Git Tags Overview

Staging Versus Production

Semantic Versioning

Lightweight Versus Annotated Tags

Creating Lightweight Tags

Creating Annotated Tags

Exploring a Git Tag Object

Pushing Tags to Remote

Rebasing

Section 14 Introduction

Introduction to Rebasing

Merging Versus Rebasing

How to Perform Rebasing

Rebasing - Step 1

Rebasing - Step 2

Creating a New Repository

Creating a Feature Branch and Making Changes

Rebasing a Feature Branch on Top of Master Branch

Completing Rebasing by Performing Merging

Exploring Graphs and Commits in SourceTree

Deleting a Feature Branch and Pushing to Remote

Ignoring Files in Git

Section 15 Introduction

Introduction to Git Ignore

Git File Statuses: Untracked, Tracked, and Ignored

Basic Git Ignore Rules

Pushing Repository with Ignored Files to Remote

Committing Previously Ignored Files

Ignoring Previously Committed Files

Git Ignore Common Practices and Templates

Detached HEAD

Section 16 Introduction

Detached HEAD State

Making Experimental Commits in Detached HEAD State

Retaining Changes Made in the Detached HEAD State

Advanced Git

Section 17 Introduction

Cloning One of the Public Repositories

Git Log Options: Oneline, Graph, and Stat

Git Shortlog

Filtering Commits by Author or Keyword

Pretty Formatting of Git Log

Filtering Merge Commits in Git Log

Git Reset

Git Revert

Modifying the Last Commit Using the Amend Option

Cherry-Picking Commits

Reflog - Log of All Git Operations

Stashing Changes Using Terminal

Stashing Using GitHub Desktop

Garbage Collection

Squashing Commits in GitHub

Interactive Rebasing with Squashing in the Local Repository

Git Development Workflow

GitHub Pages

Section 18 Introduction

Creating a Simple Website Using GitHub Pages

Hosting Any Repository Using GitHub Pages

Creating a Basic React Application

Preparing the React Application for Publishing to GitHub Pages

Fixing Errors with Cached Credentials Using SSH Instead of HTTPS

Verifying a React GitHub Page

Configuring a Custom Domain for GitHub Pages

Creating a Static GitHub Page Using Markdown

GitHub Hooks

Section 19 Introduction

Normal Git Workflow Without Hooks

What are Git Hooks?

How Git Hooks Can Be Used in Practice

Using a Pre-Commit Hook

Enabling a Post-Commit Hook

Disabling Rebasing Using a Pre-Rebase Hook

Matching an Author's Email Against a Regular Expression

Why Local Git Hooks Are Not Pushed to the Remote

Cleaning Up the Local Git Hooks Repository

Initializing a New Node.js Project

Installing the Jest NPM Package for Testing

Adding Multi and Sum Modules with Tests

Using the Pre-Commit NPM Package for Automation of the Pre-Commit Hook

Cloning a Remote Repository and Verifying a Pre-Commit Hook

Replacing a Pre-Commit NPM Package with Husky

Skipping All Git Hooks Using the --no-verify Option

Introduction to Linter and Running Linter in the Pre-Commit Hook

Introducing a Lint-Staged Package to Check Only Staged Files

Verifying Selective Linting and Testing Using Lint-Staged

Adding a Post-Commit Hook

Verifying Commit Messages Using Commitlint

Git Hooks Summary

Wrap Up

Complete Git Guide: Understand and Master Git and GitHub

By : Bogdan Stashchuk

Complete Git Guide: Understand and Master Git and GitHub

By: Bogdan Stashchuk

Overview of this book

Confirmation

Buy this book with your credits?

Submit Your Feedback

Create a Free Account To Continue Reading

Sign in to activate your 7-day free access