How to Use Git? A Beginner’s Guide

Git is a powerful companion for anyone who writes code, acting like a safety net that catches your progress as you build software. It helps you save your work, revisit older versions when things go wrong, and collaborate smoothly with others without creating confusion or chaos. Imagine writing an essay and being able to instantly rewind to a version before you made a mistake. That’s what Git does for code, and it’s why nearly every professional project relies on it. This blog post will guide you through how to use Git. We’ll go step by step through installing Git, setting it up, making your first commits, and even sharing your work with platforms like GitHub. By the end, you’ll be comfortable using Git in your own projects.

What You’ll Need Before Starting

Before getting into Git, a few basics will help you follow along smoothly:

• A computer with Git installed (we’ll cover this in Step 1).
• Basic knowledge of opening a terminal and typing commands.
• A GitHub account if you’d like to back up your work online or share it.

That’s all you need. Now, let’s get started.

Step 1 – Install Git

The first step is to get Git installed on your machine.

Windows – Download it from git-scm.com and follow the setup wizard. You might want to select default options unless you have specific needs.

macOS – If you use Homebrew, run:

brew install git

Linux – Use your package manager. For example, on Ubuntu:

sudo apt update
sudo apt install git

To confirm the installation, type:

git –version

If you see a version number, you’re good to go.

Step 2 – Configure Git

Now that Git is installed, tell it who you are by setting up your identity. This is important because every change you make will be tagged with your name and email. Run the following commands in your terminal:

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

This configuration only needs to be done once, unless you want different identities for different projects.

Check your settings with:

git config –list

This step ensures your commits are tagged with the right identity.

Step 3 – Start a Repository

A repository (or repo) is where Git stores your project and tracks changes. Think of it as a container for your project’s files and their history.

To create a new repository in an empty folder:

mkdir my-project
cd my-project
git init

This creates a hidden folder that Git uses to track changes in your project.

To copy an existing project from GitHub:

git clone https://github.com/user/repo.git

Now Git is ready to track your work.

Step 4 – Track Changes

With Git now watching your project, you can start tracking changes. Let’s add some files and save them with Git.

1. Create or edit a file in your project.

2. Check the current status:

git status

3. When you add or modify files, you tell Git which changes to include in the next snapshot by adding them to the “staging area” using:

git add filename.txt

Or to add all changes:

git add .

4. Then commit (save) the snapshot with a message describing what you’ve done:

git commit -m "Describe your changes here"

Each commit acts like a save point, capturing your work at a specific moment.

Step 5 – Review Your Work

Git provides useful commands to keep an eye on what’s going on.

See which files have been modified but not yet committed:

git status

Review your history of commits:

git log

See changes since the last commit:

git diff

These commands help you stay organized and understand the progress of your project over time.

Step 6 – Work with Branches

Branches let you work on new features or experiment safely. For example, you can try a new feature without affecting the main code until you’re ready so you won’t disrupt the stable codebase.

Create a branch with:

git branch feature-name

Switch to the branch using:

git checkout feature-name

After finishing the work on the branch, you can merge it back into your main branch, typically called main or master, ensuring your project’s main version includes all improvements.

git checkout main
git merge feature-1

Branches are optional when you’re starting out, but learning them early is a big win.

Step 7 – Connect to a Remote Repository

To share your work or create a backup online, connect your local repository to a remote one on services like GitHub. First, create a repository on the platform, then link it via:

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

Push your commits up to the remote repository with:

git push -u origin main

This is where Git really shines for teamwork as it enables collaboration and access to your project from any device. Everyone can work on their part of the project and bring it together.

Step 8 – Try a Simple Workflow

Here’s a straightforward workflow to experience how Git keeps your coding safe and organized:

1. Make sure your main branch is up to date by pulling changes from the remote:

git pull origin main

2. Create and switch to a new branch for your feature:

git checkout -b new-feature

3. Work on your files and use git add to stage changes and git commit to save them locally.

git add .
git commit -m "Initial commit"

4. Push your branch to the remote repository:

git push origin new-feature

5. When ready, open a pull request on GitHub to merge your feature into the main branch.

Through this process, Git helps avoid conflicts and keeps a clean history of development.

Real-World Mini Example: Fixing a Bug with Git

Imagine you’ve just deployed a new feature to your project, but hours later, a user reports a bug. You’re unsure when the bug was introduced, but you need to fix it quickly without losing your recent progress.

First, you use Git to check your recent commits with:

git log

You identify that the bug likely appeared after your latest changes. Next, you switch to a new branch to work on the fix without disturbing your main project:

git checkout -b bugfix-urgent

You make the necessary code edits, stage them with:

git add .

And commit your fixes:

git commit -m "Fix user-reported bug in new feature"

Before merging, you test thoroughly to ensure the bug is resolved. Then, you merge your bug fix back into the main branch:

git checkout main
git merge bugfix-urgent

Finally, you push the updated main branch to your remote repository for immediate deployment:

git push origin main

This process shows how Git acts as a safety net, allowing you to experiment, fix problems, and keep your project’s history well-organized without losing any work.

Final Thoughts

Learning how to use Git is less about memorizing commands and more about building a habit. Once you get into the flow of adding, committing, and pushing your work, it quickly becomes second nature. It’s not limited to major projects or professional teams; it’s helpful anytime you need to track work history and handle changes efficiently. Git not only protects your code from mistakes, but it also allows you to gain the ability to experiment freely and collaborate with confidence.

Start small. Create a simple project, follow the steps here, and keep practicing. The more you use Git, the more comfortable it will feel. Soon it will become one of the most reliable tools in your developer toolkit. Give it a try and see how this safety net makes coding less stressful and much more productive.