Git Basics

Introduction

In modern software development, managing code efficiently is essential. Teams frequently work collaboratively on projects, making changes to the same codebase simultaneously. Without proper version control, coordinating these changes becomes challenging and error-prone. This is where Git comes into play.

Git is a distributed version control system that allows developers to track changes, collaborate effectively, and maintain a history of their codebase. It was created by Linus Torvalds in 2005 to manage the Linux kernel and has since become the standard for source code management in software development.

This post explores Git basics, key commands, workflows, and practical examples. It provides a comprehensive guide for beginners and serves as a reference for experienced developers.

What is Git?

1. Version Control System

A version control system (VCS) is a tool that records changes to files over time. Git allows multiple developers to work on the same project simultaneously while keeping track of every modification. Key benefits of using a VCS include:

• Tracking changes over time
• Reverting to previous versions
• Managing collaboration between multiple developers
• Maintaining project history

2. Distributed Nature

Unlike centralized version control systems, Git is distributed. Every developer has a full copy of the repository, including the complete history. This approach offers advantages:

• Work offline without relying on a central server
• Faster operations, such as commits, diffs, and logs
• Reduces the risk of data loss

---

Git Installation

Before using Git, you must install it on your system. Git is compatible with Windows, macOS, and Linux.

Installation on Windows

1. Download Git from https://git-scm.com/downloads
2. Run the installer and follow the prompts
3. Verify installation:

git --version

Installation on macOS

Use Homebrew:

brew install git
git --version

Installation on Linux

On Ubuntu/Debian:

sudo apt update
sudo apt install git
git --version

---

Configuring Git

After installation, configure your Git identity. This information appears in commits.

git config --global user.name "Your Name"
git config --global user.email "[email protected]"

To check configuration:

git config --list

---

Creating a Git Repository

Initialize a Repository

To start tracking a project with Git, initialize a repository:

git init

This command creates a .git directory in the project folder, which stores all Git metadata and history.

Example:

mkdir myproject
cd myproject
git init

---

Staging Changes

git add

Before committing changes, you must stage them. Staging allows you to select which modifications will be included in the next commit.

git add <file>
git add .

Examples:

• Stage a single file:

git add index.html

• Stage all changes in the current directory:

git add .

---

Committing Changes

git commit

A commit represents a snapshot of the repository at a specific point in time. Committing records staged changes to the repository history.

git commit -m "Commit message describing changes"

Example:

git commit -m "Add homepage"

Tips for Commit Messages:

• Be concise but descriptive
• Use present tense: “Add feature” instead of “Added feature”
• Include context for why the change was made

---

Checking Repository Status

git status

The git status command shows the state of your working directory and staging area. It helps identify:

• Modified files
• Staged changes ready for commit
• Untracked files

Example:

git status

Output might include:

Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)
    new file:   index.html
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
    modified:   style.css

---

Viewing Commit History

git log

To view the history of commits:

git log

Common options:

• git log --oneline – shows commits in a concise format
• git log --graph --all --decorate – shows a visual branch structure

Example:

commit 1a2b3c4d
Author: Your Name <[email protected]>
Date:   2025-10-23

Add homepage

---

Undoing Changes

Unstaging Changes

To remove a file from the staging area without discarding changes:

git reset HEAD <file>

Discarding Changes

To discard modifications in the working directory:

git restore <file>

Example:

git restore style.css

---

Working with Branches

What is a Branch?

A branch is an independent line of development. Branches allow developers to work on features, bug fixes, or experiments without affecting the main codebase.

Creating a Branch

git branch <branch-name>

Switching Branches

git checkout <branch-name>

Creating and Switching in One Command

git checkout -b <branch-name>

Merging Branches

To merge changes from one branch into another:

git checkout main
git merge feature-branch

---

Cloning a Repository

To work on an existing project, clone the repository:

git clone <repository-url>

Example:

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

---

Pulling and Pushing Changes

git pull

Fetches updates from the remote repository and merges them into your local branch:

git pull origin main

git push

Sends your local commits to the remote repository:

git push origin main

---

Git Ignore

Sometimes, you don’t want to track certain files, like temporary files, logs, or compiled binaries. Use a .gitignore file.

Example .gitignore:

# Ignore node_modules
node_modules/

# Ignore log files
*.log

# Ignore compiled files
*.class

---

Resolving Conflicts

Conflicts occur when multiple changes affect the same part of a file. Git marks conflicts for manual resolution. Steps to resolve:

1. Open conflicted file
2. Look for conflict markers:

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

3. Edit the file to resolve the conflict
4. Stage and commit the resolved file:

git add resolved-file
git commit -m "Resolve merge conflict"

---

Tagging in Git

Tags mark specific points in history, often used for releases.

• Create a tag:

git tag v1.0

• Push tags to remote:

git push origin v1.0

• List tags:

git tag

---

Undoing Commits

• Amend the last commit (for minor changes):

git commit --amend -m "Updated commit message"

• Reset to previous commit:

git reset --soft HEAD~1  # Keep changes staged
git reset --hard HEAD~1  # Discard changes

---

Working with Remotes

Adding a Remote

git remote add origin <repository-url>

Listing Remotes

git remote -v

Fetching from Remote

git fetch origin

---

Practical Git Workflow

Typical Workflow:

1. Clone the repository:

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

2. Create a new branch for a feature:

git checkout -b feature-login

3. Make changes and stage files:

git add login.html
git add style.css

4. Commit changes:

git commit -m "Implement login page"

5. Push branch to remote:

git push origin feature-login

6. Create a pull request for review
7. Merge after approval

---

Best Practices in Git

1. Commit frequently with meaningful messages
2. Use branches for features, bug fixes, and experiments
3. Avoid committing sensitive data or secrets
4. Pull latest changes before starting work
5. Resolve conflicts promptly
6. Use .gitignore to exclude unnecessary files
7. Tag releases for version tracking