Beginner’s Guide to Code Management Like a Pro

Beginner’s Guide to Code Management Like a Pro

Git & GitHub Basics to Get Started

Soumo Sarkar's photo
Soumo Sarkar
·

6 min read

Table of contents

So, you’ve heard developers talking about Git and GitHub, but you’re not sure where to start? Don’t worry! This guide will turn you from a Git newbie to a confident collaborator, ready to work on real-world projects. Let’s dive in!

Why Git & GitHub? 🤔

Imagine writing a book and saving every draft so you can undo mistakes or try new ideas without losing progress. Git does exactly that for code! It’s a version control system that tracks changes, while GitHub is the social platform where developers host and collaborate on Git projects. Together, they’re the backbone of modern software development.

Step 1: Installation & Setup 💻

  1. Install Git

    • Windows: Download Git Bash.

    • Mac/Linux: Use terminal commands:

        # Mac (via Homebrew)  
  brew install git  
  # Ubuntu/Debian  
  sudo apt install git

  2. Configure Git
    Set your name and email (used in commits):

     git config --global user.name "Your Name"  
 git config --global user.email "your@email.com"

  3. Create a GitHub Account
    Head to github.com and sign up.

Step 2: Git Basics – Commands You’ll Use Daily 👨🏻‍💻

1. git clone: Copy a Repository

Want to work on an existing project? Clone it!

git clone https://github.com/username/repo-name.git

This downloads the entire project to your local machine.

2. git add: Stage Your Changes

After editing files, you need to stage them (like adding items to a cart):

# Stage a specific file  
git add filename.py  

# Stage ALL changes  
git add .

3. git commit: Save Changes with a Message

Commits are snapshots of your code. Always add a meaningful message:

git commit -m "Added login button functionality"

Pro Tip: Commit often! Small, focused commits make debugging easier.

4. git status & git log: Check Progress

  • git status: See what’s staged/unstaged.

  • git log: View commit history (with IDs, authors, and messages).

Step 3: Branching Like a Pro 🌿

Branches let you work on features without messing up the main codebase.

1. Create & Switch Branches

# Create a new branch  
git branch feature-login  

# Switch to the branch  
git checkout feature-login  

# Shortcut: Create + switch  
git checkout -b feature-login

# Check the current branch you're in
git branch

2. Merge vs. Rebase

  • Merge: Combines branches and keeps history intact.

      git checkout main  
  git merge feature-login

  • Rebase: Rewrites history for a cleaner timeline (use carefully!).

      git checkout feature-login  
  git rebase main

When to use?

  • Merge for public/shared branches.

  • Rebase for personal branches to keep history linear.

Step 4: Collaborating on GitHub 🤝

1. Forking a Repository

A fork is your copy of someone else’s repo. Click “Fork” on GitHub, then clone it locally:

git clone https://github.com/YOUR-USERNAME/repo-name.git

2. Pull Requests (PRs)

  1. Push your branch to GitHub:

     git push origin feature-login

  2. On GitHub, create a Pull Request to merge your changes into the original repo.

Step 5: SSH Setup in GitHub for Secure Access 🔑

No more typing passwords!

  1. Generate SSH Key

     ssh-keygen -t rsa -b 4096 -C "your-email@example.com"

    Press Enter to save in the default location.

  2. Add Key to GitHub

    • Copy the public key:

        cat ~/.ssh/id_rsa.pub

    • Go to Your GitHub Account → Settings → SSH and GPG Keys → Add New Key.

  3. Test Connection

     ssh -T git@github.com

    You’ll see: “Hi username! You’ve successfully authenticated!”

Handling Mistakes: Undoing Changes Like a Wizard 🧙♂️

1. git restore: Undo Unwanted Changes

Accidentally edited a file? git restore lets you discard changes in your working directory or staging area.

  • Discard changes in a specific file:

      git restore filename.py

  • Unstage a file (remove from staging area):

      git restore --staged filename.py

Why use this? It’s safer than git reset for beginners—no risk of losing commit history!

2. git checkout: Switch Branches or Restore Old Files

While git restore handles changes, git checkout is a Swiss Army knife:

  • Switch branches:

      git checkout main

  • Restore a deleted file from a previous commit:

      git checkout HEAD~1 -- deleted-file.py

Advanced Workflow Tips 🔥

1. git stash: Save Changes Temporarily

Need to switch branches but don’t want to commit half-done work? Stash it!

git stash          # Save changes  
git stash pop      # Restore the latest stash  
git stash list     # View all stashes

Pro Tip: Add a message for clarity:

git stash save "Work on login feature"

2. git fetch vs. git pull: Stay Updated

  • git fetch: Downloads updates from the remote repo without merging them.

      git fetch origin

  • git pull: Fetches and merges changes into your current branch.

      git pull origin main

Best Practice: Use git pull --rebase to avoid messy merge commits:

git pull --rebase origin main

3. git diff: See What Changed

Compare differences between:

  • Working directory and last commit:

      git diff

  • Two branches:

      git diff feature-login main

  • Specific commits:

      git diff commit-id-1 commit-id-2

6. git remote: Manage Remote Repositories

Working with multiple remotes (e.g., a fork and the original repo)?

  • List remotes:

      git remote -v

    Output:

      origin  https://github.com/username/repo.git (fetch)  
  origin  https://github.com/username/repo.git (push)

In this case, origin is the default name for the primary remote repository.

  • Add a new remote:

    If you want to connect your local repository to another remote, use the git remote add command:

      git remote add upstream https://github.com/original/repo.git

  • Fetch updates from upstream:

      # Fetch changes from upstream
  git fetch upstream

  # Merge upstream/main into your current branch
  git merge upstream/main

  • Remove a remote:

      git remote remove origin

Versioning Like a Pro with git tag 🏷️

Mark releases or milestones with tags:

# Create a lightweight tag  
git tag v1.0.0  

# Create an annotated tag (with message)  
git tag -a v1.0.0 -m "First stable release"  

# Push tags to GitHub  
git push origin --tags

Bonus: Create a Killer GitHub Profile! 🎨

Add a README.md to your profile repo (username/username):

  1. Create a repo named exactly as your GitHub username.

  2. Add a README.md with Markdown/HTML:

# 👋 Hi, I’m [Your Name]!  

## 🛠️ Tech Stack  
- **Languages**: Python, JavaScript  
- **Tools**: Docker, AWS  

## 🔥 Latest Projects  
- [Project 1](https://github.com/your-username/project1): A cool automation script!  

<img src="https://img.shields.io/badge/Follow%20Me-%230077B5?style=flat&logo=linkedin" alt="LinkedIn">

Result: This README becomes your GitHub profile’s landing page!

Industry Best Practices 🏆

  1. Branch Naming: Use feature/, bugfix/, or refactor/ prefixes.

  2. Atomic Commits: Keep commits small and focused on one task.

  3. Commit Messages: Follow Conventional Commits.

  4. .gitignore: Exclude files like node_modules/, .env, logs, binaries, or secrets.

You’re Now Git-Ready! 🚀

Git and GitHub might feel overwhelming at first, but with practice, they’ll become second nature. Remember:

  • Google is your friend (everyone forgets commands!).

  • Experiment in a dummy repo.

  • Contribute to open source to sharpen your skills.

Happy coding! 💻

Loved this guide?

  • Like ❤️ if it helped!

  • Follow for more DevOps/cloud content.

  • Share to help others start their Git journey!

#Git #GitHub #DevOps #VersionControlSystem #Programming

Stuck? Drop a comment below! Let’s learn together. 🌟

GitHubGitvcscode managementSSH Gitgit branching