Git & Version Control - bounswe/bounswe2025group8 GitHub Wiki

1. What is Version Control?
2. What is Git?
3. How Does Git Work?
4. Fetching and Merging Updates
5. Merge Conflicts and Resolutions
6. Git Workflows
7. Best Practices
8. Common Git Commands
9. References

Version control, also known as source control, is the practice of tracking and managing changes to software code. It allows developers to:
✔️ Keep a history of changes
✔️ Collaborate effectively
✔️ Revert to previous versions if needed

In CVCS (e.g., CVS, Subversion, Perforce):

• A single server stores all the versioned files.
• Clients check out files from the central server.
• Easy to administer but has a single point of failure.

✅ Pros: Simpler to manage
❌ Cons: If the server crashes, you lose everything without proper backups

In DVCS (e.g., Git, Mercurial, Darcs):

• Every developer has a complete copy of the repository, including history.
• No reliance on a central server for history tracking.
• Any client can restore a lost server.

✅ Pros: No single point of failure, faster local operations
❌ Cons: Slightly higher learning curve

Git is the most widely used modern version control system, originally developed by Linus Torvalds in 2005.
✔️ Fast and distributed version control
✔️ Used for managing collaborative development
✔️ Tracks code history efficiently

Unlike older VCS (like SVN), Git:

• Stores snapshots of the entire project at each commit instead of just differences.
• Saves space by referencing unchanged files rather than duplicating them.
• Makes history tracking and branching more efficient.

Git tracks files in three states:

🔹 Three Key Areas in a Git Project:

• Working Tree: Your local files (modified state)
• Staging Area: Prepares selected changes for commit
• Git Directory: Stores metadata and history

1. Modify files in your working tree.
2. Stage specific changes (git add).
3. Commit the changes (git commit).
4. Push them to a remote repository (git push).

When collaborating, you need to keep your branch updated with the latest remote changes.

git fetch downloads changes from the remote repository without merging them:

git fetch origin

This updates your remote-tracking branches but does not affect your working branch.

To merge fetched updates into your local branch:

git merge origin/main

Alternatively, use git pull to fetch and merge in one step:

git pull origin main

A merge conflict happens when two branches modify the same part of a file. Git cannot automatically merge these changes.

When a conflict occurs, Git stops the merge and shows a message like this:

Auto-merging file.txt  
CONFLICT (content): Merge conflict in file.txt  
Automatic merge failed; fix conflicts and then commit the result.  

When you open the conflicted file, Git marks the conflicting sections like this:

<<<<<<< HEAD
Your version of the file.
=======
Other branch's version of the file.
>>>>>>> feature-branch

• <<<<<<< HEAD → This section contains the changes from your current branch (the one you’re on).
• ======= → This separates your changes from the incoming changes.
• >>>>>>> feature-branch → This section contains the changes from the branch you are merging in.

1. Open the conflicted file and decide which changes to keep.
2. Manually edit the file, keeping the correct version.
3. Mark it as resolved with:

git add file.txt

4. Complete the merge with:

git commit -m "Resolved merge conflict in file.txt"

If you want to cancel the merge and revert to the last known good state:

git merge --abort

Different teams follow different Git workflows based on project needs:

1. Centralized Workflow:

   • Everyone commits directly to main.
   • Simple but can cause conflicts.

2. Feature Branch Workflow:

   • Developers create branches for features.
   • Merge via Pull Requests (PRs).

3. Git Flow (Advanced Workflow):

   • Uses multiple branches: main, develop, feature, release, hotfix.
   • Useful for large teams and structured development.

4. Forking Workflow:

   • Used in open-source projects.
   • Developers fork a repo, make changes, and submit Pull Requests.

✔️ Commit often – Small, frequent commits help track changes.
✔️ Pull latest changes before working – Prevents conflicts.
✔️ Write clear commit messages – Explain why the change was made.
✔️ Use branches – Keep main clean and use feature branches.
✔️ Agree on a workflow – Follow team conventions.

For details and examples of commands, visit our Git Commands Wiki Page.

1. Git Documentation
2. Pro Git Book
3. Atlassian Git Tutorials