Git

Version ControlDevOpsCLIDistributedOpen SourceCollaboration

Version Control Tool

Git

Overview

Git is a distributed version control system designed for speed, efficiency, and reliability. Created by Linus Torvalds in 2005, Git enables developers to track changes, collaborate on projects, and maintain complete history of their codebase. As the most widely used version control system in the world, Git forms the backbone of modern software development workflows.

Details

Git operates on a distributed model where every developer has a complete copy of the project history. Unlike centralized systems, Git doesn't rely on a single server, making it more resilient and allowing offline work. Key features include branching and merging capabilities, staging area for selective commits, and cryptographic integrity through SHA-1 hashing.

The system consists of three main areas: the working directory (your local files), the staging area (index), and the Git repository (.git directory). This three-stage workflow allows for precise control over what gets committed and when.

Git's branching model is lightweight and encourages feature-based development. Branches are merely pointers to specific commits, making creation and switching between branches extremely fast. The merge and rebase operations provide flexible ways to integrate changes from different branches.

Advantages and Disadvantages

Advantages

Distributed Architecture: Complete repository history on every machine
Speed: Optimized for performance with most operations being local
Branching Excellence: Lightweight branches encourage experimentation
Data Integrity: Cryptographic checksums ensure data consistency
Offline Capability: Full functionality without network connection
Flexible Workflows: Supports various development methodologies
Wide Adoption: Industry standard with extensive tool support
Open Source: Free and constantly improved by the community

Disadvantages

Learning Curve: Complex concepts can be intimidating for beginners
Storage Overhead: Complete history requires more disk space
Binary File Handling: Not optimized for large binary files
Complex Merge Conflicts: Difficult conflicts can be challenging to resolve
Command Complexity: Many commands with numerous options
Steep Initial Setup: Initial configuration and concepts require learning

Reference Pages

Code Examples

Basic Repository Setup

# Initialize a new Git repository
git init

# Clone an existing repository
git clone https://github.com/user/repository.git

# Check repository status
git status

# Add files to staging area
git add file.txt
git add .  # Add all files

# Commit changes
git commit -m "Initial commit"

# View commit history
git log
git log --oneline

Branching and Merging

# Create a new branch
git branch feature/new-feature
git checkout feature/new-feature
# Or create and switch in one command
git checkout -b feature/new-feature

# Switch between branches
git checkout main
git switch main  # Modern syntax

# Merge branches
git checkout main
git merge feature/new-feature

# Delete a branch
git branch -d feature/new-feature

Remote Repository Operations

# Add remote repository
git remote add origin https://github.com/user/repo.git

# Push changes to remote
git push origin main
git push -u origin main  # Set upstream

# Pull changes from remote
git pull origin main

# Fetch remote changes without merging
git fetch origin

# List remote repositories
git remote -v

Advanced Workflow Commands

# Interactive staging
git add -i

# Stash changes temporarily
git stash
git stash pop
git stash list

# Rebase for cleaner history
git rebase main
git rebase -i HEAD~3  # Interactive rebase

# Cherry-pick specific commits
git cherry-pick commit-hash

# View differences
git diff
git diff --staged

Configuration and Aliases

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

# Create useful aliases
git config --global alias.st status
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit

# View configuration
git config --list

Troubleshooting and Recovery

# Undo last commit (keep changes)
git reset --soft HEAD~1

# Undo last commit (discard changes)
git reset --hard HEAD~1

# Revert a specific commit
git revert commit-hash

# Clean untracked files
git clean -fd

# Find when a bug was introduced
git bisect start
git bisect bad
git bisect good commit-hash