Git Commands

Git is a fast, scalable, distributed revision control system with an extraordinarily rich command set that gives both high-level operations and full access to internals. Repositories, Branches, and Exploring Git history show how to fetch and study a project using git.

Once you are done with learning all basic concepts of Git from our other Git Tutorials spend some of your learning time in this ultimate GIT Commands Tutorial and learn what commands GIT offers and how to use them while working with Git in numerous projects.

What is Git and how it works?

Git is the most famous and frequently used VCS (Version Control System). It tracks the modifications that you performed to files and it records completely what you did with files in the Git repository. Also, you can revert to particular versions which suit your project and what you required to. However, Git also offers easy collaboration, enabling changes by various people to all to be merged into one source.

What is the Git command line?

Git is a set of Command-Line service programs designed to perform on a Unix-style command-line environment at its core. Modern operating systems like Linux and macOS both include built-in Unix command line terminals. In Windows environments, Git has often been packaged as part of higher-level GUI applications.

basic git commands

We divide Git into high-level (“porcelain”) commands and low-level (“plumbing”) commands. Find the detailed list of git commands from this git commands page and become pro in working with Git.

List of All Git Tutorials

Git Installation

For GNU/Linux distributions, Git should be available in the standard system repository. For example, in Debian/Ubuntu please type in the terminal:

$ sudo apt-get install git

If you need to install Git from the source, you can get it from

The Git command that is used to verify whether the git is installed or not is given here. Just open a terminal and run the following command:

git --version

If Git is installed, the output is:

git version X.Y.Z

In case you didn’t find any version of git, then you should install git at first and then run the above commands.

Git Configuration

If you want to work with Git on your PCs, then the configuration of Git is a must. To make it happen and to start using Git, should enter your credentials to identify yourself as the author of your work. The username and email address should match the ones you use in GitLab.

In your shell, add your user name:

git config --global "your_username"

Add your email address:

git config --global ""

To verify the configuration, run the following git config command:

git config --global --list

Where, –global option instructs Git to always use this information for anything you do on your system. If you omit –global or use –local, the configuration applies only to the current repository.

Basic Git Commands List

Here is the list of basic & common git commands that you should get to know while working with Git on your software projects.

Git Task Notes Git Commands
Tell Git who you are Configure the author name and email address to be used with your commits. Note that Git strips some characters (for example trailing periods) from
git config --global "Sam Smith"
git config --global
Create a new local repository
git init
Checkout a repository Create a working copy of a local repository:
git clone /path/to/repository
For a remote server, use:
git clone username@host:/path/to/repository
Add files Add one or more files to staging (index):
git add <filename>

git add *
Commit Commit changes to head (but not yet to the remote repository):
git commit -m "Commit message"
Commit any files you’ve added with git add, and also commit any files you’ve changed since then:
git commit -a
Push Send changes to the master branch of your remote repository:
git push origin master
Status List the files you’ve changed and those you still need to add or commit:
git status
Connect to a remote repository If you haven’t connected your local repository to a remote server, add the server to be able to push to it:
git remote add origin <server>
List all currently configured remote repositories:
git remote -v
Branches Create a new branch and switch to it:
git checkout -b <branchname>
Switch from one branch to another:
git checkout <branchname>
List all the branches in your repo, and also tell you what branch you’re currently in:
git branch
Delete the feature branch:
git branch -d <branchname>
Push the branch to your remote repository, so others can use it:
git push origin <branchname>
Push all branches to your remote repository:
git push --all origin
Delete a branch on your remote repository:
git push origin :<branchname>
Update from the remote repository Fetch and merge changes on the remote server to your working directory:
git pull
To merge a different branch into your active branch:
git merge <branchname>
View all the merge conflicts: View the conflicts against the base file:

Preview changes, before merging:

git diff git diff --base <filename>
git diff <sourcebranch> <targetbranch>
After you have manually resolved any conflicts, you mark the changed file:
git add <filename>
Tags You can use tagging to mark a significant changeset, such as a release:
git tag 1.0.0 <commitID>
CommitId is the leading character of the changeset ID, up to 10, but must be unique. Get the ID using:
git log
Push all tags to the remote repository:
git push --tags origin
Undo local changes If you mess up, you can replace the changes in your working tree with the last content in your head: Changes already added to the index, as well as new files, will be kept.
git checkout -- <filename>
Instead, to drop all your local changes and commits, fetch the latest history from the server and point your local master branch at it, do this:
git fetch origin

git reset --hard origin/master
Search Search the working directory for foo():
git grep "foo()"

Git Repositories

You can find two actively used repositories always help developers to work on Git. They are:

  1. Local repository: The local repository is present on our computer and consists of all the files and folders. This Repository is utilized to make changes locally, review history, and commit when offline.
  2. Remote repository: The remote repository refers to the server repository that may be present anywhere. This repository is used by all the team members to exchange the changes made. For better knowledge, you can check how to change git remote origin and these operations can be done with the help of Git commands.

Both repositories have their own set of commands. There are separate Git Commands that work on different types of repositories.

Git Branches

A branch is a copy of the files in the repository at the time you create a git branch. You can work in your branch without affecting other branches. When you’re ready to add your modifications to the main codebase, you can merge your branch into the default branch, for instance, main.

The main uses of Git branches are as follows:

  • Want to add code to a project but you’re not sure if it works properly.
  • Are collaborating on the project with others, and don’t want your work to get mixed up.

A new branch is often called a feature branch to differentiate from the default branch.

For more information on branches of Git, you need to go through the following Git branch tutorials:

Top 20 Git Commands Every Developers Should Know

The git commands that have been covered in the below list of top 20 Git commands for developers are explained neatly with examples in this tutorial for gaining a good knowledge on Git and work with these commands effectively while your projects.

Check out the best & most commonly used commands of Git that every developer must know before working with GIT:

Git Commands: Working With Local Repositories

1. git init: The command git init is used to create an empty Git repository. After the git init command is used, a .git folder is created in the directory with some subdirectories. Once the repository is initialized, the process of creating other files begins.


# change directory to codebase
$ cd /file/path/to/code

# make directory a git repository
$ git init

In Practice:

# change directory to codebase
$ cd /Users/computer-name/Documents/website

# make directory a git repository
$ git init
Initialized empty Git repository in /Users/computer-name/Documents/website/.git/

2. git add: Add command is used after checking the status of the files, to add those files to the staging area. Before running the commit command, “git add” is used to add any new or modified files.

If you want to learn the commands that are used for undo git add commands and add all files in Git then check our Git tutorials compiled on the git add command.


$ git add <file or directory name>

In Practice:

# To add all files not staged:
$ git add .

# To stage a specific file:
$ git add index.html

# To stage an entire directory:
$ git add css

3. git commit: This command will record the modifications done to the files to a local repository. For simple reference, each commit has a unique ID. It’s best practice to add a message with each commit explaining the changes made in a commit and how to amend a git commit message. Adding a commit message helps to find a particular change or understanding the changes.


# Adding a commit with message
$ git commit -m "Commit message in quotes"

In Practice:

$ git commit -m "My first commit message"
[SecretTesting 0254c3d] My first commit message
1 file changed, 0 insertions(+), 0 deletions(-)
create mode 100644 homepage/index.html

If you want to understand a clear picture of the git commit message command just go through this How to Git Commit with Message Tutorial. 

4. git status: Want to check the current state of the repository then you make use of this git status command. As it returffns the current working branch. If a file is in the staging area, but not committed, it shows with git status. Or, if there are no changes it’ll return nothing to commit, working directory clean.


$ git status

In Practice:

# Message when files have not been staged (git add)
$ git status
On branch SecretTesting
Untracked files:
(use "git add <file>..." to include in what will be committed)


# Message when files have been not been committed (git commit)
$ git status
On branch SecretTesting
Your branch is up-to-date with 'origin/SecretTesting'.
Changes to be committed:
(use "git reset HEAD <file>..." to unstage)

new file: homepage/index.html

# Message when all files have been staged and committed 
$ git status
On branch SecretTesting
nothing to commit, working directory clean

5. git config: Whenever you want to configure the and initially then use this git config command. It defines what email id and username will be utilized from a local repository. When git config is used with –global flag, it writes the settings to all repositories on the computer.


$ git config <setting> <command>

In Practice:

# Running git config globally
$ git config --global ""
$ git config --global "Brian Kerr"

# Running git config on the current repository settings
$ git config ""
$ git config "Brian Kerr"

6. git branch: To discover what branch the local repository is on, add a new branch, or delete a branch.


# Create a new branch
$ git branch <branch_name>

# List all remote or local branches
$ git branch -a

# Delete a branch
$ git branch -d <branch_name>

In Practice:

# Create a new branch
$ git branch new_feature

# List branches
$ git branch -a
* SecretTesting
remotes/origin/master -> origin/SecretTesting

# Delete a branch
$ git branch -d new_feature
Deleted branch new_feature (was 0254c3d).

7. git checkout: By using git checkout, you can easily switch branches, whenever the work is to be started on a different branch. The command works on three separate entities: files, commits, and branches.


# Checkout an existing branch
$ git checkout <branch_name>

# Checkout and create a new branch with that name
$ git checkout -b <new_branch>

In Practice:

# Switching to branch 'new_feature'
$ git checkout new_feature
Switched to branch 'new_feature'

# Creating and switching to branch 'staging'
$ git checkout -b staging
Switched to a new branch 'staging'

8. git merge: In order to integrate the branches together, we use the git merge command. Also, it combines the changes from one branch to another branch. For instance, it is utilized to merge the changes in the staging branch to the stable branch.


# Merge changes into current branch
$ git merge <branch_name>

In Practice:

# Merge changes into current branch
$ git merge new_feature
Updating 0254c3d..4c0f37c
homepage/index.html | 297 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 297 insertions(+)
create mode 100644 homepage/index.html

Git Commands: Working With Remote Repositories

1. git remote: If you want to create, view, and delete connections to other repositories then you can use this git remote command. Also by using this command, you can connect a local repository with a remote repository.

A remote repository can have a name set to avoid having to remember the URL of the repository. One must know fact about this command is A remote repository can have any name and it’s common practice to name the remote repository ‘origin’.


# Add remote repository
$ git remote <command> <remote_name> <remote_URL>

# List named remote repositories
$ git remote -v

In Practice:

# Adding a remote repository with the name of beanstalk
$ git remote add origin

# List named remote repositories
$ git remote -v
origin (fetch)
origin (push)

2. git clone: In order to build a local working copy of a current remote repository, this command is used. It also downloads the remote repository to the computer. It is similar to the Git init command when operating with a remote repository. In order to clone a git repository also you need to make use of this command.


$ git clone <remote_URL>

In Practice:

$ git clone
Cloning into 'repository_name'...
remote: Counting objects: 5, done.
remote: Compressing objects: 100% (3/3), done.
remote: Total 5 (delta 0), reused 0 (delta 0)
Receiving objects: 100% (5/5), 3.08 KiB | 0 bytes/s, done.
Checking connectivity... done.

3. git pull: This command is utilized to get the latest version of a repository run git pull. This pulls the changes from the remote repository to the local computer.


$ git pull <branch_name> <remote_URL/remote_name>

In Practice:

# Pull from named remote
$ git pull origin staging
* branch staging -> FETCH_HEAD
* [new branch] staging -> origin/staging
Already up-to-date.

# Pull from URL (not frequently used)
$ git pull staging
* branch staging -> FETCH_HEAD
* [new branch] staging -> origin/staging
Already up-to-date.

4. git push: The command git push is applied to transfer the commits or pushing the content from the local repository to the remote repository. After a local repository has been changed, and the changes are to be shared with the remote team members then this command is used. And this git push command needs two parameters: the remote repository and the branch that the push is for.


$ git push <remote_URL/remote_name> <branch>

# Push all local branches to remote repository
$ git push —all

In Practice:

# Push a specific branch to a remote with named remote
$ git push origin staging
Counting objects: 5, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (3/3), done.
Writing objects: 100% (5/5), 734 bytes | 0 bytes/s, done.
Total 5 (delta 2), reused 0 (delta 0)
ad189cb..0254c3d SecretTesting -> SecretTesting

# Push all local branches to remote repository
$ git push --all
Counting objects: 4, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (4/4), done.
Writing objects: 100% (4/4), 373 bytes | 0 bytes/s, done.
Total 4 (delta 2), reused 0 (delta 0)
remote: Resolving deltas: 100% (2/2), completed with 2 local objects.
0d56917..948ac97 master -> master
ad189cb..0254c3d SecretTesting -> SecretTesting

A Few Other Advanced Git Commands

1. git diff: This command shows the file differences which are not yet staged. It also discovers the conflicts against the base file. However, it previews modifications before merging:

git diff
git diff --base <filename>
git diff <sourcebranch> <targetbranch>
git diff –staged

2. git reset:

If you want to unstage the file, then make use of this command. But most importantly, it preserves the file contents.

git reset [file]

The following git reset command discards all history and goes back to the specified commit.

git reset –hard [commit]

Must check the complete details about git reset – hard from this tutorial ie., How To Git Reset to HEAD

3. git stash: The git stash command takes your modified tracked files and saves them on a pile of unfinished changes that you can reapply at any time. To go back to work, you can use the stash pop. Also, It will benefit a developer in switching branches to work on something else without committing to incomplete work. Do you know how to git stash changes can be performed? If not, access the available link.


# Store current work with untracked files
$ git stash -u

# Bring stashed work back to the working directory
$ git stash pop

4. git rm: This rm command is used to remove files or directories from the working index (staging area). With git rm, there are two options to keep in mind: force and cached.

Running the command with force deletes the file. The cached command extracts the file from the working index. When deleting an entire directory, a recursive command is necessary.


# To remove a file from the working index (cached):
$ git rm --cached <file name>

# To delete a file (force):
$ git rm -f <file name>

# To remove an entire directory from the working index (cached):
$ git rm -r --cached <directory name>

# To delete an entire directory (force):
$ git rm -r -f <file name>

5. git log: The git log command gives the order of the commit history for a repository. The command aids in getting the state of the current branch by showing the commits that lead to this state.


# Show entire git log
$ git log

# Show git log with date pameters
$ git log --<after/before/since/until>=<date>

# Show git log based on commit author
$ git log --<author>="Author Name"

6. git show: This command displays the metadata and content changes of the defined commit.

git show [commit]

7. git tag: The tag command is used to provide tags to the defined commit.

git tag [commitID]

Some Other Git Tag Articles: 

High-level commands (porcelain) of GIT

We divide the porcelain commands into the main commands and some ancillary user utilities. They are as listed below:

1. Main porcelain commands

  • git-add: Add file contents to the index
  • git-am: Apply a series of patches from a mailbox
  • git-archive: Create an archive of files from a named tree
  • git-bisect: Use binary search to find the commit that introduced a bug
  • git-branch: List, create or delete branches
  • git-bundle: Move objects and refs by archive
  • git-checkout: Switch branches or restore working tree files
  • git-cherry-pick: Apply the changes introduced by some existing commits
  • git-citool: Graphical alternative to git-commit
  • git-clean: Remove untracked files from the working tree
  • git-clone: Clone a repository into a new directory
  • git-commit: Record changes to the repository
  • git-describe: Give an object a human readable name based on an available ref
  • git-diff: Show changes between commits, commit and working tree, etc
  • git-fetch: Download objects and refs from another repository
  • git-format-patch: Prepare patches for e-mail submission
  • git-gc: Cleanup unnecessary files and optimize the local repository
  • git-grep: Print lines matching a pattern
  • git-gui: A portable graphical interface to Git
  • git-init: Create an empty Git repository or reinitialize an existing one
  • gitk: The Git repository browser
  • git-log: Show commit logs
  • git-maintenance: Run tasks to optimize Git repository data
  • git-merge: Join two or more development histories together
  • git-mv: Move or rename a file, a directory, or a symlink
  • git-notes: Add or inspect object notes
  • git-pull: Fetch from and integrate with another repository or a local branch
  • git-push: Update remote refs along with associated objects
  • git-range-diff: Compare two commit ranges (e.g. two versions of a branch)
  • git-rebase: Reapply commits on top of another base tip
  • git-reset: Reset current HEAD to the specified state
  • git-restore: Restore working tree files
  • git-revert: Revert some existing commits
  • git-rm: Remove files from the working tree and from the index
  • git-shortlog: Summarize git log output
  • git-show: Show various types of objects
  • git-sparse-checkout: Initialize and modify the sparse-checkout
  • git-stash: Stash the changes in a dirty working directory away
  • git-status: Show the working tree status
  • git-submodule: Initialize, update or inspect submodules
  • git-switch: Switch branches
  • git-tag: Create, list, delete or verify a tag object signed with GPG
  • git-worktree: Manage multiple working trees

2. Ancillary Commands


  • git-config: Get and set repository or global options
  • git-fast-export: Git data exporter
  • git-fast-import: Backend for fast Git data importers
  • git-filter-branch: Rewrite branches
  • git-mergetool: Run merge conflict resolution tools to resolve merge conflicts
  • git-pack-refs: Pack heads and tags for efficient repository access
  • git-prune[1]: Prune all unreachable objects from the object database
  • git-reflog: Manage reflog information
  • git-remote: Manage set of tracked repositories
  • git-repack: Pack unpacked objects in a repository
  • git-replace: Create, list, delete refs to replace objects


  • git-annotate: Annotate file lines with commit information
  • git-blame: Show what revision and author last modified each line of a file
  • git-bugreport: Collect information for user to file a bug report
  • git-count-objects: Count unpacked number of objects and their disk consumption
  • git-difftool: Show changes using common diff tools
  • git-fsck: Verifies the connectivity and validity of the objects in the database
  • git-help: Display help information about Git
  • git-instaweb: Instantly browse your working repository in gitweb
  • git-merge-tree: Show three-way merge without touching index
  • git-rerere: Reuse recorded resolution of conflicted merges
  • git-show-branch: Show branches and their commits
  • git-verify-commit: Check the GPG signature of commits
  • git-verify-tag: Check the GPG signature of tags
  • gitweb: Git web interface (web frontend to Git repositories)
  • git-whatchanged: Show logs with difference each commit introduces

Interacting with Others

These commands are to interact with foreign SCM and with other people via patch over e-mail.

  • git-archimport: Import a GNU Arch repository into Git
  • git-cvsexportcommit: Export a single commit to a CVS checkout
  • git-cvsimport: Salvage your data out of another SCM people love to hate
  • git-cvsserver: A CVS server emulator for Git
  • git-imap-send: Send a collection of patches from stdin to an IMAP folder
  • git-p4: Import from and submit to Perforce repositories
  • git-quiltimport: Applies a quilt patchset onto the current branch
  • git-request-pull: Generates a summary of pending changes
  • git-send-email: Send a collection of patches as emails
  • git-svn: Bidirectional operation between a Subversion repository and Git

Git Reset, restore, and revert Commands

The commands that are with the same names are these three: git reset, git restore, and git revert. So, check out their usage from below:

  • git-revert is about making a new commit that reverts the changes made by other commits.
  • git-restore is about restoring files in the working tree from either the index or another commit. It won’t update your branch but it restores files in the index from another commit.
  • git-reset is about updating your branch, moving the tip in order to add or remove commits from the branch. This operation changes the commit history. Also, it helps in restoring the index, overlapping with git restore.

Low-level commands (plumbing) of Git

Even though Git holds its own porcelain layer, its low-level commands are enough to support the development of alternative porcelains. The following information separates the low-level commands or plumbing Git commands into manipulation objects commands (in the repository, index, and working tree), interrogation commands, and commands that move objects and references between repositories.

Manipulation commands

  • git-apply: Apply a patch to files and/or to the index
  • git-checkout-index: Copy files from the index to the working tree
  • git-commit-graph: Write and verify Git commit-graph files
  • git-commit-tree: Create a new commit object
  • git-hash-object: Compute object ID and optionally creates a blob from a file
  • git-index-pack: Build pack index file for an existing packed archive
  • git-merge-file: Run a three-way file merge
  • git-merge-index: Run a merge for files needing merging
  • git-multi-pack-index: Write and verify multi-pack-indexes
  • git-mktag: Creates a tag object with extra validation
  • git-mktree: Build a tree-object from ls-tree formatted text
  • git-pack-objects: Create a packed archive of objects
  • git-prune-packed: Remove extra objects that are already in pack files
  • git-read-tree: Reads tree information into the index
  • git-symbolic-ref: Read, modify and delete symbolic refs
  • git-unpack-objects: Unpack objects from a packed archive
  • git-update-index: Register file contents in the working tree to the index
  • git-update-ref: Update the object name stored in a ref safely
  • git-write-tree: Create a tree object from the current index

Interrogation commands

  • git-cat-file: Provide content or type and size information for repository objects
  • git-diff-files: Compares files in the working tree and the index
  • git-cherry: Find commits yet to be applied to upstream
  • git-for-each-ref: Output information on each ref
  • git-diff-index: Compare a tree to the working tree or index
  • git-diff-tree: Compares the content and mode of blobs found via two tree objects
  • git-for-each-repo: Run a Git command on a list of repositories
  • git-get-tar-commit-id: Extract commit ID from an archive created using git-archive
  • git-ls-files: Show information about files in the index and the working tree
  • git-ls-remote: List references in a remote repository
  • git-ls-tree: List the contents of a tree object
  • git-merge-base: Find as good common ancestors as possible for a merge
  • git-name-rev: Find symbolic names for given revs
  • git-pack-redundant: Find redundant pack files
  • git-rev-list: Lists commit objects in reverse chronological order
  • git-rev-parse: Pick out and massage parameters
  • git-var: Show a Git logical variable
  • git-show-index: Show packed archive index
  • git-unpack-file: Creates a temporary file with a blob’s contents
  • git-show-ref: List references in a local repository
  • git-verify-pack: Validate packed Git archive files

In general, the interrogate commands do not touch the files in the working tree.

Syncing repositories

  • git-daemon: A really simple server for Git repositories
  • git-http-backend: Server side implementation of Git over HTTP
  • git-fetch-pack: Receive missing objects from another repository
  • git-update-server-info: Update auxiliary info file to help dumb servers
  • git-send-pack: Push objects over Git protocol to another repository

The following are helper commands used by the above; end users typically do not use them directly.

  • git-http-fetch: Download from a remote Git repository via HTTP
  • git-http-push: Push objects over HTTP/DAV to another repository
  • git-upload-archive: Send archive back to git-archive
  • git-upload-pack: Send objects packed back to git-fetch-pack
  • git-receive-pack: Receive what is pushed into the repository
  • git-shell: Restricted login shell for Git-only SSH access

Internal helper commands

These are internal helper commands used by other commands; end users typically do not use them directly.

  • git-check-attr: Display gitattributes information
  • git-check-ignore: Debug gitignore / exclude files
  • git-check-mailmap: Show canonical names and email addresses of contacts
  • git-check-ref-format: Ensures that a reference name is well formed
  • git-column: Display data in columns
  • git-credential: Retrieve and store user credentials
  • git-credential-cache: Helper to temporarily store passwords in memory
  • git-credential-store: Helper to store credentials on disk
  • git-fmt-merge-msg: Produce a merge commit message
  • git-interpret-trailers: Add or parse structured information in commit messages
  • git-mailinfo: Extracts patch and authorship from a single e-mail message
  • git-mailsplit: Simple UNIX mbox splitter program
  • git-merge-one-file: The standard helper program to use with git-merge-index
  • git-patch-id: Compute unique ID for a patch
  • git-sh-i18n: Git’s i18n setup code for shell scripts
  • git-sh-setup: Common Git shell script setup code
  • git-stripspace: Remove unnecessary whitespace

Top 15 Common Git Interview Questions for Freshers & Expert Developers

Here is the list of top frequently asked and Basic Git interview questions that help freshers and experienced candidates to deal with tough interview rounds on Git and impress interviewers with your knowledge on git fundamentals. Refer to the below list of 15 best & common interview questions on git for cracking interviews:

  1. What is Git?
  2. What do you understand by the term ‘Version Control System’?
  3. What’s the difference between Git and GitHub?
  4. What is a Git repository?
  5. How can you initialize a repository in Git?
  6. Name a few Git commands with their function.
  7. What are the advantages of using Git?
  8. How do you resolve a merge conflict?
  9. What is the difference between fork, branch, and clone?
  10. Explain the git push command.
  11. What language is used in Git?
  12. Name some of the popular Git hosting repositories.
  13. Explain the git pull command.
  14. What is a commit message, and how is the commit command executed?
  15. Difference between git fetch and git pull.

Wrap Up

We believe the curated list of Git Commands in this tutorial aids you in understanding different concepts commands in Git with ease. After going through this entire guide, you will definitely become proficient in Git basics and their command-line usage. Also, you can get a good grip on some of the advanced commands as we have compiled with the syntax of each git command.

For more knowledge and expertise in the principles of Git, software engineering, project development, and other IT services such as Docker, Linux, Kigana, Grafana, etc. check out this website ie., 

In case you are wondering about some new queries in Git then let us know in the comment box and be familiar with all Git Commands to work like experienced ones and gain perfect results.