Understanding GitHub as a Version Control System

🚀 Day 56 – Understanding Git Reset vs Git Revert 🚀 Today I explored an important concept in Git — the difference between resetting commits and reverting commits. Both are used to undo changes, but they work in very different ways. 🔹 What I Learned Today ✔ Git Reset git reset is used to move the current branch pointer back to a previous commit. Types of reset: Soft Reset → Keeps changes staged Mixed Reset → Keeps changes but unstaged Hard Reset → Removes commits and changes completely This command is powerful but should be used carefully, especially when working with shared repositories. ✔ Git Revert git revert is used to undo a specific commit by creating a new commit that reverses the changes. Key points: Does not remove commit history Safe for shared repositories Maintains a clear project timeline 🔹 Reset vs Revert Feature Reset Revert Commit History Rewrites history Keeps history Safe for Teams No Yes Use Case Local fixes Shared repositories 🔹 Reflection Understanding the difference between reset and revert helps developers safely manage mistakes while keeping the project history organized. Version control is not just about saving code — it's about managing change responsibly. #Git #GitHub #VersionControl #SoftwareDevelopment #DeveloperJourney #100DaysOfCode #LearningByDoing #TechGrowth 🚀

🚀 Day 55 – Going Back to Previous Versions in Git 🚀 Today I learned how to restore older versions of code using Git. This is one of the most powerful features of version control because it allows developers to safely experiment and always return to a stable version 🔁 🔹 What I Learned Today ✔ Viewing Commit History Used: git log This command shows the history of commits, including commit IDs, messages, and timestamps. ✔ Going Back to a Previous Version Using checkout: git checkout <commit-id> This allows you to view the project at a specific point in history. ✔ Resetting to a Previous Commit Used reset to move the branch back: git reset --soft <commit-id> Keeps changes staged. git reset --mixed <commit-id> Keeps changes but unstaged. git reset --hard <commit-id> Completely resets project to that version. ✔ Reverting a Commit Another safe method: git revert <commit-id> This creates a new commit that undoes the previous changes, which is safer for shared repositories. 🔹 Key Learning Git allows developers to track, restore, and manage every version of code. This makes development much safer and prevents losing important work 🔐 🔹 Reflection Understanding how to move between versions gives me more confidence to experiment and improve my code without fear of breaking things 🚀 #Git #GitHub #VersionControl #SoftwareDevelopment #100DaysOfCode #LearningJourney #DeveloperTools 💻🚀

🚀 Day 53 – Pulling Changes, Resolving Conflicts & Managing Code Safely 🚀 Today I focused on handling real-world Git challenges — syncing updates, resolving conflicts, and undoing mistakes like a professional developer 💻⚡ 🔹 What I Learned Today ✔ Pull Command git pull → Fetch + merge updates from remote repository Understood how to keep local code in sync with team updates Learned the importance of pulling before pushing ✔ Resolving Merge Conflicts Understood why conflicts occur (same file, same lines changed) Practiced manually resolving conflicts Staged and committed the resolved version This was a big learning moment — conflicts aren’t scary when you understand them 🔥 ✔ Undoing Changes Explored safe recovery techniques: git restore git reset git revert Now I know how to fix mistakes without breaking project history. ✔ Forking Repositories Learned how to fork projects on GitHub to: Contribute to open source Experiment independently Work without affecting the original repository 🔹 Reflection Today made Git feel real and powerful. Version control isn’t just about saving code — it’s about managing collaboration, mistakes, and evolution safely 🧠 Every day, my development workflow is becoming more professional 🚀 #Git #GitHub #VersionControl #MergeConflicts #DeveloperWorkflow #OpenSource #FullStackJourney #100DaysOfCode #TechGrowth 🚀

🚀 Day 23 – Git Branching & My First Push to GitHub Today I unlocked one of the most powerful concepts in Git: 👉 Branching Yesterday I learned how to commit. Today I learned how real developers actually work. 🌿 What I Practiced Today ✅ Created and switched between multiple branches ✅ Understood how HEAD works ✅ Used git switch (modern way) instead of checkout ✅ Made feature-specific commits ✅ Verified branch isolation ✅ Deleted unused branches ✅ Pushed both main and feature-1 to GitHub ✅ Pulled changes made directly from GitHub And yes… My repo is now live on GitHub 🔥 🧠 Key Realizations 🔹 A branch is just a pointer to a commit — but it changes everything. 🔹 main should stay stable. Features belong in separate branches. 🔹 git pull = git fetch + git merge 🔹 origin is my remote repo. 🔹 upstream is the original repo (used in fork workflows). Switching branches literally feels like time travel ⏳ Your files change to match that branch’s history. 🌎 First GitHub Workflow Experience Local repo → Create branch → Commit → Push → View branches on GitHub → Pull changes This is how collaboration actually works in DevOps teams. 💡 Biggest Learning Git isn’t just version control. It’s: ✔ Controlled experimentation ✔ Safe collaboration ✔ Structured development ✔ Production protection Today I moved from “using Git” to “understanding Git.” Small steps. Strong foundations. 💪 Tomorrow — merging & real-world workflow. #90DaysOfDevOps #DevOpsKaJosh #TrainWithShubham #Git #GitHub #VersionControl #DevOpsJourney

Day 25 | #90DaysOfDevOps🚀 — Mastering Advanced Git Commands Today I focused on learning and practicing some powerful Git commands that help developers manage code safely and efficiently. Understanding these commands is essential for real-world collaboration and version control. 🔧 What I practiced today: ✅ Git Reset – Learned how to undo commits in different ways: --soft → keeps changes staged --mixed → keeps changes but unstaged --hard → removes commits and deletes changes ✅ Git Revert – Safely undo a commit by creating a new commit without rewriting history. This is the recommended approach for shared repositories. ✅ Handling Merge Conflicts – While reverting a commit, I encountered a conflict and learned how to manually resolve it and continue the revert process. 📚 Updated my Git command reference to include: Setup & Configuration Basic Git Workflow Branching Remote repositories Merging & Rebasing Stash & Cherry Pick Reset & Revert #DevOps #Git #VersionControl #LearningInPublic #90DaysOfDevOps #DevOpsKaJosh #TrainWithShubham

🔄 Mastering Git & GitHub — A Must-Have Skill in Tech Every serious software developer must understand one thing: Writing code is important. Managing code properly is even more important. I’ve been actively learning and practicing Git & GitHub to understand how real-world software teams collaborate and ship production-ready applications. From: Version control fundamentals Branching strategies Pull requests & code reviews Conflict resolution GitHub Actions & automation To understanding how companies maintain large-scale systems without breaking production. In today’s industry: Every company uses Git Every team relies on collaboration Every deployment depends on proper version tracking Learning Git is not just about commands — It’s about thinking like a professional developer. Excited to keep building, improving, and contributing 🚀 #Git #GitHub #VersionControl #SoftwareEngineering #FullStackDeveloper #MERN #LearningInPublic #TechJourney #DeveloperLife

Day 4 – Something Every Developer Should Know 🔧 Today I learned about something that almost every developer talks about. 🔹 Day 4: What is Git & Why It Matters? Earlier, I thought Git was just for uploading code. But it’s actually much more than that. Git is a version control system. In simple words, it helps you track changes in your code. Imagine working on a project and accidentally deleting something important. Without Git → panic. With Git → you can go back to the previous version easily. It also helps when multiple people work on the same project. Everyone can contribute without overwriting each other’s work. And then there’s GitHub — where we store and share our Git projects online. One thing I realized: Writing code is important. But managing and maintaining code properly is equally important. Still learning. Still improving. Day 5 tomorrow 🚀 #Day4 #Git #VersionControl #TechJourney #LearningInPublic #FresherGrowth

How Git Actually Works (Simple Explanation) Many developers use Git daily. But not everyone clearly understands what happens behind the scenes. Here’s the simple flow 👇 🖥️ 𝟭. 𝗪𝗼𝗿𝗸𝘀𝗽𝗮𝗰𝗲 This is where you write and edit your code. Files are modified here. When you run: git add You move changes to the next stage. 📦 𝟮. 𝗦𝘁𝗮𝗴𝗶𝗻𝗴 𝗔𝗿𝗲𝗮 This is like a preparation zone. You choose what changes will go into the next commit. When you run: git commit Changes move into your local repository. 💾 𝟯. 𝗟𝗼𝗰𝗮𝗹 𝗥𝗲𝗽𝗼𝘀𝗶𝘁𝗼𝗿𝘆 This is your local Git history. Commits are stored here on your system. To share changes: git push → sends code to remote. To get updates: git fetch → downloads changes git pull → fetch + merge together ☁️ 𝟰. 𝗥𝗲𝗺𝗼𝘁𝗲 𝗥𝗲𝗽𝗼𝘀𝗶𝘁𝗼𝗿𝘆 This is GitHub, GitLab, or Bitbucket. It stores code online for collaboration. 💡 Simple Way to Remember: Workspace → Stage → Commit → Push Git isn’t complicated. It’s just a structured way to track and share changes safely. Once you understand this flow, Git becomes much easier. 🔖 Hashtags (SEO-friendly) #Git #VersionControl #GitHub #SoftwareDevelopment #WebDevelopment #DeveloperTips #ProgrammingBasics

🚀 Version Control with Git – Push & Pull Workflow As part of my development practice, I worked on managing project files using Git and GitHub. Here’s a simple workflow I followed: 🔹 Push Files to Repository 1️⃣ Initialize Git in the project folder 2️⃣ Add files using git add . 3️⃣ Commit changes using git commit -m "message" 4️⃣ Push to GitHub using git push origin main This process uploads local project files to the remote repository. 🔹 Pull Files from Repository To get the latest updates from the remote repository: git pull origin main #Git #GitHub #WebDevelopment #CodingLife #VersionControl #DevOps #OpenSource #ProgrammingTips

What I Learned About Git & GitHub (Hands-On) Recently, I practiced Git & GitHub hands-on and learned how real version control works beyond basic theory. Here are some of the key Git commands and concepts I worked with 👇 🔹 Repository setup: git init, git status, git config 🔹 Tracking changes: git add, git commit, git diff, git diff --staged 🔹 Branching & navigation: git branch, git switch, git switch -c 🔹 Merging & conflict handling: git merge, resolving merge conflicts manually 🔹 History & safety concepts: git stash, git log, understanding staged vs unstaged changes 🔹 Remote operations: git push, git pull, handling README conflicts, git push --force 🔹 Advanced understanding: git rebase vs git merge, clean vs preserved history, file encoding issues, .gitattributes 💡 Key takeaway: Git makes much more sense when you actually face errors, fix them, and understand why they happen. Looking forward to applying this knowledge in real projects #Git #GitHub #VersionControl #LearningByDoing #DeveloperJourney #DataEngineering