Learn Git and GitHub – FastTrack Your Journey to Git!

Git is a Version Control System, where as GitHub is a centralized repository to host the code and enable team collaboration.

In this course, you will learn about Git and GitHub and all the concepts pertaining to them. This course also talks about the use cases and workflows that you need to know as a developer.

You will not only understand the core part of Git and GitHub and how it works under the hood, but we will also explore a host of concepts that are crucial for you to understand before you start contributing to Git projects.

Who can take this course?

• Individuals seeking to advance their careers in IT or enter a new job role where knowledge of git and github is required.

• People who are getting started with their software developer journey

• Managers or team leads who lead a project

• People who want to get started with their DevOps journey

• Passionate learners who want to upgrade their skills for better job prospects

In this course, you will also learn how to contribute to open source projects and build your online presence or credibility.

This course will teach you everything you need to know about Git and GitHub, and you don’t have to refer to any other sources.

This course comes with a 30 day refund policy. If you didn’t like the course for whatever reason, you can ask for a full refund.

Few reasons to learn Git and GitHub:

• GitHub has over 100 million repositories (source: GitHub).

• Over 72 million developers from around the world use GitHub (source: GitHub).

• GitHub is home to over 40 million registered users (source: GitHub).

• The most popular programming languages on GitHub are JavaScript, Python, Java, TypeScript, and Ruby (source: GitHub).

• Over 31 million GitHub repositories are public (source: GitHub).

• The most popular license for GitHub repositories is the MIT License, followed by the GNU General Public License (source: GitHub).

• Microsoft acquired GitHub in 2018 for $7.5 billion (source: The Verge).

These statistics demonstrate the popularity and widespread use of GitHub among developers and the programming community.

What is GitHub?

GitHub is a web-based platform for software developers to store and share their code with others. It provides version control through Git, which allows developers to keep track of changes to their code, collaborate with others, and easily roll back to previous versions if needed. GitHub also offers a range of features, such as issue tracking, project management tools, and code review capabilities, to help teams work together more effectively. It has become a popular platform for open-source software development and hosts millions of projects, ranging from small personal projects to large enterprise software.

Why GitHub is used for software development:

Version Control: GitHub uses Git, which is a powerful and widely used version control system. It allows developers to keep track of changes to their code and collaborate with others, ensuring that everyone is working on the same version of the code.

Collaboration: GitHub provides a platform for developers to work together on projects, whether they are in the same office or on opposite sides of the world. Teams can easily share code, review changes, and collaborate on new features.

Community: GitHub is a hub for open source projects, providing a platform for developers to contribute to projects created by others. This fosters a community of developers who can share knowledge and collaborate on projects.

Code Review: GitHub provides tools for code review, allowing team members to easily review and comment on each other’s code. This helps ensure that code is of high quality and meets the project’s requirements.

Project Management: GitHub provides tools for project management, including issue tracking and milestones. This allows teams to keep track of project progress, identify and prioritize issues, and set goals for the project.

Integration: GitHub can be integrated with many other tools and services, such as continuous integration and deployment (CI/CD) tools, which help automate the development process and ensure that code is deployed to production environments quickly and efficiently.

High-level overview of what you will learn:

Git: Git is a popular version control system that allows you to track changes to code and collaborate with others. Understanding how Git works and how to use it is essential for working with GitHub.

Repositories: A repository is a central location for your code. You can create a new repository on GitHub, and then upload your code to it. Repositories can be either public or private, and they can be used to collaborate with others or manage your own projects.

Branches: Branches are used in Git to isolate changes to code and work on new features or fixes. Understanding how to create and manage branches is important for working with Git and GitHub.

Pull Requests: Pull requests are a way to propose changes to code and collaborate with others. They allow you to submit changes to a repository and have them reviewed by others before they are merged into the main codebase.

Issues: Issues are used to track bugs, feature requests, and other tasks. They can be used to manage projects and prioritize work, and they can be assigned to specific users to ensure that work is distributed effectively.

Collaborating with others: GitHub provides a range of tools for collaborating with others, including pull requests, code reviews, and issue tracking. Understanding how to use these tools is essential for working with others and ensuring that code is of high quality.

Project management: GitHub provides tools for project management, including issue tracking and milestones. Understanding how to use these tools can help you manage your own projects more effectively, as well as contribute to larger projects that use GitHub for project management.

This is only a high level overview. Below are the topics covered in this course (By the time of this writing)

Section 1:

Introduction

Need For Version Control System and Git Part 1

Need For Version Control System and Git Part 2

VCS-How it works

Distributed VCS

Installing Git

Git CLI vs Git Bash vs Git GUI

Basic Bash Commands

What exactly is Git Commit

Initializing the project and Exploring dot git folder

Configuring Git Credentials and exploring local global system configs

Staging and Unstaging and checking status

Understanding Commit with multiple use cases

Section 2:

Git Deep Dive

Sha1 Hashing Algorithm

Git Internals (All about Object Database) Part 1

Git Internals (All about Object Database) Part 2

Git Internals – Viewing and reading Git Objects

How Blob Objects Behave

Garbage Collection and Pack Files

Git Snapshot – What it means to take a snapshot

Time travel with Git

Time Travel in Practice

Section 3:

Git Branches

Life without Branches

What are Git Branches

How Branches Solved our Problems

How Git Branches Work and What Exactly is a Branch

Branches in Action (Creating Branches and exploring the git repo)

Understanding ‘HEAD’ – Detached Head State – Head in Action.

Undo the changes with Git Reset HEAD

Retrieving the lost mystery with reflog

Section 4:

Merging

Fast-Forward Merge

Fast-Forward Merge In Action

Deleting the branch and recovering

Understanding Three Way Merge and Merge Commit

Three Way Merge in Action

Understanding Merge Conflicts

Merge Conflicts in Action Part 1

Merge Conflicts in Action Part 2

Installing and setting up Visual Studio Code to work on Git

Exploring VS Code and performing GIT Operations

Section 5:

Git Rebase

Git Rebase vs Merge

Performing Rebase in VS Code & Handling conflicts

Git Rebase in Git Bash – Skipping conflicts and Aborting the Rebase

Git Interactive Rebase

Rebase to specific commit or to another feature branch

When to use rebase and when to use Merge – use cases

Section 6:

Stashing

What is Stashing – It’s use cases – Example of Stashing

Applying the stash across multiple branches

Retrieving a specific stash – Listing stashes – Handling conflicts

Stashing Selective Changes and retrieving them – Understanding Hunk

Exploring stashing in VS Code – Deleting a stash

Section 7:

Git Ignore

Git Ignore and it’s significance (Crash course)

Git Ignore in action – Global exclude config

Precedence order – overriding – Pattern debugging

Ignore files that were already committed

Generating the Ignore files for your project

Section 8:

Git Hub

Why GitHub – GitHub vs Bit Bucket vs GitLab

Creating GitHub Account

Creating and understanding Public and Private repositories in GitHub

Making Commits in GitHub and Understanding ReadMe file

Creating Branch and committing changes – Managing branches in GitHub

Section 9:

Getting Started as Collaborator

Cloning a public repo and exploring other options

Cloning a Private Repository and adding project collaborators on GitHub

Understanding Tracking Branches and Default branch

Exploring Tracking branches – Configuring Default branch – Understanding Or

Understanding origin remote – adding, editing, deleting remotes

Section 10:

Git Fetch

Understand Git Fetch and it’s use cases

Git Fetch in Action Part1 (Command variations – Checking status with comman

Git Fetch in Action Part2 (Exploring refs – FETCH_HEAD)

Switching to Remote Repo State

Merging the Changes – Using FETCH_HEAD

Using Visual Studio code to Fetch and Merge

Updating Local References with Git Fetch

Section 11:

Git Pull

Understanding Git Pull

Git Pull in Action and observing what it does

Understanding Git Pull with 3way merge

Git pull with rebase and it’s implications

Dealing with conflicts with Git Pull –rebase

Using Stashing and Hard reset

Section 12:

Contributing to the remote repository

Setting up everything for contributing – Adding collaborator – Setting cred

Creating a remote branch and pushing changes using Git Bash and VSCode – Pu

Understanding Pull Request – Raising a Pull Request

Understanding protected branches – Applying branch protection rule – Mandat

Reviewing and approving the changes – Working on review comments and publis

Exploring the merging options – Understanding Squashing commits – Deleting

What Git Pull Actually Does

Resolving conflicts on GitHub the right way – Force pushing changes and it’

Divide and Conquer Strategy

Resolving Conflicts by merging main in to feature branch

Section 13:

13 Forking and Contributing to Opensource Projects

What is Forking and why forking

Forking a public repository and cloning it in our local machine

Contributing the necessary changes

Syncing the Forked repo with original one and updating local

Syncing the Forked repo with original from local repo

Pushing our changes to the forked repo

Raising the pull request and merging the changes in upstream repository

Exploring Existing Public Project

Section 14:

Branching Strategy and Tags

Branching Strategy Explained

Branching Strategy with Realtime Scenario

Semantic Versioning Explained

Understanding Git Tags

Braching Workflow in Action

Hot Fix workflow in Action

Creating Tags – Annotated vs Lightweight Tags – Pushing tags to remote

Understanding how Tags are stored – Detached head state with tags

Releases and Creating Tags on GitHub

Section 15:

Branch Protection Rules

Dismiss stale pull request approvals for new commits

Configuring Code Owners with patterns – Automatic review request

Mandating conversation resolution before merging

Exploring all other branch protection rules

Section 16:

Digital Signatures and Verified commits

Mimicking the Commits and the need to have verified commits

Understanding Digital Signatures

Understanding Signed Commits

Creating Public and Private Keys Using GPG

Exporting Public Key and updating GPG key on GitHub

Making Signed Commit – Setting global config – verifying signed commits on

Mandating Signed Commits – Signing commits from VS Code

Section 17:

Git Hooks

What are Git Hooks

Demonstrating Git Hook

Standardizing Hooks across teams

Explore Other Hooks

Section 18:

Other Concepts

Bug Tracing with Git Bisect

Git Diff to compare and visualize differences

Git Diff to compare branches

Advanced Git Log

All About GitHub Pages