1.git init

It is used for initializing the git version control system for the project. After this git manages the record of each and every lines of codes changed in a project. By default there is no name for the current branch of repository, basically the branch name is depend on the git server where toy are storing your project code. Most of platforms like GitHub, GitLab, etc. uses main as their default branch name where as SourceForge uses master as default branch name.

git init

2.git add

Git add is used to stage the changes for commit. It basically means whenever a commit happens for string the current code consider all the staged files for saving the current progress.

Example:

git add file.js  # Stage a specific file
git add . # Stage all files changed

3.git commit

Commit command stores/save the current changes of project such that in future if mistakenly the project is deleted or the there you found a bug in previous committed code then restoration of code can possible.

For best practice always commit the code with some messages using :

git commit -m “<your-message>”

This will help while looking for the commit for rolling back to a specific code version.

4.git revert

Revert is used to commit a history safely with removing the code of specific commit. It can also called as “safe rollback” because it safely remove the code of a specific commit and whole code flow remains as it is.

# Syntax 
git revert <commit_hash>

#Example 
git revert xyz986

5.git reset

Git reset moves the current project head back to a specific mentioned commit.

There are mainly 3 ways to reset:

git reset --soft HEAD~1   # Keeps changes staged
git reset --mixed HEAD~1  # Keeps changes unstaged (default)
git reset --hard HEAD~1   # Discards changes completely

NOTE: Use git reset carefully specially git reset --mixed as it can remove all the changes done till in the project. There is no way back after git reset --hard.

6.git log

Git log gives the all the history of commit activity done on project. It mainly shows commit hash, commit message, author name and date of commit. All the logs is in reverse chronological order.

$ git log # command

# Sample output
commit 2e9fa773a7b8b21cad7923978a1e84ebb751b745 (HEAD -> master) #Hash
Author: Nikhil Nandanwar <email@email.com> #Author name and email
Date:   Thu Jan 8 11:57:29 2026 +0530  # Date and time
    Add initial implementation of chat application with WebRTC functionality # Commit message

commit 17250d504e338e498ad0289462a8cb2d56cfc0e7
Author: Nikhil Nandanwar <email@email.com>
Date:   Tue Jan 6 22:38:53 2026 +0530
    Remove legacy chat application files including package.json, server.js, and style.css

commit 8fcdf3b637fe4aa8faa90e16bcf4d5d55fd08c92
Author: Nikhil Nandanwar <email@email.com>
Date:   Tue Jan 6 22:32:50 2026 +0530
    initial commit: add basic structure for chat application with WebRTC functionality

7.git diff

Git diff is used to see the difference between the two files like what is actually changed in that code compared to last commit. It can be used for comparison of two files, commits or branches shows the added code with the green highlight and remove code with red highlight, helping user to see clear difference between the two.

git diff              # Unstaged changes
git diff --staged     # Staged changes

8.git status

Git status tells the status of each files and current working directory by marking files as modified, staged, untracked, or ready to be committed.

git status

9.git branch

Git branch is used for creating another branch of current project flow, with having all the previously added code in it. It mainly helps for parallel working without affecting the code of other branches.

git branch # List all branches
git branch feature-login # Create a new branch
git branch -d feature-login # Delete a branch

10.git checkout

Git checkout is mainly used for getting the code of other branches of the current project. It helps to quickly switch between two branches and check the progress of each branches or compare the two.

git checkout main            # Switch branch
git checkout abc123          # Checkout a specific commit

Checkout is also useful for restoring the code of a file to it’s previous version.

git checkout -- file.txt     # Restore a file

This are the 10 commands that will help you in your software development journey and I am open for your feedback or suggestions about the blog.

Thank you for reading the blog, this is Nikhil Nandanwar.

Without Git, developers would face significant challenges in managing changes to the codebase. Collaboration among team members would become largely difficult, as there would be no efficient way to track who made specific changes or to merge contributions from different developers seamlessly. This could lead to conflicts and errors, as multiple versions of the code might exist without a clear way to reconcile them.

Moreover, without a version control system like Git, reverting to previous versions of the code in case of errors or bugs would be difficult or impossible. Developers would have to manually keep track of changes, which is not only time-consuming but also prone to human error. This could result in lost work and decreased productivity.

Git also provides a robust framework for branching and merging, allowing developers to experiment with new features or fixes in isolated environments without affecting the main codebase. This capability encourages innovation and reduces the risk of introducing bugs into the production environment.

Creating Software Without Git

In a company, there are often numerous developers collaborating on the same project. Without Git, they might have no better choice than using physical storage devices like USB drives to store and share the project's code. While USB drives are portable and can transfer data quickly, this method introduces several challenges. Each developer would need to manually copy the latest version of the code onto their drive, which could lead to inconsistencies if someone forgets to update their version (like final, final_v2, latest_final). Additionally, coordinating changes becomes difficult, as developers must ensure they are not overwriting each other's work. This process is not only time-consuming but also increases the likelihood of errors, such as accidentally losing important code changes or creating conflicting versions. Overall, relying solely on USB drives for code sharing in a multi-developer environment can significantly hinder productivity and collaboration.

So, imagine a scenario where Dev1 creates a new feature and saves it onto a USB drive as a version named final_v1. Then, Dev1 hands the USB drive to Dev2, who makes changes and adds another feature to the same drive as final_v2. This process continues as the USB drive is passed along to the next developer who needs to add their code. Each developer must wait their turn to access the USB drive, which can slow down the entire development process.

There's also a scenario where all developers are working on the same feature and they make changes in almost the same files. So, when combining the entire project code implementations of all the developers, there is a chance of overriding code or undetectable merge conflicts, which can cause unusual behavior of the project software or an outage, which can cost the company.

How Git solves the problems?

Git is a version control system which keeps tract of all the changes occurred in software from the beginning of project with the customization messages given by the developing team for marking the type of work done till. Git is developed by @Linus__Torvalds as side project for managing and keeping track of the Linux codebase.

Git is designed to efficiently track every single line of code that is changed across different branches of a project. Unlike traditional methods that might require duplicating the entire codebase, Git manages to do this without creating multiple copies of the code. This approach makes Git both lightweight and fast, allowing it to keep a detailed history of changes without consuming excessive storage space. Each change is recorded with precision, enabling developers to easily review, compare, and manage the evolution of their files over time. This capability is crucial for maintaining an organized and efficient workflow, especially in collaborative environments where multiple developers are working on different parts of the project simultaneously.

Short Comparison