Day 15 of 90 Days of DevOps Challenge: Version Control Systems

Whether you're a developer, tester, or part of a DevOps team, understanding version control is an essential skill. In this blog, I’m documenting what I’ve learned about Version Control Systems (VCS). what they are, why they matter, and how tools like Git and GitHub help developers collaborate and manage code changes efficiently. This is not just a post, it’s a step in my journey toward mastering DevOps, and I hope it helps you too if you’re starting out!

What is a Version Control System (VCS)?

A Version Control System (VCS) is a tool that helps developers, testers, and DevOps teams collaborate, track changes, and manage source code efficiently throughout the development lifecycle.

With a VCS:

• You can track what was changed, who changed it, and why.

• Revert to previous versions if needed.

• Collaborate without overwriting others' code.

• Work with different versions (branches) of the code simultaneously.

Why Use Version Control?

• Team collaboration

• Backup and recovery

• Version history and audit trail

• Simplified debugging

• Easier code integration and deployment

Examples of Version Control Software

• Git (Most Popular – Used with GitHub, GitLab, Bitbucket)

• SVN (Subversion)

• Mercurial

What is GitHub?

GitHub is a web-based platform built on top of Git (a distributed version control system). It is widely used for:

• Hosting and sharing code repositories.

• Tracking and managing code changes.

• Collaborating with other developers using features like pull requests, issues, and actions.

GitHub Features at a Glance

• Public/Private Repos – Control who can view or contribute.

• Issues & Discussions – Track bugs and collaborate easily.

• Repositories – Store code, docs, and project files.

• CI/CD & Packages – Automate builds, tests, and deployments.

Environment Setup for Git & GitHub

Step 1: Create a GitHub Account

Visit https://github.com and sign up.

Step 2: Install Git

Download Git from https://git-scm.com/ and install it on your system.

Step 3: Configure Git (One-time setup)

Open Git Bash and run:

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

What is a GitHub Repository?

A repository (repo) is a storage space for your project. It contains all files, folders, and history related to your project.

Types of Repositories:

• Public Repo – Anyone can view, but you can control who contributes.

• Private Repo – Restricted visibility; only allowed users to access and modify.

NOTE: A GitHub repo is also called the remote or central repository.

Git Architecture (Centralized Workflow)

Here's how Git works step by step:

1. Working Tree: Local directory where you edit files.

2. Staging Area (Index): Temporarily stores changes before committing.

3. Local Repository: Stores all commit and change history.

4. Remote Repository (GitHub): Final destination for sharing code with others.

Flow:

Working Tree → Staging Area → Local Repo → Remote Repo (GitHub)

Common Git Commands

git config → Configure name & email

git init → Initialize a new Git repo in current directory (working tree)

git status → View current file status

git add → Stage changes for commit (staging area)

git commit -m “message “→ Save changes from staging area to local repo

git push → To send files from the local repo to the remote repo

git pull → Pull latest changes from central repo to local repo

git clone <URL> → Copy remote repo to local system

git log → View commit history

git restore <file> → to discard local changes

git restore --staged <file> → Unstage staged changes

git rm <file> → delete file from local repo

git revert <commitID> → revert changes from central repo (revert + commit + push)

To delete it from central repo too → git rm → git commit -m 'msg' → git push

Final Thoughts

As I'm learning Git and GitHub, I’ve realized how powerful and essential version control is in real-world projects. It’s not just about saving code. it’s about working smart, tracking changes, and collaborating better. This journey has made me more confident in managing my projects efficiently. I'm excited to explore more advanced features like branching, pull requests, and GitHub Actions. Excited to keep learning, building, and pushing code like a pro.