Ruturaj Kumbhar’s Post

As I progress into learning more about Devops, here's all the things I've picked up while studying GIT this week! 🚀 Week Progress: Mastering Git & Real-World Version Control Over the past week, I’ve been focused on building a solid foundation in Git — not just using commands, but understanding how it works in real development environments. Here’s what I’ve worked through: 🔹 Core Git Workflow • Working directory → staging → commits → remote • Understanding Git as a snapshot-based system (not just file changes) 🔹 Branching & Collaboration • Creating feature branches and merging safely into main • Handling merge conflicts manually • Using GitHub workflows: fork → clone → branch → commit → push → pull request 🔹 History & Code Management • Exploring commit history with git log --oneline --graph • Using git show to inspect changes • Cleaning commit history with interactive rebase & squash 🔹 Real-World Development Practices • Using git stash to manage context switching • Understanding when to use merge vs rebase • Maintaining clean, readable commit history 🔹 Debugging & Recovery • Safe undoing with git revert vs destructive changes with git reset • Understanding detached HEAD and how to avoid losing work 💡 Key takeaway: Git isn’t just about files — it’s about managing history, collaboration, and maintaining clean, reliable codebases. This week has taken me from basic usage to confidently handling real-world workflows used in development teams. Next step: diving deeper into DevOps practices and automation 🚀 #Git #DevOps #SoftwareDevelopment #LearningInPublic #OpenToWork #CoderCo

🚀 DevOps Learning Journey -🔧 Day 10 – Git Basics (Version Control System) Today I continued learning Git, a powerful version control system used to track changes and collaborate on code efficiently. 🔹 What is Git? Git helps developers manage code, maintain version history, and collaborate with teams without conflicts. 🔹 Why Git is Important? ✔ Tracks history of code changes ✔ Enables team collaboration ✔ Supports version control and rollback ✔ Integrates with CI/CD pipelines 🔹 Basic Git Commands I Practiced • git init – Initialize a new repository • git add . – Add files to staging area • git commit -m "message" – Save changes • git status – Check current status • git log – View commit history 🔹 Additional Commands • git show – Display details of a specific commit • git show --stat – Show commit details with file changes summary • git log --oneline – View commit history in a short format • git log --pretty=oneline – Display each commit in a single line 🔹 Example Workflow git init git add . git commit -m "Initial commit" git log --oneline 📌 Hands-on: Created a local repository, tracked changes, and explored commit history using different Git log commands. Understanding Git is a key step towards mastering version control and CI/CD pipelines. #DevOps #Git #VersionControl #LearningJourney #TechSkills #ContinuousLearning

🚀 DevOps Learning Journey – Git & GitHub Deep Dive Yesterday, I dedicated my time to revising Git and GitHub in depth as part of my ongoing DevOps learning challenge. This revision helped me strengthen my understanding of how modern development teams collaborate efficiently on a single project using version control systems. 🔍 Key Concepts I Focused On: 🔹 Version Control Basics Understanding how Git tracks changes, maintains history, and allows developers to work without affecting the main codebase. 🔹 Branching Strategy Learned how developers create separate branches (git checkout -b feature-name) to work on features independently and safely. 🔹 Collaboration Workflow Explored how multiple developers contribute to the same repository using: Clone → git clone Branch → git checkout -b Commit → git commit Push → git push Pull Requests & Code Review 🔹 GitHub Repository Management Understood how organizations manage access, maintain repositories, and ensure smooth collaboration among team members. 🔹 Merge & Conflict Handling Got clarity on merging branches and resolving merge conflicts — one of the most important real-world skills. 💡 Key Takeaway Git & GitHub are not just tools, they are the backbone of collaboration in DevOps and software development. A strong foundation here makes working in teams much more efficient and structured. #DevOps #Git #GitHub #LearningJourney #VersionControl #CloudComputing #ContinuousLearning #TechCareer

🚀 DevOps Learning Journey - 🌿 Day 11 – Git Branching & Merging Today I learned one of the most important concepts in Git — Branching and Merging. Branching allows developers to work on new features or fixes without affecting the main codebase. 🔹 What is a Branch? A branch is a separate line of development. By default, Git has a main/master branch, and we can create new branches for features. 🔹 Why Branching is Important? ✔ Work on features independently ✔ Avoid breaking main code ✔ Enable parallel development ✔ Easy collaboration in teams 🔹 Git Commands I Practiced • git branch – List all branches • git branch feature – Create a new branch • git checkout feature – Switch to a branch • git checkout -b feature – Create & switch to branch • git merge feature – Merge branch into current branch 🔹 Example Workflow git branch feature git checkout feature # make changes git add . git commit -m "Added new feature" git checkout main git merge feature 🔹 Merge Concept Merging combines changes from one branch into another. Sometimes conflicts may occur, which need to be resolved manually. 📌 Hands-on: Created a feature branch, made changes, and merged it back to the main branch. Understanding branching is essential for working in real-world DevOps and development teams. #DevOps #Git #VersionControl #Branching #LearningJourney #ContinuousLearning

🚀 Git Learning Series – Part 2: Branching Strategy Explained After understanding Git basics and SSH setup, the next important concept is: 🌿 Git Branching Strategy Many beginners ask: 👉 Why do we need branches? Because in real projects, you should never work directly on "main". --- 🔑 What is a Branch? A branch is like a separate workspace where you can: ✔ Develop features ✔ Fix bugs ✔ Experiment safely Without affecting the main code. --- 🔥 Common Branching Workflows 1️⃣ Feature Branch Workflow (Most Used) - Create branch from main - Work on your feature - Push → Raise PR → Merge Example: git checkout -b feature/login-api --- 2️⃣ GitHub Flow (Simple & Powerful) - Only main + feature branches - Direct PR → review → merge ✔ Best for startups & small teams --- 3️⃣ Git Flow (Structured) - main → production - develop → active development - feature / release / hotfix branches ✔ Used in large enterprise projects --- 4️⃣ GitLab Flow - Includes environments like: - preprod - production ✔ Useful for DevOps pipelines --- ⚠️ Beginner Mistake 🚫 Working directly on main ✅ Always create a feature branch --- 📘 Follow for more hands-on Git & DevSecOps learning DevSecOps Learning Hub #Git #GitHub #DevOps #DevSecOps #CI_CD #Automation #CloudSecurity #SoftwareEngineering #LearningInPublic #TechLearning #Developers #VersionControl #OpenSource #CareerGrowth #Engineering

🚀 #100DaysOfDevOps – Day 6 Today I practiced Git basics focusing on tracking, committing, and analyzing changes, simulating real development workflows. 🔹 Tracking & Committing Files ✔ Scenario: Tracking code/config changes before deployment ✔ Scenario: Maintaining version history for rollback Commands: git add file git commit -m "message" 🔹 Working with Multiple Files ✔ Scenario: Committing multiple configuration changes in one release Commands: git add . git commit -m "message" 🔹 Git Logs (History Tracking) ✔ Scenario: Debugging issues by checking recent changes ✔ Scenario: Understanding who changed what in the project Commands: git log git log --oneline git log -2 🔹 Git Show (Deep Analysis) ✔ Scenario: Inspecting exact code changes that caused an issue ✔ Scenario: Reviewing commit details during debugging Commands: git show <commit-id> git show <commit-id> --name-only 🔹 Git Config ✔ Setting up identity for commits Commands: git config user.name "username" git config user.email "email" 💡 Git plays a key role in code versioning, collaboration, and production debugging in DevOps workflows. Every commit tells a story — learning to read and manage it effectively. 💪 #Git #DevOps #CloudEngineering #VersionControl #100DaysChallenge #ContinuousLearning

Week 8 of my DevOps journey — and my perspective on coding completely changed. Before learning Git, I used to think coding was mostly an individual activity you write code on your machine, save it, and move on. But this week showed me that modern software development is really about collaboration. As I dove deeper into Git, I started to understand how teams actually build software together. Every change is tracked, every update is intentional, and nothing gets lost. Git isn’t just saving code it’s recording the entire story of a project. One concept that really stood out to me was branching and merging. The idea that you can create a separate space to work on something without affecting the main codebase and then safely merge it back in is powerful. It’s what allows teams of hundreds (or even thousands) of engineers to work on the same project at the same time. I also explored merge vs rebase, which completely changed how I think about project history. Merge preserves the full story, while rebase keeps things clean and linear. Knowing when to use each feels like an important step toward working in real engineering teams. Another big shift for me was learning about real-world Git workflows things like pull requests, forks, and trunk-based development. Pull requests especially stood out. The idea of sharing your code, having it reviewed, and improving it before merging shows how much collaboration and quality matter in tech. I also started focusing on commit hygiene writing clear commit messages, keeping changes small, and being mindful about security (like not exposing sensitive data). This week made me realize something important: Git isn’t just a tool. It’s the foundation of how modern engineering teams collaborate, review code, and safely deliver software at scale. And for the first time, I feel like I’m starting to think like a developer not just someone writing code. Slowly but surely, things are starting to make sense. #DevOps #Git #LearningInPublic #TechJourney #VersionControl #OpenToWork #JuniorEngineer #Coderco

🚀 #100DaysOfDevOps – Day 9 Today I practiced Git branching strategies, merge vs rebase, and stash operations, focusing on real-time development scenarios. 🔹 Git Branching (Parallel Development) ✔ Scenario: Creating feature branches for new tasks without impacting main code ✔ Scenario: Working on bug fixes while another feature is in progress Commands: git branch git checkout -b feature-branch 🔹 Git Merge (Combining Code) ✔ Scenario: Merging tested feature branch into main before deployment ✔ Scenario: Integrating multiple developer changes Command: git merge branch-name 🔹 Git Rebase (Clean Commit History) ✔ Scenario: Updating feature branch with latest main branch changes ✔ Scenario: Maintaining a clean and linear commit history before PR Command: git rebase main 🔹 Merge vs Rebase (Real Use Case) ✔ Merge → preserves history (used in team collaboration) ✔ Rebase → cleaner history (used before pushing changes) 🔹 Git Stash (Context Switching) ✔ Scenario: Urgent production issue comes → stash current work and switch branch ✔ Scenario: Saving incomplete work without committing Commands: git stash git stash apply git stash list git stash pop 💡 These commands are essential for real-time collaboration, handling multiple tasks, and managing clean code history in DevOps environments. Learning how teams actually work with Git in production. 💪 #Git #DevOps #VersionControl #Branching #Rebase #Stash #100DaysChallenge #ContinuousLearning

🚀 DevOps Journey – Day 15 / 100 Diving deeper into Git advanced commands & concepts 🔥 🔹 Tracking & Status: • git add * → Track normal files • git add . → Track all (including hidden files) • git status → Check current changes 🔹 Removing Files: • git rm --cached file → Remove file from staging but keep in system 🔹 Git Configuration: • git config --global user.name "username" • git config --global user.email "mailid" 🔹 Logs & History: • git log --oneline → Short history • git log --follow --all file → Track file history • git log -p file → Show detailed changes 🔹 Modifying Commits: • git commit --amend -m "new message" • git commit --amend --author="user <email>" 🔹 Important Concepts: 📌 .gitignore → Used to ignore unwanted files (logs, temp, builds) 🔹 Reset & Recovery: • git reset --hard HEAD~1 → Delete last commit (danger ⚠️) • git reset --soft HEAD~1 → Undo commit but keep changes • git reflog → Recover lost commits 🔹 Advanced: • git cherry-pick <commit_id> → Apply specific commit 💡 Pro Tip: Always use --soft reset when learning. --hard can permanently delete work if not careful! Consistency is the key 🔑 Keep learning Git → Become DevOps Ready 💪 #DevOps #Git #Linux #VersionControl #100DaysOfDevOps #LearningJourney #Automation #Cloud #selflearning #flm

Day 21 of learning Tech. I continued learning about Git and why it is such an important tool for developers and DevOps engineers. Before Git, version control was often done manually, which made it easy to lose changes or create confusion when multiple people worked on the same project. Git helps solve this by creating a structured history of changes, enabling safe experimentation with branches, and making collaboration much easier. One of the first commands I learnt is git init, which creates a new repository and adds a hidden .git folder that stores the project’s version history. I also learned about git clone, which allows you to download a project from GitHub to your local computer. Another important concept is the staging area, where files are prepared before being committed. Commands like git add and git add . move changes to the staging area, while git commit creates a snapshot of the project at a specific point in time, including the reasons for the changes and who made them. I also explored branching. Branches allow developers to work on new features without affecting the main project. Using commands like git branch and git switch, we can easily create and move between branches. To track project changes, we can use commands like git status, git diff, and git log. These commands help us see file changes, staged files, and the full history of commits. Finally, I learned how to collaborate with others using git push to upload changes to GitHub and git pull to download updates from the remote repository. I also saw the importance of the .gitignore file, which tells Git which files should not be tracked. Step by step, I'm building a deeper understanding of Git and how it helps teams manage code and collaborate effectively. TS Academy #Devops #Cloudcomputing #git #Buildinpublic #learnwithTs