Git for Beginners: A Friendly Guide to Version Control

Welcome to the program! Whether you’re just getting started with programming or want to familiarize yourself with Git for your personal projects, you’ve come to the right place. Git can seem intimidating if you’re new to it, but don’t worry! This guide will take you through the basics step by step in an easy to understand way. We’ll familiarize you with Git so you can manage your code more effectively.

What is Git and why should you care?

Git is a version control system, which means it helps you manage changes to your code. Think of it as an intelligent tool that tracks every change to your projects. It allows you to:

Save snapshots of your work (called “commits”)
Revert to previous versions if something doesn’t work
Work with others on the same project without stepping on each other’s toes

Why use Git?

You might be thinking: “Why do I need Git? Can’t I just save my files manually?” Sure, but Git gives you much more control and flexibility. It’s like having an undo button for every change you make and a time machine that lets you revisit your code at any point in time.

Here are a few key reasons why you’ll love Git:

Safe collaboration: Multiple people can work on the same project at the same time without overwriting each other’s work.
Version history: You can revert to previous versions if you accidentally insert bugs.
Backups: You can move your code to remote repositories (like GitHub) so your work is safe even if your local machine crashes.

Already convinced? Great! Let’s move on to installing Git.

Installing Git: Setting up the tools

Before you can use Git, you need to install it on your computer. Here you can find out how to do this:

Windows

Go to the official Git website git-scm.com.
Download the latest version of Git for Windows.
Run the installer and follow the prompts. Keep the default settings unless you need to change something.
Once installed, open “Git Bash” This is a terminal where you can enter Git commands. You can find it by searching for “Git Bash” in your start menu.

macOS

Open Terminal (you can also search for it in Spotlight).
Type the following command and press Enter:

 git --version

If Git is already installed, you will see the version number. If not, your Mac will prompt you to install it.

Follow the instructions to install Git. Once it is installed, you can use Git directly from your terminal.

Linux

With most Linux distributions, Git can be installed via the package manager. For example:

Ubuntu/Debian:

 sudo apt-get install git

Fedora:

 sudo dnf install git

Once Git is installed, verify it by typing:

git --version

You should see something like “Git version 2.x.x”, which means you’re good to go!

Configuring Git: Setting up your identity

Now that Git is installed, it’s time to configure it. To do this, you need to tell Git who you are so that your commits can be assigned to you. To do this, you need to enter your name and email address. This is how it works:

Open your terminal (or Git Bash on Windows) and enter these commands:

git config --global user.name "Your name"
git config --global user.email "your.email@example.com"

Replace "your name" and "your.email@example.com" with your actual data.

By the way: The flag “–global” means that these settings apply to all your Git projects. If you want to configure different identities for different projects, you can omit --global and execute the command within the project directory.

Creating a repository

A repository (or repo) is like a folder for your project. It’s where Git saves all the changes you make. You can create a Git repository from an existing project or create a new project. This is how it works:

Start a new project with Git

Navigate to the folder in which you want to create your project. In the terminal, you can use the “cd” command to switch between directories. For example:

 cd path/to/your/folder

Once you are in the correct folder, initialize a new Git repository by typing:

 git init

This will create a hidden .git folder that contains all the version control information. Don’t worry, you won’t have to touch this folder directly.

Add an existing project to Git

If you already have a project folder that you want to add to Git, the steps are similar:

Open your terminal and go to your project directory with “cd”.
Execute the following command to initialize Git:

 git init

Now Git is tracking your project!

Track changes: Add, commit and status

Alright, now that you’ve set up your repository, let’s learn how to track changes to your files.

1. Check the status

First, you need to check which files are being tracked. Run this command:

git status

You will probably see something like:

Untracked files:
 (use "git add ..." to include them in the files to be transferred)

This means that Git knows that these files exist, but it is not tracking them yet. You need to explicitly tell Git which files to track.

2. Add files to the staging area

Before Git can commit your changes, you need to add files to the Staging Area. Think of this as a preparatory step before you create a permanent snapshot (commit).

To add a file to the staging area, run

git add filename

Replace “filename” with the actual name of your file. If you want to stage all files in your project, run

git add .

3. Commit your changes

As soon as your files are ready, you can commit them. A commit is like a snapshot of your project at that moment. To commit, execute:

git commit -m "Describe your changes here"

The message should explain what changes you have made. For example:

git commit -m "Add first project files"

4. Check the status again

If you now run, you will see a clean slate:

nothing to transfer, working tree clean

This means that everything has been transferred and is up to date.

Branches: The magic of parallel working

Branches allow you to work on different functions, bugs or experiments in isolation without affecting the main project. You can think of a branch as a copy of your project that you can work on independently.

Creating a new branch

Let’s say you want to add a new function to your project. Instead of working directly on the main branch (called master or main), you can create a new branch:

git branch feature-branch

This will create a new branch called feature-branch. You can name it whatever you want, but descriptive names are best. To switch to your new branch, execute:

git checkout feature-branch

Now you are in your new branch and any changes you make will not affect the main branch.

Merge branches

When you are happy with the changes in your branch, you can merge it back into the main branch. First switch back to the main branch:

git checkout main

Then add your feature branch to it:

git merge feature-branch

If there are no conflicts, Git merges the changes and you’re done! If there are conflicts (when two branches have changed the same part of a file differently), Git prompts you to resolve them manually.

Cloning and pulling: working with remote repositories

Many projects use remote repositories hosted on platforms like GitHub, GitLab or Bitbucket. Suppose you want to collaborate on a project that is hosted in a different location. Here you can find out how to get started.

Cloning a repository

To get a copy of a remote repository, you need to clone it. This is how it works:

Go to the project’s page on GitHub (or another platform).
Copy the URL of the repository.
Run it in your terminal:

 git clone https://github.com/username/repository.git

This will create a local copy of the repository on your computer.

Drag changes

If someone else makes changes to the project, you can pull the latest updates from the remote repository:

git pull

This will fetch the latest changes and merge them into your local copy.

Share changes: Share your work

If you want to share your work with others, you need to push your changes to a remote repository (like GitHub). Before you can use the push method, you need to add a remote repository to your local project. You can do this with the following command:

git remote add origin https://github.com/username/repository.git

Now you can push your changes:

git push origin main

If you are working in a different branch, replace “main” with the name of your branch.

Resolve merge conflicts: When things are not running smoothly

Merge conflicts occur when Git can’t automatically reconcile the differences between two branches. This can happen when two people change the same part of a file in different ways.

In this case, Git marks the conflict in the file and it’s up to you to fix it manually.

This is how it works:

Open the file with the conflict. You will see something like this:

 <<<<<<< HEAD
 Your changes
 =======
 Their changes
 >>>>>>> branch-name

Edit the file to resolve the conflict by choosing which changes to keep or by manually merging both sets of changes.
Once you have resolved the conflict, add the file to the staging area:

 git add filename

Finally, commit the changes:

 git commit

And the conflict is resolved!

A few bonus git commands

Now that you know the basics, here are a few additional commands to help you work even more efficiently:

git log: Look at the history of all your commits.
git diff: View the changes between your working directory and the last commit.
git stash: Temporarily save your changes without committing them. You can apply them later with git stash pop.

Conclusion: You can do it!

Congratulations! You’ve just taken your first big step into the world of Git. You now know how to install Git, configure it, create repositories, track changes, work with branches, collaborate with others, and even resolve merge conflicts. With practice, these commands will become second nature.

Remember that Git is a powerful tool, and while it may seem like a lot at first, every developer has experienced where you are. The more you use it, the easier it gets. Keep practicing and soon you’ll be managing your code like a pro!

Have fun coding and don’t be afraid to experiment. It’s there to make your life easier!