Q1. What is Git, and how does it work internally?

A Git repository stores all project versions and history. It contains commits, branches, tags, and configuration files.

The .git folder holds metadata and object storage. Each commit references a snapshot of files and previous commits.

This structure enables fast branching and merging.

Branches allow developers to work on features independently.

Each branch points to a specific commit. Git creates lightweight branches without copying files.

Once work is complete, branches are merged back into the main branch.

Branching supports parallel development and safer collaboration.

GitHub provides remote repositories for sharing code. Developers push changes and create pull requests.

Pull requests enable code review, discussion, and testing before merging. GitHub also tracks issues, commits, and contributors.

This makes team collaboration structured and transparent.

Git manages code history, while GitHub manages collaboration.

clone is for starting, pull is for syncing.

fetch is safer for reviewing changes before merging.

Private repos are preferred for company code.

Version control tracks changes in code over time. It allows rollback to previous versions. It helps teams collaborate without conflicts.

Git is the most popular version control system today. It improves code safety and productivity.

A commit in Git is a saved snapshot of your project at a specific point in time.

Whenever you make changes and commit them, Git records those changes permanently in the repository history.

It helps you track what was changed, when it was changed, and who made the change.

Key Points:

• A commit stores the current state of tracked files.
• Each commit has a unique hash ID.
• It includes a commit message, author name, and timestamp.
• Commits create the project’s version history.
• Small and meaningful commits are considered best practice.

Example Situation:

• You fix a login bug → make a commit: “Fix login validation error”
• You add a new feature → make a commit: “Add user dashboard page”
• You update UI styling → make a commit: “Improve navbar design”

Good commits make it easier to understand project progress and roll back changes if needed.

git status is used to check the current state of your working directory and staging area.

It shows which files have been modified, which files are staged for commit, and which files are untracked.

This helps you understand exactly what changes are ready to be committed and what is still pending.

Key Points:

• Shows modified files that are not yet staged
• Shows files added to the staging area
• Displays untracked (new) files
• Helps prevent accidental commits
• Used frequently before running git commit

The git status command is used to check the current condition of your repository. It shows what is happening in your working directory and staging area before you make a commit.

When you run git status, Git tells you:

• Which files have been modified but not staged
• Which files are staged and ready to be committed
• Which files are untracked (new files Git is not tracking yet)
• Which branch you are currently working on

This command is very important because it helps you review your changes before committing. It reduces the chances of accidentally committing the wrong files or forgetting to add important changes.

In real development, programmers use git status frequently — usually before every commit — to stay aware of the project’s current state. That’s why it is considered one of the most commonly used Git commands.

The command git commit -m is used to create a new commit along with a message written directly in the terminal.

The -m flag stands for message, and it allows you to describe the changes you are saving in that commit.

When you run this command, Git takes all the staged changes and saves them as a snapshot in the repository history. The message you provide explains what was changed and why.

Key Points:

• Creates a commit from staged files
• Adds a commit message in the same command
• Saves changes permanently in project history
• Helps track what was modified in each update

Clear and meaningful commit messages are important because they make the project history easy to understand. In team projects, good commit messages improve collaboration and make debugging much easier.

A branch is an independent line of development. It allows working on features without affecting main code.

Branches are cheap and fast. Most workflows use feature branches.

Branching improves stability and productivity.