How to Make Your First Git Commit: A Beginner's Step-by-Step Guide

What Is Git and Why Do You Need It?

Git is a distributed version control system that tracks changes in files and coordinates work among multiple developers. It's the backbone of modern software development, enabling teams to collaborate efficiently without stepping on each other's toes. In this section, we'll explore what Git is, how it works, and why it's essential for any serious developer.

How Git Tracks Changes

Git creates a timeline of changes called commits. Each commit stores a snapshot of your project at a point in time. This allows you to roll back to previous versions, compare changes, and understand how your project evolved.

Key Git Commands

Here are some essential Git commands to get you started:

# Initialize a new Git repository
git init

# Add files to staging area
git add .

# Commit changes with a message
git commit -m "Add feature X"

# View commit history
git log

# Create a new branch
git branch new-feature

# Switch to a branch
git checkout new-feature

# Merge a branch into the current branch
git merge new-feature

💡 Git is essential for modern software development. It enables safe experimentation through branching, seamless collaboration, and a complete history of your project's evolution. Whether you're working solo or in a team, Git provides the tools to manage your codebase with precision and confidence.

Understanding the Git Workflow: Workspace, Staging, and Repository

The Git workflow is a powerful yet elegant system that governs how code moves from your mind, to your editor, and finally into a version-controlled history. Understanding this workflow is essential for mastering Git.

At the heart of Git lies a three-area architecture: the Workspace, the Staging Area, and the Repository. Each plays a distinct role in how changes are created, reviewed, and stored.

Workspace: Where You Work

The Workspace (also known as the working directory) is where you do your actual work. It's the set of files you're currently editing. Think of it as your creative sandbox — where ideas become code.

Staging Area: The Preparation Zone

The Staging Area is a temporary storage that holds changes you're about to commit. It's like a checklist of what you want to include in your next commit.

# Add a file to the staging area
git add <file-name>

# Add all changes to staging
git add .

# Check what's staged
git status

Repository: Permanent Storage

The Repository is where Git stores your project's history. Each commit creates a new snapshot in the repository, preserving the state of your project at that moment.

# Commit staged changes
git commit -m "Add feature X"

# View commit history
git log

Visualizing the Workflow

Here's a simplified view of how a change moves through the system:

Why This Matters

Understanding this workflow is foundational for advanced topics like branching strategies, CI/CD pipelines, and code review workflows.

Key Takeaways

• Git uses a three-stage workflow: Workspace → Staging → Repository.
• Changes start in your Workspace, move to the Staging Area, and are saved in the Repository via commits.
• Each stage provides a checkpoint for quality control and change management.

Setting Up Your Environment: Installing and Configuring Git

Before you can start managing your code with Git, you must first set up your environment. This involves installing Git and configuring it with your identity and default editor. This setup is a one-time process that ensures your commits are properly attributed and your Git experience is optimized.

Installing Git

Git is available for all major operating systems. Follow the steps below based on your OS:

brew install git

sudo apt update
sudo apt install git

Configuring Git

After installation, configure Git with your identity and preferred text editor:

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

These settings are global and will apply to all repositories you create or clone on this machine.

📘 Note

Use git config --global for system-wide settings. For project-specific settings, use git config --local.

Verifying Installation and Configuration

Check that Git is installed and configured correctly:

git --version
git config --global --list

If everything is set up correctly, you’ll see your Git version and configuration details.

Key Takeaways

• Git must be installed and configured with your identity to start tracking changes.
• Use git config to set your name, email, and default editor.
• Proper setup avoids future issues with commit tracking and collaboration.

Initializing a Git Repository: The 'git init' Command

Every Git project begins with a single command: git init. This command creates a new Git repository in your current working directory, laying the foundation for version control. It's the first step in tracking your code's evolution.

💡 Pro Tip

Use git init only once per project, and always in the root directory of your project.

# Navigate to your project folder
cd my-awesome-project

# Initialize a new Git repository
git init

What Happens Behind the Scenes?

When you run git init, Git sets up:

• A .git directory with subdirectories like objects, refs, and config.
• A default branch (usually main or master).
• An empty commit history ready for your first snapshot.

graph TD
    A["Start: User runs git init"] --> B["Git creates .git directory"]
    B --> C["Initializes objects, refs, HEAD"]
    C --> D["Sets up default branch"]
    D --> E["Repository ready for commits"]

Key Takeaways

• git init is the gateway to Git version control for any project.
• It creates a hidden .git folder that stores all repository data.
• Only run this command once per project, in the root directory.

Preparing Your First File: Creating and Staging Content

Now that you've initialized your Git repository with git init, it's time to start working with actual content. In this section, we'll walk through creating your first file, adding it to the staging area, and preparing it for version control. This is where your project truly begins to take shape.

Creating Your First File

Let's begin by creating a simple file in your project directory. This file will serve as the foundation for your first commit. For this example, we'll create a basic HTML file called index.html.

graph TD
    A["Create index.html"] --> B["Add content to file"]
    B --> C["Stage file with git add"]
    C --> D["File now in staging area"]
    D --> E["Ready for commit"]

Staging Files with git add

Once your file is created, you need to tell Git to track it. This is done using the git add command. This command moves your file from the working directory to the staging area, preparing it for a commit.

Example: Creating and Staging a File

Let's walk through a practical example of creating and staging a file:

# Create a new file
echo "<!DOCTYPE html><html><body><h1>Hello, Git!</h1></body></html>" > index.html

# Add the file to staging
git add index.html

# Check the status
git status

After running these commands, your file will be ready to be committed. You can verify this by running git status, which will show the file in the staging area.

Key Takeaways

• Creating a file is the first step in building your project.
• Staging with git add prepares your changes for a commit.
• Always verify your staging status with git status.

Understanding the .git Directory: What Git Stores Internally

At the heart of Git's version control system lies the .git directory. This hidden folder is where Git stores all the metadata and object database for your project. Understanding its structure is key to mastering Git's internals.

Key Components of the .git Directory

• objects: Stores all the data for commits, trees, blobs, and tags.
• refs: Contains references to branches and tags.
• HEAD

Example: Inspecting .git Objects

Let's look at how to inspect the internal objects:

# Navigate to your Git repository
cd /path/to/your/repo

# List the contents of the .git directory
ls -la .git

# View the commit objects
ls -la .git/objects

# View the commit history
git log --oneline

Key Takeaways

• The .git directory is the core of Git's internal storage.
• It contains all the necessary data to track your project's history.
• Understanding its structure helps in debugging and optimizing Git workflows.

Making Your First Commit: The 'git commit' Command Explained

At the heart of Git's version control system lies the git commit command. This is where your changes transition from a temporary state to a permanent snapshot in your project's history. In this section, we'll break down how git commit works under the hood, what happens when you run it, and how it fits into the larger Git architecture.

What Happens When You Run git commit?

When you execute git commit, Git takes the changes in the staging area and creates a new commit object. This object contains a pointer to the snapshot of the files, metadata like author, timestamp, and a commit message. It also includes a pointer to the parent commit, forming a history chain.

Step-by-Step: Commit Process

Here's how the commit process works in practice:

# 1. Modify a file
echo "Hello, Git!" > example.txt

# 2. Stage the changes
git add example.txt

# 3. Commit the changes
git commit -m "Add example.txt with a greeting"

What’s Inside a Commit Object?

Each commit object contains:

• A tree object pointing to the file snapshot
• Metadata: author, committer, timestamp, and message
• A pointer to the parent commit (unless it's the initial commit)

Key Takeaways

• git commit creates a permanent snapshot of your project at that point in time.
• It relies on the staging area to determine what changes to include.
• Each commit links to its parent, forming a chain of history.

Writing Effective Commit Messages: Best Practices

Commit messages are the narrative thread that weaves your project's history together. A well-crafted commit message is not just a formality—it's a communication tool for your future self and your team. In this section, we'll explore the anatomy of a great commit message and how to write one that stands the test of time.

Why Good Commit Messages Matter

Effective commit messages:

• Improve code readability and project history
• Speed up debugging and code reviews
• Enable automation tools to parse and act on changes
• Support git bisect and other history-traversing tools

The 7 Rules of a Great Commit Message

Adopted from the Linux kernel team, these rules are the gold standard:

1. Separate subject from body with a blank line
2. Limit the subject line to 50 characters
3. Capitalize the subject line
4. Do not end the subject line with a period
5. Use the imperative mood in the subject line
6. Wrap the body at 72 characters
7. Use the body to explain what and why, not how

Structural Elements of a Good Commit Message

Here’s a breakdown of the components:

• Subject Line: Brief, imperative summary of the change
• Body: Detailed explanation of what changed and why
• Footer (optional): References to issues, tickets, or related commits

Example: A Well-Structured Commit Message

Add user authentication via OAuth2

Implement OAuth2 login using GitHub and Google providers. This includes:
- Adding passport.js middleware
- Updating user model to support multiple auth strategies
- Adding environment variables for provider secrets

Fixes #1234

Key Takeaways

• Good commit messages are a form of documentation that helps teams collaborate effectively.
• They follow a consistent structure and tone, making history easier to parse.
• They help with automation, debugging, and code reviews.

What Happens During a Commit: Git Objects and SHA-1 Hashes

Introduction: The Magic Behind the Commit

Every time you make a commit in Git, a series of powerful, low-level operations occur. Understanding what happens under the hood is essential for mastering version control. In this section, we'll explore how Git transforms your code into immutable objects using SHA-1 hashes, and how these objects form the backbone of Git’s content-addressable filesystem.

Git Objects: The Building Blocks of Version Control

Git uses four main object types to store your project’s data:

• Blob: Stores file data (like source code or images).
• Tree: Represents a directory, pointing to blobs and other trees to build a file hierarchy.
• Commit: Points to a tree and contains metadata like author, timestamp, and a pointer to the parent commit(s).
• Tag: A human-readable reference to a specific commit, often used for releases.

SHA-1 Hashing: The Engine of Immutability

Each Git object is identified by a SHA-1 hash, a 40-character hexadecimal string. This ensures that any change in content results in a new hash, enforcing immutability and data integrity. Here's how it works:

• Git generates a unique SHA-1 hash for each object (blob, tree, commit) based on its content.
• Even a single character change in a file results in a new blob and a new SHA-1 hash, triggering a new commit object.

Visualizing Git Objects in Action

Let’s walk through what happens when you make a commit:

1. Git takes a snapshot of your staged changes.
2. It creates a blob object for each file change.
3. It creates a tree object to represent the directory structure.
4. It generates a commit object, which points to the tree and includes metadata like author, timestamp, and commit message.

Example: Creating a Commit Object

Here’s a simplified example of how a commit object is structured:

commit 9a30b2e4f7d83b1f2e2a7c4d8a9b0e1f2a3c4d5e
Author: John Doe <johndoe@example.com>
Date:   Mon Apr 5 10:20:30 2024 +0000

    Fix user authentication logic

When you run git show or git log, Git reads these objects to display a commit history. The SHA-1 hash ensures that each object is unique and tamper-proof.

Key Takeaways

• Git uses SHA-1 hashes to ensure data integrity and immutability.
• Each commit references a tree object, which in turn references blob objects for each file.
• Understanding Git objects helps you debug issues, optimize workflows, and appreciate Git's robustness.

Inspecting Your Commit: 'git log' and 'git show'

Now that you understand how Git stores commits under the hood, it's time to learn how to inspect them. In this section, we'll explore the powerful tools Git provides to examine your commit history and understand what changed in each commit.

Using 'git log' to Explore Commit History

The git log command is your window into the past. It shows a chronological list of commits, each with its metadata. Here's how to use it effectively:

# Basic usage
git log

# One line per commit
git log --oneline

# Show changes with each commit
git log -p

# Limit to last 3 commits
git log -n 3

# Show commits by author
git log --author="John Doe"

# Show commits since a date
git log --since="2024-01-01"

# Show commits with file changes
git log --stat

Reading 'git log' Output

Here's a sample output of git log and what each part means:

commit 9a30b2e4f7d83b1f2e2a7c4d8a9b0e1f2a3c4d5e
Author: John Doe <johndoe@example.com>
Date:   Mon Apr 5 10:20:30 2024 +0000

    Fix user authentication logic

    This commit resolves the issue where users were unable to log in due to
    a missing null check in the authentication flow.

git config --global alias.lg "log --oneline --graph --all --decorate"

Using 'git show' to Inspect a Specific Commit

While git log gives you an overview, git show lets you dive deep into a specific commit. It displays the commit metadata along with the actual changes made:

git show 9a30b2e

This command shows you exactly what changed in that commit, including:

• Author and committer information
• Timestamps
• Commit message
• File diffs showing the exact changes

Reading 'git show' Output

Here's a breakdown of a typical git show output:

commit 9a30b2e4f7d83b1f2e2a7c4d8a9b0e1f2a3c4d5e
Author: John Doe <johndoe@example.com>
Date:   Mon Apr 5 10:20:30 2024 +0000

    Fix user authentication logic

diff --git a/src/auth.js b/src/auth.js
index 2e3f4a1..5a6b7c8 100644
--- a/src/auth.js
+++ b/src/auth.js
@@ -25,7 +25,7 @@ function authenticateUser(user) {
     if (!user) {
-        return false;
+        return null;
     }
     // ... more changes

Key Takeaways

• git log provides a high-level view of commit history, while git show gives detailed insights into specific commits.
• Use git log --oneline for a concise list of commits and git log -p to see changes with each commit.
• Custom aliases can make frequently used log formats much faster to access.
• Understanding how to read commit diffs is essential for debugging and code review.

Common Mistakes and How to Avoid Them

Even seasoned developers make mistakes when working with Git. The key is to recognize these pitfalls early and learn how to avoid them. This section outlines the most frequent missteps and how to sidestep them with best practices and clear workflows.

Key Takeaways

• Common Git mistakes include committing without staging, creating empty commits, and committing to the wrong branch.
• Always verify your branch and pull remote changes before pushing to avoid conflicts.
• Use git add to ensure only intended changes are committed.
• Understand how to use git commit --allow-empty appropriately to avoid unnecessary commits.
• Adopting a consistent branching and commit strategy helps avoid many of these errors.

Branching Out: What Comes After the First Commit

git checkout main
git pull origin main
git checkout -b feature/login-system

# ... coding happens here ...
git add .
git commit -m "feat: implement user authentication"

git push -u origin feature/login-system
# (Create Pull Request on GitHub/GitLab)
git checkout main
git merge feature/login-system