How to Handle and Resolve Conflicts in Git

In this post, we’re going to tackle a common roadblock in Git: conflicts. Don’t worry; I’ll make this as simple as buttered toast!

Understand What Conflicts Are and Why They Occur

Conflicts, in Git, happen when two people make changes to the same part of a file in two different branches.

Imagine it like this: you and your friend both try to decorate the same cake with different toppings at the same time. Conflict time!

Why Conflicts Occur:

  1. Parallel Universe Syndrome: When multiple people are working on the same project, it’s like everyone’s cooking in their own kitchen. Sometimes, you both reach for the salt shaker at the same time.
  2. No Mind Reading: Git doesn’t have mind-reading superpowers. It doesn’t know whose topping should go on the cake. So, it’s like, “Hold up, I need help deciding.”

Learn How to Resolve Conflicts When Merging Branches

Resolving Conflicts is all about making that cake look beautiful again after at least two people mixed up stuff over it, and Git gives you the tools.

Just follow these steps.

  1. Identify the Conflict: Git tells you which files have conflicts. Open those files in a text editor.
  2. Find the Conflict Markers: Look for lines like <<<<<<<, =======, and >>>>>>>. They show where the conflict starts and ends.
  3. Make a Decision: Decide which topping to keep or how to combine them.
  4. Remove Conflict Markers: Delete the markers and unwanted code.
  5. Save the File: Save your changes in the text editor.
  6. Add and Commit: After resolving conflicts, add the file and commit it.

That’s it! You’ve just solved a Git conflict like a pro baker!

Remember, conflicts are just part of the collaborative coding journey, and learning to resolve them is a crucial skill.


Question 1: What are conflicts in Git?

a) Friendly disagreements between developers.
b) Events where Git refuses to work.
c) Issues that occur when two people edit the same part of a file in different branches.
d) Errors that happen when Git runs out of memory.

Question 2: Why do conflicts occur in Git?

a) Because Git loves drama.
b) Because two people can edit the same part of a file in different branches.
c) Because Git doesn't like your code.
d) Because conflicts are random and unpredictable.

Question 3: When you encounter a conflict, what do you need to do first?

a) Panic and close your computer.
b) Shout at Git for causing the conflict.
c) Identify the conflict and open the affected file.
d) Automatically choose your code over others'.

Question 4: What do the conflict markers <<<<<<<, =======, and >>>>>>> indicate in a conflicted file?

a) They indicate your best friend's code.
b) They're just random symbols.
c) They show the start and end of the conflict and the dividing line between conflicting code.
d) They are secret Git codes.

Question 5: After resolving a conflict, what should you do next in Git?

a) Make a new conflict.
b) Ignore the changes.
c) Add the file, commit the changes, and carry on coding.
d) Uninstall Git.

1c – 2b – 3c – 4c – 5c

Teamwork Made Easy: Using Git for Collaborative Development

In this lesson, we’ll dive into the world of collaborative development using Git. We’ll explore remote repositories and learn how to clone, push, and pull changes to and from them.

Introduce the Concept of Remote Repositories

A remote repository is a Git repository hosted on a server, typically on the internet or a network. It allows multiple developers to collaborate on a project by sharing their changes with one another. Here’s why remote repositories are crucial:

  • Collaboration: Developers working on the same project can access and contribute to the codebase from different locations.
  • Backup: Remote repositories serve as a backup, protecting your project’s history from data loss.
  • Version Control: They provide a central location for tracking changes made by different team members.

Clone a Repository from a Remote Source

Cloning a Repository (git clone):

  • To clone a remote repository to your local machine, use the git clone command, followed by the repository’s URL:
git clone
  • This command creates a local copy of the remote repository, allowing you to work on it and collaborate with others.

Push and Pull Changes from/to Remote Repositories

Pushing Changes to a Remote Repository (git push):

Once you’ve made local commits, you can push those changes to the remote repository:

git push origin branchname

This command sends your local commits to the remote repository.

Pulling Changes from a Remote Repository (git pull):

To retrieve changes made by others in the remote repository, use the git pull command:

git pull origin branchname

This command fetches and merges changes from the remote repository into your current branch.

Collaborative development with Git and remote repositories is an essential part of modern software development.


Question 1: What is the primary purpose of remote repositories in Git?

a) To slow down development.
b) To serve as a personal backup of your code.
c) To enable collaboration and sharing of code among multiple developers.
d) To keep code secret and inaccessible to others.

Question 2: Which Git command is used to clone a remote repository to your local machine?

a) git copy
b) git create
c) git clone
d) git fetch

Question 3: What does the git push command do in Git?

a) Retrieves changes from a remote repository.
b) Deletes all commits from a branch.
c) Sends your local commits to a remote repository.
d) Creates a new branch in the remote repository.

Question 4: How do you fetch and merge changes from a remote repository into your local branch?

a) Use `git update`.
b) Use `git merge origin branchname`.
c) Use `git pull origin branchname`.
d) Use `git push origin branchname`.

Question 5: Why is collaborative development with remote repositories important in Git?

a) It helps developers work in isolation without sharing their code.
b) It ensures that only one person can work on the project at a time.
c) It allows multiple developers to collaborate and track changes effectively.
d) It prevents developers from making any changes to a project.

1C – 2C – 3C – 4C – 5C

Git Harmony: Branch and Merge

Today, we’ll explore the concepts of branches and merging, which are fundamental to collaborative and organized development with Git.

Learn About Branches and Why They’re Important

A branch in Git is like a separate line of development. It allows you to work on new features, bug fixes, or experiments without affecting the main project until you’re ready. Here’s why branches are essential:

  • Isolation: Branches keep your work isolated, so it won’t interfere with the main project or other developers’ work.
  • Collaboration: Multiple developers can work on different branches simultaneously and later merge their changes together.
  • Experimentation: You can create branches to test new ideas without committing to them immediately.

Create and Switch Between Branches

Creating a New Branch (git branch):

To create a new branch, use the following command, replacing branchname with a descriptive name for your branch:

git branch branchname

Switching to a Branch (git checkout):

To switch to a branch, use the git checkout command:

git checkout branchname

Creating and Switching to a New Branch in One Command (git checkout -b):

A common practice is to create and switch to a new branch in one command:

git checkout -b newbranchname

Understand How to Merge Branches

Merging a Branch into Another (git merge):

After making changes in a branch, you can merge those changes into another branch (often the main branch) using the git merge command.

# Switch to the target branch (e.g., main)
git checkout main
# Merge changes from your feature branch into main
git merge feature-branch

Git will automatically integrate the changes from the feature branch into the main branch, creating a new commit.

Branching and merging are powerful tools for managing complex projects and collaborating effectively with others.

Question 1: What is the primary purpose of using branches in Git?

a) To clutter your project with unnecessary files.
b) To prevent any changes to the main project.
c) To isolate different lines of development and collaborate on new features or fixes.
d) To merge all changes immediately.

Question 2: Which Git command is used to create a new branch?

a) git make
b) git branch
c) git create
d) git newbranch

Question 3: How can you switch to a different branch in Git?

a) Use `git switch branchname`.
b) Use `git change branchname`.
c) Use `git checkout branchname`.
d) Use `git swap branchname`.

Question 4: What does the git merge command do in Git?

a) It deletes a branch.
b) It creates a new branch.
c) It integrates changes from one branch into another.
d) It renames a branch.

Question 5: Why might you want to create a branch for a new feature or experiment in Git?

a) To immediately apply changes to the main project.
b) To make your project look more complex.
c) To work on new ideas without affecting the main project.
d) To confuse other developers.

1C – 2B – 3C – 4C – 5C

Navigating the Git Workflow

In the previous post of this series, you learned how to create a Git repository, stage changes, and make your first commit. Now, let’s dive deeper into understanding the Git workflow.

Explore the Basic Git Commands

1. git init
  • As you’ve learned before, git init initializes a new Git repository in your project folder.
  • It’s a one-time setup for each project.
2. git add
  • Use git add to stage changes you want to include in your next commit.
  • You can add specific files, like git add filename, or all changes with git add ..
3. git commit
  • After staging changes, commit them using git commit.
  • Remember to provide a meaningful commit message: git commit -m "Your commit message here".

Understand the Concept of the Git Workflow

The Git workflow is a series of steps you follow when working with Git to manage your project’s version history.
It helps you keep track of changes, collaborate with others, and maintain a clear history of your project. Here’s a more detailed explanation with examples:

1. Create or Clone a Repository

Creating a New Repository (git init):

  • Imagine you’re starting a new coding project called “MyApp.”
  • You navigate to your project folder in the terminal:

cd path/to/MyApp

  • To initialize a new Git repository, simply run:

git init

Cloning an Existing Repository (git clone):

  • Alternatively, if you want to work on an existing project hosted on a platform like GitHub, you can clone it to your local machine.
  • For instance, if you find a project on GitHub called “AwesomeApp,” you can clone it with:

git clone

2. Make Changes

Now that you have a Git repository set up, you can start making changes to your project. For example, you might add new files, modify existing ones, or delete unnecessary ones.

# Create a new file
touch index.html

# Edit an existing file
nano app.js

# Delete a file
rm oldfile.txt

3. Stage Changes (git add)

Not all changes you make are automatically saved in Git. You need to tell Git which changes you want to include in the next commit. This is where the staging area comes in.

  • To stage specific files for a commit, use git add filename:

git add index.html git add app.js

  • To stage all changes, use git add .:

git add .

4. Commit Changes (git commit)

Once you’ve staged your changes, you’re ready to create a commit. A commit is like taking a snapshot of your project at a specific point in time.

git commit -m "Add index.html and update app.js"

Make sure to provide a meaningful commit message. This helps you and others understand what this commit does.

5. View History (git log)

You can use git log to see a history of your commits, including their unique identifiers, authors, timestamps, and commit messages.

git log

6. Collaborate and Share

If you’re working with others, you can push your commits to a remote repository using git push and pull their changes with git pull.

# Push your commits to a remote repository
git push origin main
# Pull changes from a remote repository
git pull origin main

7. Resolve Conflicts (When Needed)

In collaborative projects, sometimes two people may edit the same part of a file, leading to conflicts. Git provides tools to help you resolve these conflicts, ensuring your changes are integrated correctly.

That’s a basic overview of the Git workflow! Remember, Git allows you to manage your project’s history efficiently and collaborate seamlessly with others. As you gain experience, you can explore more advanced features like branching for parallel development.

Question 1: What is the purpose of the staging area in the Git workflow?

a) To automatically save all changes made to your project.
b) To view the commit history of your project.
c) To select which changes should be included in the next commit.
d) To undo all changes made to your project.

Question 2: What command is used to initialize a new Git repository in your project folder?

a) git start
b) git create
c) git init
d) git setup

Question 3: When you create a commit in Git, what should you include in the commit message?

a) Your favorite song lyrics.
b) A brief description of your changes.
c) Your project's entire history.
d) The name of your computer.

Question 4: In the Git workflow, what comes after “View History”?

a) Make Changes
b) Collaborate and Share
c) Stage Changes
d) Resolve Conflicts

Question 5: What command is used to push your commits to a remote repository in Git?

a) git send
b) git upload
c) git push
d) git pull

1C. -2C – 3B – 4B – 5C

Creating Your First Repository

In this post, we will take our first steps into the world of Git by creating a local Git repository. We will also introduce you to two essential concepts: the staging area and commits.

Create a Local Git Repository

A Git repository is like a folder that tracks changes to your project over time. It helps you manage different versions of your project.

Step 1: Create a New Folder

  1. Open your computer’s file explorer or terminal.
  2. Choose a location where you want to create your project folder.
  3. Right-click (or use the terminal) and create a new folder with a meaningful name. This will be your project’s main folder.

Step 2: Initialize a Git Repository

Now, let’s turn this folder into a Git repository.

  • Open your terminal (command prompt or Git Bash on Windows, or any terminal on macOS/Linux).
  • Navigate to your project folder using the cd command. For example:
cd path/to/your/project-folder

Run the following command to initialize a Git repository:

git init

Congratulations! You’ve just created your first Git repository.

Learn About the Staging Area and Commits

Git uses a staging area to prepare changes before saving them as a commit. A commit is like a snapshot of your project at a specific point in time.

Step 1: Add Files to the Staging Area

  1. Create or add some files to your project folder.
  2. To stage changes, run:
    git add filename

Replace filename with the actual name of your file. You can also use git add . to stage all changes.

Step 2: Create a Commit

After staging your changes, you can create a commit to save them in the Git history.

  • Run the following command:
git commit -m "Your commit message here"

Replace "Your commit message here" with a brief description of your changes. This message helps you and others understand what this commit does.

You’ve just made your first commit!

Congratulations! You’ve taken your first steps into the Git world. Now, your project is tracked, and you can save and manage changes efficiently.

Question 1: What is the purpose of creating a Git repository?

a) To organize files alphabetically.
b) To track changes to your project over time.
c) To delete files.
d) To change file permissions.

Question 2: What does the staging area in Git help you with?

a) It automatically saves all your changes.
b) It prepares changes before saving them as commits.
c) It deletes unwanted files.
d) It renames your project folder.

Question 3: How do you add files to the staging area in Git?

a) By using the `git stash` command.
b) By using the `git add` command.
c) By using the `git push` command.
d) By using the `git remove` command.

Question 4: What is a commit in Git?

a) A snapshot of your project at a specific point in time.
b) A Git repository.
c) A way to rename files.
d) A folder where Git stores its data.

Question 5: Why is it important to include a meaningful commit message?

a) To confuse other collaborators.
b) To make your Git repository larger.
c) To help you and others understand the purpose of the commit.
d) To slow down the commit process.

1 b – 2 b – 3 b – 4 a – 5 c

Setting Up Git

Welcome back, everyone! In today’s post, we’ll focus on getting Git set up on your system and configuring some basic settings. Don’t worry; I’ll explain everything in non-technical terms so that everyone can follow along. Let’s dive right in!

Installing Git

Download Git

  1. Go to the official Git website:
  2. Look for a prominent download button on the homepage. It’s usually labeled “Download for Windows,” “Download for macOS,” or “Download for Linux” Click on the appropriate one for your operating system.


For Windows:

  • Once the download is complete, double-click the downloaded file to start the installer.
  • Follow the on-screen instructions, leaving most settings as their default values.
  • When you reach the “Adjusting your PATH environment” screen, choose the “Use Git from the Windows Command Prompt” option. This will make Git accessible from the regular command prompt.

For macOS:

  • Open the downloaded .dmg file.
  • Drag the Git icon into the Applications folder.
  • Open Terminal and type git --version to ensure Git was installed correctly.

For Linux:

  • Use your package manager (e.g., apt, yum, or dnf) to install Git. The command may vary based on your Linux distribution.
  • After installation, open a terminal and type git --version to verify that Git is installed.

Verify Installation

In your terminal or command prompt, type:

git --version

You should see Git’s version information, which confirms that Git is installed on your system.

 ~ % git --version
git version 2.37.1 (Apple Git-137.1)

Configuring Basic Settings

Now that Git is installed, let’s configure some basic settings so that Git knows who you are when you make commits. This helps keep track of who made what changes in a project.

Set Your Name and Email

In your terminal or command prompt, type the following commands, replacing “Your Name” and “Your Email” with your actual name and email address:

git config --global "Your Name" git config --global "Your Email"

These settings are global and will be used for all your Git repositories.

Verify Configuration

To double-check that you’ve set your name and email correctly, type:

git config --global 
git config --global

You should see your name and email displayed on the screen.

That’s it! You’ve successfully installed Git and configured some basic settings. You’re now ready to start using Git for version control in your projects.

In our next post, we’ll learn how to create your first Git repository and make your first commit. Stay tuned!

Let’s recap trying to answer the following questions 🙂

Question 1: What is the purpose of setting your name and email in Git configuration?

a) To customize the appearance of your Git terminal.

b) To set your preferred text editor for Git.

c) To identify yourself as the author of commits.

d) To change the color scheme of Git's user interface.

Question 2: Where can you download Git for your specific operating system?

a) Only from the Mac App Store.

b) The official Git website.

c) Any software download website.

d) The terminal using a command like "git download."

Question 3: Which step is necessary for Windows users during the Git installation process?

a) Choosing a username and password.

b) Selecting the type of version control system.

c) Deciding on the installation path.

d) Configuring Git to work with the Windows Command Prompt.

Question 4: What command should you use to verify if Git is installed correctly on your system?

a) check git installation

b) git --verify

c) git status

d) git --version

Question 5: After configuring your name and email in Git, where can you check to ensure these settings are correctly configured?

a) In your web browser's settings.

b) In the Git configuration file.

c) By running `git config --global` and `git config --global` commands.

d) In your computer's system preferences.

Answers: 1 c – 2 b – 3 d – 4 d – 5 c

The Need for Version Control

Why Version Control?

Version control is a system that helps track changes to files and folders over time. It is crucial for several reasons:

  • History Tracking: Version control allows you to maintain a detailed history of changes made to your project files. This history includes who made the changes, what changes were made, and when they were made.
  • Collaboration: In collaborative projects, multiple developers often work on the same codebase simultaneously. Version control enables seamless collaboration by managing changes and ensuring that everyone is working on the latest version of the project.
  • Error Recovery: Mistakes happen. With version control, you can easily revert to a previous working state if something goes wrong, reducing the risk of losing valuable work.
  • Code Reviews: Version control systems facilitate code reviews by providing a platform to discuss and suggest changes before integrating new code into the main project.

What Git Is and Its Role in Collaborative Development

Git is a distributed version control system designed to handle everything from small to very large projects efficiently. It was created by Linus Torvalds in 2005 and has since become the de facto standard for version control in the software development industry.

Key Concepts of Git

  • Repository: A repository, or repo, is a collection of files and their complete history of changes. It exists on your local machine as well as on remote servers.
  • Commit: A commit is a snapshot of your repository at a specific point in time. Each commit has a unique identifier and contains the changes you’ve made.
  • Branch: A branch is a separate line of development within a repository. It allows you to work on new features or fixes without affecting the main codebase.
  • Merge: Merging is the process of combining changes from one branch into another. It’s used to integrate new code into the main project.
  • Pull Request: In Git-based collaboration, a pull request is a way to propose and discuss changes before they are merged into the main branch.

Local vs Remote Repositories

  • Local Repository: A local repository resides on your computer and contains the entire history of the project. You can work on your code, make commits, and experiment without affecting others.
  • Remote Repository: A remote repository is hosted on a server (like GitHub, GitLab, or Bitbucket). It serves as a central hub where developers can share and collaborate on their code. Remote repositories ensure that all team members are working with the same codebase.

Syncing Local and Remote Repositories

To collaborate effectively, you need to sync your local repository with the remote repository:

  • Push: Pushing involves sending your local commits to the remote repository, making your changes available to others.
  • Pull: Pulling is the process of fetching changes from the remote repository and merging them into your local repository.
  • Fetch: Fetching retrieves changes from the remote repository without automatically merging them into your local repository.

In summary, version control, particularly Git, is the backbone of collaborative development. It empowers teams to work together efficiently, track changes, and manage complex projects seamlessly. Understanding the distinction between local and remote repositories is fundamental to successful collaboration.

Save username and password in git

Lately I started to work on a new environment and the first thing has been to install git.

The second thing has been to clone a repository and finally I started to pull and push things.

But! Every time I pulled and pushed something a very nasty little window started bothering me: insert username, insert password (because of course the repository was protected by a password)

And if initially I endured it, after the third time I started to hate it.

So…I decided to save locally my git username and password.

First I had to type this

git config --global credential.helper store

and then

git pull (or push)

You will be prompt (for the LAST TIME) the git username and password

They will be stored in a .git-credentials file in a clear format like:


Normally this file is saved in your local [username] folder (in windows or linux OS)

There is the possibility to have a secure (and recommended) method using a ssh key. Alternatively you can use a caching timeout way of saving your credentials (just in memory for a limited period of time).

For a complete documentation please refer to: