Formal Definition

Git is a free, open-source distributed version control system (VCS) designed to track changes in source code during software development.

In English

• A tool that can save the state of our project,from adding a semicolon to a file, to writing hundreds of lines of code.
• Whenever we think this should be saved, we can!
• And whenever we need to see that version, we can!
• Whenever we need to use that version or do changes to it and save again, we can!
• We can save n number of versions of our project and each version can be just as simple as a space char inclusion in a file!
• All of this without taking lot of space in hard disk

Getting and Setting-Up Git

Check the official website: https://git-scm.com/

How It Works

1. First you initialize a directory as git repo (repository):
   • You do git init
   • Git creates a .git hidden folder in current directory
   • This .git folder is what makes your folder a repo and gives those magical powers to see the history and versions of your project.
   • If, by any chance, you delete that .git folder, you will loose all the project history, unless you pushed your changes to github!
2. You ask git, what is the status of the project:
   • You do git status
   • Git says on branch main, and then shows some filenames in red and says "Untracked files" (if you have files in your repo)
   • That simply means git is working and its asking to save the changes if you are done working on them
   • The branch thing is explained in the Core Concepts section
3. You ask git to take a screenshot of the changed files:
   • You do git add filename.something or git add .
   • Git takes a screenshot of the specified files
   • Keep in mind,the screenshot is not saved yet
   • Its like print screen on pc, we get a window that asks to save it or discard!
4. You ask git to save the screenshot:
   • You do git commit -m "Some message about the changes!"
   • Git saves the screenshot into the project history
   • Each screenshot saved is called a commit
   • Each commit has a hash
   • That hash is like a name, that we can refer, to ask git to get that version or commit to us
5. You can view all the commits or versions:
   • You do git log
   • Git will show all the commits list with details like: Who,when, commit hash, commit message, etc!

This is the basic working!

Core Concepts

User

• Each commit will include information about the person who made the commit
• That is the username and email address of the person
• This helps others or yourself in future, that who made the commit
• The User is simply a person with username and email set in the git configuration
• This is done by setting the username and password in git like this:

git config --global user.name "Your Name"

git config --global user.email "your.email@example.com"

Branches

• All your commits from first one to the last one are like a rope
• You can see the timeline of the commits straight
• This timeline rope is a branch, just like the branch of a tree
• It starts at the root, first commit, then grows!
• By default, the root or main branch is called main
• Now, if you have an experimental feature that you don't want to save to the current timeline or branch, but still want to save its changes and later when it works fine, want to join it to the current timeline of commits or branch
• For this we have branches and merging
• You can create a branch, do changes to the repo and save them into its own rope of commits
• Later when you want to, you can add it to the main branch, that is to merge the branch with the main branch
• You can make as many branches as you want
• But merging branches with lot of changes and commits is an advanced topic!

GitHub (Pushing/Pulling)

• Although git is helping save our projects's history, the history of our project is still living on our hard disk
• If we loose it then bang!
• And if someone else wants to collaborate with us on the project, they don't have access to our repo on our pc
• To solve these issues, we have GitHub, a repo hosting platform, where we can save our repo history
• When you make new commits you send them to github that is to push changes up!
• Anyone having access to your github repo can send their changes (commits) to the repo on github and we can get or pull those changes back to our local pc repo

The Usual Flow of Commands

1) Initialize a git repo

git init

2) Check status

git status

3) Add changes to the staging area (just a fancy term, you know what it does)

git add .

or

git add specific_file.something specific_file2.something ...

4) Save changes

git commit -m "My first commit with changes"

5) Checking and pulling new changes from GitHub

git pull

6) Pushing changes to GitHub

git push origin main

or

git push

7) See the history

git log

Caution For Beginners

• While using the command: git add ., git tracks everything in you repo folder including any sensitive information
• And when you push it to GitHub, if its a public repo, then the whole world can get access to that information
• So, do not put any sensitive information like passwords, tokens, api keys etc in your repo!
• And mostly use git add with explicit filenames rather than "."

Note: I skipped the topics like: how to setup github account and make repos and add local repo's pushing destination to github repo, etc
Those, I think, you can learn on your own, once you get the basics!
(AI is also there for your help!)

Where to go from here?

I found this video very helpful while learning:
https://www.youtube.com/watch?v=apGV9Kg7ics
And the official git book:
https://git-scm.com/book/en/v2/Getting-Started-About-Version-Control