6.1.2. Git fundamentals
Table of Contents
Why Version Control Matters
Git is a distributed version control system. It helps you record changes to files, go back to previous versions, experiment safely, and collaborate with others.
Unlike saving many copies of a file like project-final-really-final.txt, Git creates a structured history of changes. It stores snapshots of your project and lets you see who changed what and when.
Git is distributed, which means every clone of a repository contains the full history. You can work offline, commit locally, and synchronize with others later.
Git records text changes extremely well. Commit early and often, with small focused changes and clear messages.
Git Repositories and Basic Concepts
A Git repository is a directory tracked by Git. Inside it, Git stores all history and metadata in a hidden .git directory.
There are two main ideas:
A working directory is your actual files that you edit.
The repository is the internal database of commits, branches, and tags, inside .git.
Every commit forms a node in a history graph. Each commit has a unique hash like a1b2c3d, which Git uses as an identifier. Commits also store a message, an author, and timestamps.
In Git, almost everything is addressed by a hash. You rarely need to type the whole hash. Usually the first 7 characters are enough, for example git show a1b2c3d.
The Three Git Areas
Git tracks changes using three areas: the working tree, the staging area, and the repository.
The working tree is your files on disk. When you edit files, they become modified in the working tree.
The staging area, also called the index, is a temporary area where you prepare changes to be committed. You select which changes go into the next commit.
The repository is where committed snapshots live. After you commit, your changes move from the staging area into the repository history.
You can visualize the flow as:
$$
\text{Working tree} \rightarrow \text{Staging area} \rightarrow \text{Repository (commits)}
$$
A commit only includes what is in the staging area, not every change in your working directory.
Creating and Cloning Repositories
There are two main ways to get a Git repository.
To start a new project in an existing directory, run:
git init
This creates a new .git directory and turns the current directory into a repository. At first, there are no commits until you add files and commit.
To copy an existing repository from somewhere else, such as GitHub, use git clone:
git clone https://github.com/user/project.gitThis command downloads the history and creates a new directory with a local copy. The new directory is a fully functional repository.
The repository you clone from is usually registered as a remote called origin. Remotes will be discussed in more detail when you start collaborating, but for now it is enough to know that origin is the default name for the place you cloned from.
Checking Repository Status
To see what Git thinks about your current directory, use:
git statusThis command shows:
Which branch you are on.
Which files are untracked, modified, or staged.
Hints about which commands to run next.
You will use git status often to understand your current state.
Tracking and Staging Files
New files are untracked. Git ignores them until you explicitly add them.
To start tracking a file and stage it for commit, run:
git add filenameYou can stage multiple files at once:
git add file1 file2 dir/To stage all changes in the repository:
git add .This stages new, modified, and deleted files. For beginners this is convenient, but be careful because it may stage more than you expect.
If you want to stage only parts of a file, you can use interactive staging:
git add -p filenameThis lets you choose individual hunks of changes, which is useful for creating clean, focused commits.
Only changes in the staging area will be included in the next commit. Always run git status before committing to verify what is staged.
Making Commits
A commit records a snapshot of the project. It also has a message that explains why the change was made.
To create a commit of the staged changes, run:
git commit -m "Short, meaningful message"Commit messages should describe the change, not just repeat filenames. For example:
Fix off-by-one error in line counter is better than update file.
If you omit -m, Git will open an editor so you can write a multi-line commit message. A common style is:
First line: short summary, around 50 characters.
Blank line.
Optional detailed description.
Each commit points to a parent commit. Together, they form a chain:
$$
\text{Commit}_1 \rightarrow \text{Commit}_2 \rightarrow \text{Commit}_3
$$
Git uses this chain to reconstruct the state of the project at any point in time.
Viewing History
To see the recent commit history, use:
git logThis shows commits with their hashes, authors, dates, and messages. The default view can be long, so you can use shorter formats, for example:
git log --onelineThis prints a single line per commit, with a short hash and the first line of the commit message.
To see which changes a specific commit introduced, use:
git show <commit-hash>You can use abbreviations like:
git show HEAD
HEAD means the current commit that your working directory is based on.
Inspecting and Comparing Changes
Git can show what has changed before you commit. To see modifications in your working tree that are not staged, run:
git diffTo see what is staged and will be included in the next commit, run:
git diff --cachedThese commands display differences line by line. Deletions are prefixed with a minus sign, additions with a plus sign.
Always review your changes with git diff or git diff --cached before committing. This reduces accidental commits of debug code or secrets.
Undoing and Fixing Common Mistakes
You will make mistakes, and Git provides several tools to correct them.
If you changed a tracked file and want to discard your local modifications and return to the last committed version, run:
git restore filename
If you already staged changes with git add, but want to unstage them while keeping the modifications in your working tree, use:
git restore --staged filenameIf your last commit message is wrong or you forgot to include a file, you can amend the most recent commit:
git commit --amendThis replaces the last commit with a new one, which can have a different message and contents. Use this only on local commits that you have not yet shared with others.
To create a commit that reverts the effect of an earlier one, use:
git revert <commit-hash>
This makes a new commit that applies the opposite changes. git revert is safe even for shared history.
There is also git reset, which can move HEAD and change history. It is powerful but also dangerous when used incorrectly. For beginners, prefer git restore and git revert, which are safer.
Basic Branching
A branch is a movable pointer to a series of commits. Branches let you work on new features or experiments without affecting the main line of development.
To list existing branches, run:
git branchTo create a new branch based on the current commit:
git branch feature-xTo switch to a branch:
git switch feature-xYou can also create and switch to a new branch in one command:
git switch -c feature-x
The branch you are on controls where new commits are added. When you commit on feature-x, that branch moves forward. Other branches remain unchanged.
Basic Merging
When you are done working on a branch and want to bring its changes into another branch, you usually perform a merge.
First, switch to the branch that should receive the changes. For example, to merge feature-x into main:
git switch main
git merge feature-xGit will attempt to combine the changes automatically. If there are no conflicting edits, it creates a merge commit that connects the two lines of history.
If both branches changed the same lines in a file, Git cannot decide which version is correct. This creates a merge conflict. Git marks the conflicting parts in the file and git status shows which files need attention.
To resolve a conflict, open the affected file, edit it to the correct content, then stage the file and complete the merge with a commit.
During a merge, never delete conflict markers like <<<<<<< and >>>>>>> without carefully choosing the correct content. After editing, always run git status to make sure all conflicts are resolved before committing.
Remotes, Push, and Pull
To collaborate with others or back up your work, you use remote repositories, typically on a server or hosting service.
You can list configured remotes with:
git remote -vAfter committing locally, you can send your changes to the default remote with:
git pushUsually, this is shorthand for:
git push origin main
This means push the local main branch to the origin remote. The first time you push a new branch, you may need to set the upstream:
git push -u origin feature-xTo bring remote changes into your local repository, use:
git pull
git pull is equivalent to git fetch followed by a merge. It downloads new commits and then integrates them into your current branch. Later, you may choose to work with git fetch and merge or rebase manually, but for starting out, git pull is sufficient.
Ignoring Files
Some files should not be tracked, such as build artifacts, temporary files, and local editor settings. You can tell Git to ignore them using a .gitignore file.
Create a file named .gitignore in the root of your repository, and list patterns of files and directories to ignore. For example:
# Ignore build outputs
build/
*.o
# Ignore editor settings
.vscode/
*.swp
Git will then treat those paths as untracked and not suggest adding them. If a file is already tracked, adding it to .gitignore does not remove it from the repository. You must remove it with git rm --cached filename if you want it to stop being tracked.
Never commit secrets such as passwords, private keys, or API tokens. Add them to .gitignore or store them using dedicated secret management tools.
Basic Best Practices
For effective use of Git, keep a few simple habits.
Commit frequently, but with each commit focused on one logical change.
Write clear, descriptive commit messages that explain the reason for the change.
Review changes with git diff and git status before each commit and before each push.
Use branches to isolate features and experiments from stable code.
Always pull remote changes before starting new work, especially on shared branches.
These fundamentals will make Git a reliable tool that supports your development on Linux and prepares you for more advanced workflows later.
Views: 0
Where to Move
Move chapter:
- ☰ 1. PART I — Linux Fundamentals (Beginner)
- ☰ 1.1. What Is Linux?
- ☰ 1.1.1. What is an operating system
- ☰ 1.1.2. History of Unix and Linux
- ☰ 1.1.3. The Linux kernel
- ☰ 1.1.4. GNU and the Free Software Foundation
- ☰ 1.1.5. Open source philosophy
- ☰ 1.1.6. Where Linux is used today
- ☰ 1.1.7. Desktop vs server vs embedded Linux
-
- ☰ 1.2. Choosing a Linux Distribution
- ☰ 1.2.1. What is a distribution?
- ☰ 1.2.2. Package formats (deb, rpm, pacman)
- ☰ 1.2.3. Popular distributions
- ☰ 1.2.3.1. Ubuntu
- ☰ 1.2.3.2. Debian
- ☰ 1.2.3.3. Fedora
- ☰ 1.2.3.4. Arch Linux
- ☰ 1.2.3.5. openSUSE
-
- ☰ 1.2.4. Rolling vs fixed release
- ☰ 1.2.5. Choosing the right distribution
-
- ☰ 1.3. Installing Linux
- ☰ 1.3.1. Creating a bootable USB
- ☰ 1.3.2. Installing on real hardware
- ☰ 1.3.3. Dual booting with Windows
- ☰ 1.3.4. Installing in a virtual machine
- ☰ 1.3.5. Partitioning
- ☰ 1.3.5.1. `/` (root)
- ☰ 1.3.5.2. `/home`
- ☰ 1.3.5.3. Swap
-
- ☰ 1.3.6. First-time setup
-
- ☰ 1.4. First Steps After Installation
- ☰ 1.4.1. Desktop environment basics
- ☰ 1.4.2. Updating the system
- ☰ 1.4.3. Installing essential tools
- ☰ 1.4.4. Setting up drivers
- ☰ 1.4.5. Using the software center
-
- ☰ 1.5. Linux Filesystem Hierarchy
- ☰ 1.5.1. Overview of the root filesystem
- ☰ 1.5.2. Important directories
- ☰ 1.5.2.1. `/etc`
- ☰ 1.5.2.2. `/var`
- ☰ 1.5.2.3. `/usr`
- ☰ 1.5.2.4. `/tmp`
- ☰ 1.5.2.5. `/dev`
- ☰ 1.5.2.6. `/proc`
- ☰ 1.5.2.7. `/sys`
-
- ☰ 1.5.3. File types
- ☰ 1.5.4. Absolute vs relative paths
-
- ☰ 1.6. The Linux Graphical Environment
- ☰ 1.6.1. GNOME
- ☰ 1.6.2. KDE Plasma
- ☰ 1.6.3. XFCE
- ☰ 1.6.4. File managers
- ☰ 1.6.5. System settings
- ☰ 1.6.6. Workspaces and window management
-
-
- ☰ 2. PART II — Command Line Essentials
- ☰ 2.1. Terminal and Shell Basics
- ☰ 2.1.1. What is a shell?
- ☰ 2.1.2. Bash vs Zsh vs Fish
- ☰ 2.1.3. Command structure
- ☰ 2.1.4. Environment variables
- ☰ 2.1.5. Getting help
- ☰ 2.1.6. Command history and autocomplete
-
- ☰ 2.2. Files and Directories
- ☰ 2.2.1. Listing files
- ☰ 2.2.2. Navigating directories
- ☰ 2.2.3. File operations
- ☰ 2.2.4. Wildcards and globbing
- ☰ 2.2.5. Searching files
-
- ☰ 2.3. Viewing and Editing Text Files
- ☰ 2.3.1. Viewing tools
- ☰ 2.3.2. Editing with nano
- ☰ 2.3.3. Introduction to vim
- ☰ 2.3.4. Input/output redirection
-
- ☰ 2.4. Users, Permissions, and Ownership
- ☰ 2.4.1. Users and groups
- ☰ 2.4.2. Permission types (r, w, x)
- ☰ 2.4.3. Changing permissions
- ☰ 2.4.4. Changing ownership
- ☰ 2.4.5. Using sudo
-
- ☰ 2.5. Package Management
- ☰ 2.5.1. Software repositories
- ☰ 2.5.2. APT (Debian/Ubuntu)
- ☰ 2.5.3. DNF (Fedora/RHEL)
- ☰ 2.5.4. Pacman (Arch Linux)
- ☰ 2.5.5. Snap, Flatpak, AppImage
- ☰ 2.5.6. System upgrades
-
- ☰ 2.6. Working with Processes
- ☰ 2.6.1. What is a process?
- ☰ 2.6.2. Viewing processes
- ☰ 2.6.3. Killing processes
- ☰ 2.6.4. Foreground and background jobs
- ☰ 2.6.5. System services and daemons
-
- ☰ 2.7. Introduction to Shell Scripting
- ☰ 2.7.1. Writing your first script
- ☰ 2.7.2. Variables
- ☰ 2.7.3. Conditionals
- ☰ 2.7.4. Loops
- ☰ 2.7.5. Functions
- ☰ 2.7.6. Making scripts executable
-
-
- ☰ 3. PART III — Intermediate System Administration
- ☰ 3.1. Systemd and Service Management
- ☰ 3.1.1. What is systemd?
- ☰ 3.1.2. Managing services (systemctl)
- ☰ 3.1.3. Boot targets
- ☰ 3.1.4. System logs (journalctl)
- ☰ 3.1.5. Creating custom services
-
- ☰ 3.2. Storage and Filesystems
- ☰ 3.2.1. Devices and partitions
- ☰ 3.2.2. Filesystems (EXT4, XFS, Btrfs)
- ☰ 3.2.3. Mounting and unmounting
- ☰ 3.2.4. Disk usage tools
- ☰ 3.2.5. Archiving and compression (tar, gzip, xz)
-
- ☰ 3.3. Networking Fundamentals
- ☰ 3.3.1. IP addressing
- ☰ 3.3.2. Subnets and routing
- ☰ 3.3.3. DNS and hostnames
- ☰ 3.3.4. Networking tools (ip, ss, ping)
- ☰ 3.3.5. Editing network configuration files
-
- ☰ 3.4. User and Group Administration
- ☰ 3.4.1. User information files
- ☰ 3.4.2. Creating and removing users
- ☰ 3.4.3. Password policies
- ☰ 3.4.4. Managing groups
- ☰ 3.4.5. Shell configuration
-
- ☰ 3.5. System Monitoring
- ☰ 3.5.1. CPU and memory monitoring
- ☰ 3.5.2. Disk and I/O monitoring
- ☰ 3.5.3. Log files in /var/log
- ☰ 3.5.4. Boot performance
- ☰ 3.5.5. Monitoring running services
-
- ☰ 3.6. Backup and Restore
- ☰ 3.6.1. Backup strategies
- ☰ 3.6.2. Using rsync
- ☰ 3.6.3. Creating tar archives
- ☰ 3.6.4. Using snapshot systems
- ☰ 3.6.5. Automating backups
-
- ☰ 3.7. Basic System Security
- ☰ 3.7.1. Firewalls (UFW, firewalld)
- ☰ 3.7.2. Authentication policies
- ☰ 3.7.3. SSH security basics
- ☰ 3.7.4. SELinux and AppArmor overview
- ☰ 3.7.5. Intrusion detection basics
-
-
- ☰ 4. PART IV — Advanced Linux Skills
- ☰ 4.1. Advanced Shell Scripting
- ☰ 4.1.1. Script structure
- ☰ 4.1.2. Error handling
- ☰ 4.1.3. Debugging scripts
- ☰ 4.1.4. Scheduled tasks (cron)
-
- ☰ 4.2. The Linux Boot Process
- ☰ 4.2.1. BIOS vs UEFI
- ☰ 4.2.2. Understanding GRUB2
- ☰ 4.2.3. Kernel loading
- ☰ 4.2.4. initramfs
- ☰ 4.2.5. Troubleshooting boot issues
-
- ☰ 4.3. Kernel Management
- ☰ 4.3.1. What is the kernel?
- ☰ 4.3.2. Kernel modules
- ☰ 4.3.3. Kernel parameters
- ☰ 4.3.4. Compiling a custom kernel
- ☰ 4.3.5. Kernel versioning and updates
-
- ☰ 4.4. Advanced Filesystems and Storage
- ☰ 4.4.1. LVM concepts
- ☰ 4.4.2. Logical volumes
- ☰ 4.4.3. RAID levels
- ☰ 4.4.4. Full disk encryption (LUKS)
- ☰ 4.4.5. Snapshots and rollbacks
-
- ☰ 4.5. Network Services
- ☰ 4.5.1. SSH server configuration
- ☰ 4.5.2. NFS
- ☰ 4.5.3. Samba
- ☰ 4.5.4. FTP/SFTP
- ☰ 4.5.5. Firewalls in depth
-
- ☰ 4.6. Logging and Auditing
- ☰ 4.6.1. Systemd logging
- ☰ 4.6.2. Traditional logs in /var/log
- ☰ 4.6.3. Auditd
- ☰ 4.6.4. Log rotation
- ☰ 4.6.5. Creating custom logs
-
- ☰ 4.7. Virtualization and Containers
- ☰ 4.7.1. Virtual machines (KVM/QEMU)
- ☰ 4.7.2. Linux containers (LXC/LXD)
- ☰ 4.7.3. Docker fundamentals
- ☰ 4.7.4. Podman vs Docker
- ☰ 4.7.5. Container networking
-
-
- ☰ 5. PART V — Server Administration (Expert)
- ☰ 5.1. Web Servers
- ☰ 5.1.1. Apache basics
- ☰ 5.1.2. Nginx basics
- ☰ 5.1.3. Virtual hosts
- ☰ 5.1.4. SSL/HTTPS
- ☰ 5.1.5. Reverse proxy concepts
-
- ☰ 5.2. Database Servers
- ☰ 5.2.1. MySQL/MariaDB
- ☰ 5.2.2. PostgreSQL
- ☰ 5.2.3. Database backup strategies
- ☰ 5.2.4. Database hardening
-
- ☰ 5.3. Email Services
- ☰ 5.3.1. SMTP fundamentals
- ☰ 5.3.2. Configuring Postfix
- ☰ 5.3.3. IMAP/POP3 with Dovecot
- ☰ 5.3.4. Spam filtering systems
- ☰ 5.3.5. Email routing concepts
-
- ☰ 5.4. DNS and DHCP
- ☰ 5.4.1. Understanding DNS
- ☰ 5.4.2. Setting up BIND
- ☰ 5.4.3. DNS zones and records
- ☰ 5.4.4. DHCP server configuration
- ☰ 5.4.5. DNS troubleshooting
-
- ☰ 5.5. Load Balancing
- ☰ 5.5.1. HAProxy fundamentals
- ☰ 5.5.2. Nginx as a load balancer
- ☰ 5.5.3. Session persistence
- ☰ 5.5.4. High availability concepts
-
- ☰ 5.6. Clustering and High Availability
- ☰ 5.6.1. Failover principles
- ☰ 5.6.2. Pacemaker
- ☰ 5.6.3. Corosync
- ☰ 5.6.4. Cluster resource management
- ☰ 5.6.5. Distributed filesystems
-
-
- ☰ 6. PART VI — DevOps and Cloud
- ☰ 6.1. Linux for Developers
- ☰ 6.1.1. Compiler toolchains (gcc, make)
- ☰ 6.1.2. Git fundamentals
- ☰ 6.1.3. Debugging tools (gdb, strace)
- ☰ 6.1.4. Build automation (Makefile, CMake)
-
- ☰ 6.2. DevOps on Linux
- ☰ 6.2.1. CI/CD principles
- ☰ 6.2.2. YAML basics
- ☰ 6.2.3. GitHub Actions
- ☰ 6.2.4. GitLab CI/CD
- ☰ 6.2.5. Automated testing
-
- ☰ 6.3. Configuration Management
- ☰ 6.3.1. Ansible basics
- ☰ 6.3.2. Playbooks and inventories
- ☰ 6.3.3. Puppet overview
- ☰ 6.3.4. Chef overview
-
- ☰ 6.4. Infrastructure as Code
- ☰ 6.4.1. Terraform fundamentals
- ☰ 6.4.2. Providers and resources
- ☰ 6.4.3. Modules
- ☰ 6.4.4. Cloud provisioning with Terraform
-
- ☰ 6.5. Cloud Computing with Linux
- ☰ 6.5.1. Linux on AWS
- ☰ 6.5.2. Linux on Azure
- ☰ 6.5.3. Linux on GCP
- ☰ 6.5.4. Cloud networking basics
- ☰ 6.5.5. Scaling and monitoring
-
-
- ☰ 7. PART VII — Master Topics
- ☰ 7.1. Hardening a Linux System
- ☰ 7.1.1. Hardening principles
- ☰ 7.1.2. Kernel hardening
- ☰ 7.1.3. File integrity monitoring
- ☰ 7.1.4. Vulnerability scanning
-
- ☰ 7.2. Forensics and Incident Response
- ☰ 7.2.1. Collecting evidence
- ☰ 7.2.2. Log and file recovery
- ☰ 7.2.3. Analyzing suspicious processes
- ☰ 7.2.4. Incident response workflow
-
- ☰ 7.3. Performance Tuning
- ☰ 7.3.1. CPU tuning
- ☰ 7.3.2. Memory tuning
- ☰ 7.3.3. Disk and I/O optimization
- ☰ 7.3.4. Profiling tools
-
- ☰ 7.4. Writing Linux Tools
- ☰ 7.4.1. Bash-based tools
- ☰ 7.4.2. Python command-line tools
- ☰ 7.4.3. Writing tools in C
- ☰ 7.4.4. Using Linux system APIs
-
- ☰ 7.5. Linux Internals
- ☰ 7.5.1. Process lifecycle
- ☰ 7.5.2. Memory management
- ☰ 7.5.3. Signals and IPC
- ☰ 7.5.4. Namespaces
- ☰ 7.5.5. cgroups
-
- ☰ 7.6. Becoming a Linux Expert
- ☰ 7.6.1. Career paths
- ☰ 7.6.2. Certifications (RHCE, LFCS, LPIC)
- ☰ 7.6.3. Building a homelab
- ☰ 7.6.4. Contributing to open source
-
-
Comments
Please login to add a comment.
Don't have an account? Register now!