Questions about Git/Github for version control

1. Scenario: You are working on a team project, and you are assigned to
develop a new feature on a branch named feature-X. Meanwhile,
another teammate, Alex, is working on a different feature on feature-Y.
After completing your task, you push your changes to the feature-X
branch and create a pull request to merge into the main branch.
However, when you attempt to merge your branch into the main
branch, a merge conflict arises between your changes and Alex's
changes (which have already been merged into the main branch).
Question: How would you resolve this merge conflict locally using Git?
Once the conflict is resolved, how will you ensure that your branch is
successfully merged into the main branch without overwriting Alex's
work?

2. • Resolving the Merge Conflict Locally:
• Step 1: First, ensure you're on the feature-X branch:
git checkout feature-X
Step 2: Fetch the latest changes from the remote repository to ensure
your local repository is up-to-date:
git fetch origin

3. • Step 3: Pull the latest changes from the main branch into your current
branch to bring in Alex's changes:
git pull origin main
This will likely result in a merge conflict, and Git will inform you about
the conflicting files.
Step 4: Identify the conflicting files by running:
git status

4. • The conflicting files will be shown with markers indicating the sections
that differ between your branch (feature-X) and the main branch
(which contains Alex's changes).
• Step 5: Open each conflicting file and manually resolve the conflicts.
Git uses the following format to highlight conflicts:
• <<<<<<< HEAD [Your changes on feature-X] ======= [Changes from
main (Alex's changes)] >>>>>>> main

5. • Step 6: Mark the conflict as resolved by adding the files to the staging
area:
• git add <conflicted-file>
• Step 7: Complete the merge by committing the resolution:
• git commit
• Ensuring a Successful Merge without Overwriting Alex’s Work:
• Step 8: Push the resolved changes to the feature-X branch:
• git push origin feature-X

6. Scenario
• You are working on a small project and have made some changes to a
file called app.py on your local machine. You realize that you forgot to
create a new branch for the feature you're working on and have been
committing changes directly to the main branch.

7. • Create a new branch called feature/auth for the authentication
feature.
• Move all the commits related to app.py from the main branch to the
new branch feature/auth.
• Ensure that the main branch no longer contains any of the changes
from app.py.
• Switch to the feature/auth branch to continue working on the
authentication feature.

8. • 1. Create a new branch called feature/auth:
git checkout -b feature/auth
2. Move all commits related to app.py from the main branch:
git checkout main
# Reset the last commit on the main branch
git reset HEAD~1

9. • 3. Ensure main no longer has the changes:
• # Switch back to the feature/auth branch
• git checkout feature/auth
• # Add the changes to the staging area
• git add app.py
• # Commit the changes to the new branch
• git commit -m "Move authentication logic to feature/auth"

10. • 4. Verify and continue working:
• # Switch back to the main branch
• git checkout main
• # Check the status and log
• git status
• git log

11. Scenario
• You are working on a small project in the main branch and have made
some changes to a file called index.html. Before committing your
changes, you realize that you forgot to include another file (style.css)
in your changes.

12. • Stage the changes you made to both index.html and style.css.
• Commit the changes with a meaningful commit message.
• Push the changes to the remote repository.

13. • # Stage the changes made to index.html and style.css
• git add index.html style.css
• Or
• # Stage all the changes
• git add .

14. • # Commit the changes with a descriptive message
• git commit -m "Updated index.html and added style.css for layout
improvements“
• # Push the changes to the remote repository
• git push origin main

15. Scenario
• You are working on the main branch of your project. You accidentally
made some changes to the file app.js that you don't want to keep.
The changes are not yet staged or committed. You now want to:
• Discard the changes made to app.js and revert it back to the last
committed state.
• Check the Git status to ensure there are no pending changes.
• Pull the latest changes from the remote repository.

16. • # Discard changes in app.js
• git checkout -- app.js
• git restore app.js
• # Check the status of the working directory
• git status
• # Pull the latest changes from the remote repository
• git pull origin main

17. • Scenario:
• You are working on a group project with your team, and the project is
hosted on a remote Git repository (e.g., GitHub). Each team member
is responsible for different features. Below is a series of events that
occurs as you work on the project:
1.You have been tasked with creating a new feature called "user-login."
2.Another team member is working on a "user-profile" feature and
pushed their changes to the remote repository.
3.After some progress, you realize you made a mistake in one of your
previous commits and need to correct it.
4.Finally, after completing your feature, you need to merge your
changes with the main branch, ensuring no conflicts exist between
the "user-profile" and "user-login" features.

18. • Starting your feature:
• git checkout -b user-login
• Syncing with the latest changes:
• git fetch origin
• git checkout main
• git pull origin main
• Fixing a mistake in the commit:
• git commit --amend

19. • Pushing changes to the remote repository:
• git push origin user-login
• Merging and handling conflicts:
• git checkout main
• git merge user-login
• git add <conflicting-file>
• git commit
• git pull origin main