Introduction to Git on Linux: Basic Commands for Beginners

In the world of software development, tracking changes to code, collaborating with teammates, and maintaining a history of project evolution is critical. Git, a distributed version control system (VCS), has become the industry standard for these tasks. Designed by Linus Torvalds in 2005, Git enables developers to track modifications, revert to previous versions, and collaborate seamlessly—even across distributed teams. If you’re new to development or Linux, learning Git is a foundational skill. This blog will guide you through Git’s core concepts, basic commands, and best practices, tailored specifically for Linux users. By the end, you’ll be able to initialize a repository, track changes, collaborate with remote teams, and avoid common pitfalls.

Table of Contents

1. Prerequisites
2. Installing Git on Linux
3. Fundamental Git Concepts
4. Basic Git Commands
5. Common Workflows for Beginners
6. Best Practices
7. Troubleshooting Tips
8. Conclusion
9. References

Prerequisites

Before diving in, ensure you have:

• A Linux-based operating system (e.g., Ubuntu, Fedora, Arch).
• Basic familiarity with the Linux command line (e.g., cd, mkdir, ls).
• A terminal emulator (e.g., GNOME Terminal, Konsole, or xterm).
• Internet access (for installing Git and interacting with remote repositories).

Installing Git on Linux

Git is pre-packaged for most Linux distributions. Use your system’s package manager to install it. Below are commands for popular distros:

Ubuntu/Debian

sudo apt update && sudo apt install git -y

Fedora/RHEL/CentOS

sudo dnf install git -y   # Fedora/RHEL 8+
# For older RHEL/CentOS: sudo yum install git -y

Arch Linux

sudo pacman -S git

Verify Installation

After installation, confirm Git is installed with:

git --version
# Output example: git version 2.34.1

Fundamental Git Concepts

Before diving into commands, let’s clarify key Git concepts:

Basic Git Commands

Let’s walk through the essential commands you’ll use daily.

1. Configure Git (First-Time Setup)

Git needs your identity to link commits to your name/email. Run these commands once (replace with your details):

git config --global user.name "John Doe"
git config --global user.email "[email protected]"

To verify settings:

git config --list
# Output includes: user.name=John Doe, [email protected]

2. Initialize or Clone a Repo

To start using Git, you either create a new repo or clone an existing one.

Create a New Local Repo

Navigate to your project folder and initialize Git:

mkdir my-project && cd my-project  # Create and enter project folder
git init                          # Initialize Git repo
# Output: Initialized empty Git repository in /home/user/my-project/.git/

Clone an Existing Remote Repo

To copy a remote repo (e.g., from GitHub) to your machine:

git clone https://github.com/example/remote-repo.git
# Replaces "https://..." with the repo URL from GitHub/GitLab

3. Track Changes: git status, git add, and git commit

Git works in three stages: modified (changes made but not staged), staged (changes ready to commit), and committed (changes saved to the repo).

Check Status of Files

Use git status to see which files are modified, untracked, or staged:

# After creating a new file (e.g., README.md)
git status
# Output:
# Untracked files:
#   (use "git add <file>..." to include in what will be committed)
#         README.md

Stage Changes

Add files to the staging area with git add:

git add README.md  # Stage a single file
# OR stage all modified/untracked files:
git add .

Commit Staged Changes

Save staged changes to the repo with a descriptive message:

git commit -m "Initial commit: Add README.md"
# Output:
# [main (root-commit) a1b2c3d] Initial commit: Add README.md
#  1 file changed, 0 insertions(+), 0 deletions(-)
#  create mode 100644 README.md

Pro Tip: Write concise, imperative commit messages (e.g., “Add” instead of “Added”).

4. View Commit History

Use git log to see past commits:

git log
# Output shows commit ID, author, date, and message:
# commit a1b2c3d4e5f67890abcdef1234567890abcdef12 (HEAD -> main)
# Author: John Doe <[email protected]>
# Date:   Mon Oct 10 14:30:00 2023 +0200
# 
#     Initial commit: Add README.md

For a condensed view, use git log --oneline:

git log --oneline
# Output: a1b2c3d (HEAD -> main) Initial commit: Add README.md

5. Undo Changes

Mistakes happen! Here’s how to fix common issues:

Discard Unstaged Changes

To revert a file in your working directory to its last committed state:

git checkout -- README.md  # Replace "README.md" with your file

Unstage a File

If you accidentally staged a file, remove it from the staging area:

git reset HEAD README.md  # Now "README.md" is back to "modified"

Fix the Last Commit

If you forgot to stage a file or wrote a bad message, amend the last commit:

git commit --amend -m "Initial commit: Add README and LICENSE"
# Only use this for commits that haven’t been pushed to a remote!

6. Work with Remotes

Remotes (e.g., GitHub) let you share code with teammates.

List Remotes

See linked remote repos:

git remote -v
# Output example:
# origin  https://github.com/example/remote-repo.git (fetch)
# origin  https://github.com/example/remote-repo.git (push)

Fetch and Pull Remote Changes

Before pushing your work, sync with the remote to avoid conflicts:

git pull origin main  # "origin" = remote name; "main" = branch name

Push Local Changes to Remote

Upload your commits to the remote repo:

git push origin main  # Pushes the "main" branch to "origin"

7. Basic Branching

Branches let you work on features/fixes without breaking the main codebase.

Create and Switch Branches

git branch feature/login  # Create a new branch named "feature/login"
git checkout feature/login  # Switch to the new branch
# Shortcut: Create and switch in one command:
git checkout -b feature/login

Merge Branches

Once your feature is done, merge it back into main:

git checkout main  # Switch back to the main branch
git merge feature/login  # Merge changes from "feature/login" into "main"

Common Workflows for Beginners

A simple workflow to start with:

1. Clone the remote repo to your machine: git clone <remote-url>.
2. Create a branch for your task: git checkout -b feature/your-task.
3. Make changes to files (edit, add, delete).
4. Stage changes: git add ..
5. Commit with a message: git commit -m "Add X feature".
6. Pull remote changes to sync: git pull origin main.
7. Push your branch to the remote: git push origin feature/your-task.

Best Practices

To use Git effectively, follow these guidelines:

1. Write Clear Commit Messages

• Use the imperative mood (e.g., “Add login form” not “Added login form”).
• Keep the first line short (<50 chars), then add details in a new line if needed.
  Example:

  git commit -m "Add email validation to login form
  
  - Check for valid email format using regex
  - Show error message if invalid"

2. Use .gitignore

Create a .gitignore file in your repo to exclude unnecessary files (logs, dependencies, etc.):

# Example .gitignore content
*.log          # Ignore all .log files
node_modules/  # Ignore Node.js dependencies
.env           # Ignore environment variables

3. Commit Frequently and Logically

Commit small, focused changes (e.g., “Fix button alignment” instead of “Update everything”). This makes debugging easier.

4. Pull Before Pushing

Always run git pull origin main before pushing to avoid overwriting teammates’ work.

5. Keep Branches Focused

Use branches for single tasks (e.g., bugfix/login-error, feature/payment-gateway). Delete branches after merging.

Troubleshooting Tips

• “Your local changes would be overwritten by merge”: Stash or commit your changes first:

  git stash  # Temporarily save changes
  git pull origin main
  git stash pop  # Restore stashed changes

• Merge conflicts: Git will mark conflicts in files (e.g., <<<<<<< HEAD). Edit the file to resolve conflicts, then git add <file> and git commit.
• “Failed to push some refs”: Pull first to sync with the remote: git pull origin main.

Conclusion

Git is a powerful tool, but mastering the basics is enough to start contributing to projects. By learning git init, git add, git commit, git push, and branching, you’ll be able to track changes, collaborate with teams, and maintain organized codebases.

Practice is key! Start with a small project, experiment with commands, and refer to the Git documentation for advanced use cases.

References

• Git Official Documentation
• GitHub Git Cheat Sheet
• Pro Git Book (Free)
• Linuxize: How to Install Git on Ubuntu