Inno 3.2 Version Control

Question 1

What is a repository in Git?

Answer 1

A repository (repo) is a storage space for your project’s code, including all its history, branches, and commits.

Question 2

What is a commit in Git?

Answer 2

A: A commit is a snapshot of changes in your codebase. It records what was changed, when, and by whom.

SNAPSHOT OF CHANGES

Question 3

Q: What is a branch in Git?

Answer 3

A: A branch is an independent line of development, allowing you to work on features or fixes without affecting the main codebase.

Question 4

Q: What is a merge in Git?

Answer 4

A: Merging combines changes from one branch into another, usually integrating a feature branch back into the main branch.

Question 5

Q: What is a merge conflict?

Answer 5

A: A conflict occurs when Git can’t automatically combine changes from two branches — manual resolution is needed.

Question 6

Q: What does it mean to clone a repository?

Answer 6

A: Cloning creates a local copy of a remote repository so you can work with it on your machine.

Question 7

Q: What does pull do in Git?

Answer 7

A: git pull fetches and integrates changes from a remote repository into your current local branch.

Question 8

Q: What does push do in Git?

Answer 8

A: git push sends your local commits to a remote repository.

Question 9

Q: What does fetch do in Git?

Answer 9

A: git fetch retrieves the latest commits from the remote but does not merge them into your local branch automatically.

RETRIVES THE LAST COMMITS BUT DOES NOT MERGES IT AUTOMATICLLY

Question 10

Q: What does git init do?

Answer 10

A: It initializes a new Git repository in your current folder.

Question 11

Q: What does git clone do?

Answer 11

A: It creates a local copy of an existing remote repository.

Question 12

Q: What does git add do?

Answer 12

A: It stages changes, preparing them to be committed.

Question 13

Q: What does git commit do?

Answer 13

A: It saves the staged changes to the local repository with a message.

Question 14

Q: What does git log show?

Answer 14

A: It displays the commit history of the current branch.

Question 15

Q: What does git branch do?

Answer 15

A: It lists, creates, or deletes branches.

Question 16

Q: What does git checkout do?

Answer 16

A: It switches between branches or restores files.

Question 17

Q: What does git merge do?

Answer 17

A: It integrates changes from one branch into the current branch.

Question 18

Q: What does git remote do?

Answer 18

A: It manages connections to remote repositories.

Question 19

Q: What does git push do?

Answer 19

A: It uploads your local commits to the remote repository.

Question 20

Q: What is the Git Flow branching model?

Answer 20

A: It uses branches like main, develop, feature/, and hotfix/ to manage release cycles and environments.

Question 21

Q: What is Trunk-Based Development?

Answer 21

A: All developers work on a single main branch with short-lived feature branches — encourages CI and fast delivery.

EVERYONE WORKS ON SINGLE BRANCH WITH SHORT LIVED FEATURE BRANCH

Question 22

Q: What are SSH keys in Git?

Answer 22

A: SSH keys authenticate you securely with remote Git servers without using a password every time.

Question 23

Q: How is access control typically handled in Git repositories?

Answer 23

A: With roles (e.g., read, write, admin) on platforms like GitHub/GitLab, often combined with branch protection rules.

Question 24

Q: What is rebasing in Git?

Answer 24

A: Rebasing moves or combines commits from one branch onto another to create a cleaner history.

Question 25

Q: When should you not rebase?

Answer 25

A: Avoid rebasing shared/public branches, as it rewrites history and can confuse collaborators.

Question 26

Q: What is stashing in Git?

Answer 26

A: git stash temporarily saves changes without committing them, allowing you to switch branches safely. SAVE CHANGES WITHOUT COMMITING

Question 27

Q: What does cherry-pick do in Git?

Answer 27

A: **It applies a specific commit from one branch onto another** — useful for hotfixes or isolated changes. APPLIES SPECIIF COMMITS

Question 28

Q: What is git squash?

Answer 28

A: **Squashing combines multiple commits into one to create a cleaner commit history before merging.** MERGING MULTIPLE COMMITS INTO ONE COMMIT BEFORE MERGING

Question 29

Q: How can Git be used for backups?

Answer 29

A: Pushing regularly to a remote repository acts as a backup. You can also clone repos to different machines.

Question 30

Q: What is the difference between merge and rebase, and when should you use each?

Answer 30

A: merge preserves the full history by creating a new commit that combines two branches, keeping the original commit structure. It's useful when working with a team, as it avoids rewriting history. **rebase rewrites the commit history by moving commits from one branch to another, creating a linear history**. It's great for cleaning up local commits before pushing. Use merge for shared branches, and rebase only for local or private ones to avoid conflicts with teammates.

Question 31

Q: What is an interactive rebase (git rebase -i) and what can you do with it?

Answer 31

A: git rebase -i allows you to interactively edit, squash, reorder, or remove commits before integrating them into another branch. It’s commonly used to clean up messy commit history before pushing or opening a pull request. With interactive rebase, you can: Combine multiple commits into one (squash) Edit a commit message (reword) Delete unnecessary commits Reorder commit sequence It's a powerful tool, but should be used with care. I CAN EDIT, SQUASH, REORDER

Question 32

Q: What is a Git hook, and what are some common use cases?

Answer 32

A: **A Git hook is a script that runs automatically in response to Git events**, such as committing, pushing, or merging. Git hooks are stored in the .git/hooks/ directory. Examples include: pre-commit: run linters/tests before allowing a commit pre-push: prevent push if tests fail commit-msg: enforce commit message format Hooks help enforce policies and automate checks locally, improving quality and consistency. SCRIPT THAT TUN AUTOMATICLY IN REPOSNE TO GIT EVENTS

Question 33

Q: What is the difference between pull and fetch + merge?

Answer 33

A: **git pull is a convenience command that performs git fetch followed by git merge in one step**. It updates your local branch with changes from the remote. git fetch alone downloads the changes but does not integrate them. This gives you more control to inspect or rebase instead of merging. Prefer fetch + rebase or fetch + merge for more predictable control over changes and avoiding unintended merges.

Question 34

Q: What is a detached HEAD in Git, and why does it matter?

Answer 34

A: **A detached HEAD means you are no longer working on a named branch, but on a specific commit**. **Any changes you make won't be saved to a branch unless you create one explicitly.** This is useful for reviewing past commits or building temporary changes, but dangerous if you forget to create a branch — you can lose changes when switching branches. To save work, run git checkout -b new-branch-name. NOT WORKING ON A BRANCH BUT ON A COMMIT

Question 35

Q: What is the purpose of git cherry-pick, and when should it be used?

Answer 35

A: git cherry-pick copies a specific commit from one branch and applies it to another. This is useful for applying bug fixes to multiple release branches, or reusing commits without merging full branches. However, it can complicate history and cause duplicate commits if used too much. It's best for selective, isolated commits, not regular workflow.

Question 36

Q: What is a squash merge, and what are its benefits?

Answer 36

A: **A squash merge combines all the commits from a feature branch into a single commit when merging to the main branch.** This makes the history cleaner and easier to read, especially when many small or intermediate commits exist. It's often used in projects that prefer a linear and meaningful commit history. The downside is that individual commit history from the branch is lost unless preserved elsewhere.

Question 37

Q: What are Git remotes and how are they managed?

Answer 37

A: Remotes are connections to remote repositories (e.g., on GitHub, GitLab). They allow you to sync changes between your local and remote repo. git remote add origin adds a remote git remote -v shows all remotes git remote set-url changes the remote URL You can use multiple remotes (e.g., origin, upstream) for working with forks or multiple sources.

Question 38

Q: What is the difference between reset, revert, and checkout?

Answer 38

A: reset changes the current branch's history (use with caution). revert creates a new commit that undoes the changes of a previous one, preserving history (safe for shared branches). checkout switches branches or restores files from a different commit. Use revert for undoing commits on shared branches, and reset only local

Question 39

Q: How does Git handle large files, and what is Git LFS?

Answer 39

A: Git struggles with large binary files because it tracks every version. Git LFS (Large File Storage) is an extension that stores large files (e.g., images, videos) outside the main repository, replacing them with small pointers in Git. This keeps the repository size manageable and speeds up clone/fetch operations. You need to install Git LFS separately and track files via git lfs track. USING GIT LARGE FILES STORAGE

Question 40

Q: What is a good branching strategy for a team?

Answer 40

A: Common strategies: Git Flow: Feature branches, release branches, hotfixes — great for structured releases. GitHub Flow: Short-lived feature branches, merged to main via pull requests — best for continuous deployment. Trunk-Based: Everyone commits to main, with short-lived branches — best for fast-moving, automated CI/CD environments. The right choice depends on your team's size, release frequency, and CI setup.

Question 41

Q: What is a rebase conflict and how is it resolved?

Answer 41

A: A rebase conflict occurs when rebasing and Git can't auto-apply changes on top of the new base. You must resolve the conflict manually, then continue with git rebase --continue. If things go wrong, you can abort with git rebase --abort. Rebase conflicts are more common than merge conflicts because rebase re-applies each commit one by one.

Question 42

Q: Why is it important to keep branches short-lived?

Answer 42

A: Short-lived branches: Reduce merge conflicts Make code reviews faster Encourage regular integration Prevent divergence from main This aligns well with CI/CD practices and increases team productivity.

Question 43

Q: How can Git be used to recover lost commits?

Answer 43

A: Git keeps history through references and the reflog. If a commit is lost (e.g., after a reset), you can recover it using git reflog to find the commit hash and then git checkout or git branch recover . Git never deletes commits immediately — they're usually recoverable within a short time.

Question 44

Q: What’s the purpose of git stash and when should you use it?

Answer 44

A: git stash temporarily saves uncommitted changes so you can switch branches or pull updates without committing. It's useful when you're mid-work but need to pause or test something else. You can later apply it with git stash apply or pop it with git stash pop.

Question 45

4 got stages are

Answer 45

1. modified 2. unmodified 3. staged 4. commited