Git Debugging: Broken Rebase State Resolved

Day 11 of DevOps I thought I knew Git. Turns out I only knew GitHub. Git is a distributed version control system : it tracks every change you make to your code, locally on your machine. GitHub is just where you store it online. They are not the same thing. Today I actually used Git commands for the first time. Here's how it went: git init : initialized my first local repository git add : staged my changes git commit -m : saved my first snapshot But first commit failed. Git threw an identity error : it didn't know who I was. Turns out Git requires you to set your identity before committing anything. git config --global : fixed it permanently Then things got interesting: git diff : showed me exactly what changed between versions git log : showed my entire commit history with IDs git reset --hard : rolled back to a previous version instantly That last one hit different. One command and your code goes back in time. Git doesn't just save your work. It saves every version of it. Moral of the day: GitHub is the house. Git is the foundation it's built on. #DevOps #Git #LearningInPublic

🚀Day 34/90 Days DevOps Challenge - Introduction to Git & Basic Commands Today I completed Shell Scripting and started a new tool: Git & GitHub. This marks a shift from scripting to version control, which is a core part of DevOps. Git is a distributed version control system used to track and manage changes in source code efficiently. 🔹 What Git Helps With It tracks: • Who made the changes (author) • What changes were made • When the changes were made It solves major problems like collaboration, tracking code history, and maintaining backups. 🔹 History of Git Before Git, developers faced issues in collaboration and version tracking. Tools like BitKeeper were used but had limitations. Git was introduced by Linus Torvalds in 2005 as a free and open-source solution. 🔹 Git Workflow (Very Important Concept) Working Directory → Staging Area → Local Repository → Remote Repository Understanding this flow is critical. If you skip this, Git will always confuse you. 🔹 Core Git Operations • Adding → Move files to staging area • Committing → Save changes in local repo • Pushing → Upload code to remote repo • Pulling → Download latest changes 🔹 Basic Commands I Practiced • git init → Initialize a repository • git config user.name / user.email → Set identity • git add <file> → Add file to staging • git add . → Add all files • git status → Check file status • git commit -m "message" → Save changes • git log → View commit history • git remote add origin <url> → Connect to GitHub • git remote -v → Verify remote connection • git push origin master → Push code to GitHub 💡Key Learning Git is not about memorizing commands. It’s about understanding the flow of how code moves from your system to a shared repository. 📌 Tomorrow’s Topic: pulling, fetch & cloning in Git #90DaysOfDevOps #DevOps #CICD #Docker #Kubernetes #AWS #terraform #ansible #prometheus #grafana #CloudComputing #InfrastructureAsCode #LearningInPublic #FreshGraduate #CloudEngineer #Linux #Git #GitHub #VersionControl

Day 2 of actually learning Git properly. My CS degree gave me a lot—algorithms, data structures, the whole nine yards. But version control? We touched it once and called it a day. So here I am, playing catch-up. Learned about git config—turns out Git needs to know who you are before it lets you do anything. Simple, but somehow I never stopped to think about why my commits were always showing up with the wrong name. Also finally understand the difference between tracked and untracked files. Sounds basic, I know. But I used to just git add . everything like a caveman and hope for the best. On top of that, I started reading about the DevOps lifecycle. Interesting stuff, but honestly? Theory is great, but actually managing code with a team? That's a different beast entirely. Small steps. But at least now when I break something, I'll know who's to blame (me, it's always me). What's a basic Git thing that took you embarrassingly long to figure out? Asking so I don't feel alone here. #DevOps #Git #ComputerScience #LearningInPublic #Day2

🚀 Git & GitHub: More Than Just Saving Code I never paid much attention to Git before, during the Information Technology Institute (ITI) program, we started using Git and GitHub practically, which completely changed my perspective. Special thanks to Eng. Jacklin kamal for encouraging us to practice step by step and showing the importance of version control in real projects.❤️ To build a stronger foundation, I also followed the Git & GitHub playlist by Eng. Osama Elzero It connected concepts to real practice and explained the full workflow clearly, a big thank you to for creating such an accessible and effective learning resource. Examples of what I learned: 🔹Using git branch and git checkout to develop features safely. 🔹Using git merge and git stash to handle multiple changes and conflicts. 🔹Following the full Git workflow from repository initialization to collaboration on GitHub. 🔹Since then, I’ve started regularly uploading projects to GitHub and plan to keep improving my skills. Git Commands I Use Regularly: 🔹git init 🔹git add . 🔹git commit -m "first commit" 🔹git push 🔹git pull 🔹git clone <repository-url> 🔹git branch <branch-name> 🔹git checkout <branch-name> 🔹git merge <branch-name> 🔹git stash Key Takeaways: 🔹Track and organize changes efficiently 🔹Work confidently with local and remote repositories 🔹Use branching to develop features safely 🔹Manage project history with stash, reset, and restore 🔹Understand real team collaboration on GitHub Check my GitHub profile: 🔗 https://lnkd.in/d9NrhJJX #Git #GitHub #ITI #Programming #DataAnalysis #AI #PowerBI #LearningJourney

🚀 DevOps Journey – Day 16 / 100 Today I explored Git Merge vs Rebase, Stash & GitHub basics 🔥 🔹 🔁 Merge vs Rebase (Interview Perspective) ✅ Git Merge • Combines branches with a merge commit • Preserves full history • Best for team collaboration ✅ Git Rebase • Rewrites commit history linearly • Cleaner & readable history • Best for local development 💡 Difference in One Line: 👉 Merge = Safe & history preserved 👉 Rebase = Clean & linear history ⸻ 🔹 📦 Git Stash (Temporary Save) • git stash → Save uncommitted changes • git stash list → View stash list • git stash apply → Reapply changes • git stash clear → Delete all stash ⸻ 🔹 🌐 GitHub Basics • Create account on GitHub • Create a repository • Default branch = main 🔹 🔗 Connect Local to GitHub • git remote add origin <URL> • git remote -v → Verify remote ⸻ 🔹 🚀 Push Code • git push origin branch • git push origin --all 💡 Note: Using HTTPS → Requires username + personal access token (PAT) instead of password ⸻ 🔥 Pro Tip: Use Merge in real projects, Rebase for clean commits before pushing! Consistency + Practice = DevOps Success 💪 #DevOps #Git #GitHub #Linux #VersionControl #100DaysOfDevOps #LearningJourney #Cloud #Automation #selflearning #devops #software

🚀 Day 5: Connecting the Dots with Git & GitHub – My First Deployment! 🌐 Today marks a major milestone in my learning journey. I moved beyond writing code locally and stepped into the real-world workflow of developers—collaborating, versioning, and deploying projects. Here’s what I explored today: 🔹 Git vs GitHub – Understanding the Difference I clarified a key concept: Git is a version control system that tracks changes in my code locally. GitHub is a cloud platform where I host repositories and collaborate with others. 🔹 Mastering Essential Git Commands ⌨️ Learned the core commands to push my project live: git init – Initialize repository git add . – Stage changes git commit -m "message" – Save a snapshot git remote add origin [URL] – Connect to remote repo git push -u origin main – Push code to GitHub 🔹 Creating My First Repository 📁 Structured my project and added a README.md file to document it. Realized that good documentation is as important as writing clean code. 🔹 Deployment – Going Live! 🌍 The highlight of the day: deploying my project using GitHub Pages. Seeing my work live on a public URL was incredibly rewarding. 💡 Big Takeaway: As an aspiring Full Stack Developer, understanding Git workflows is essential. It ensures my code is versioned, secure, and collaboration-ready as my projects grow. Looking forward to building and deploying more projects! 💻🔥 #JavaFullStack #Git #GitHub #VersionControl #WebDevelopment #Deployment #LearningInPublic #OpenSource #DevOps #10000Coders

💡 Understanding Git, GitHub, and GitLab: A Must for Every Developer As a software engineer, one of the most important tools in your daily workflow is Git. Yet many developers still confuse the difference between Git, GitHub, and GitLab. 🔹 Git is a distributed version control system that helps you track changes in your code, manage versions, and collaborate efficiently. 🔹 GitHub is a cloud-based platform where you can host your Git repositories, collaborate with other developers, and showcase your work. 🔹 GitLab is another powerful platform similar to GitHub, but with strong built-in DevOps features like CI/CD pipelines and self-hosting capabilities. 🚀 Why Git is essential: 👉 Keeps a complete history of your code 👉 Enables safe collaboration across teams 👉 Helps manage features using branches 👉 Makes debugging and rollback easier 👉 Supports modern development workflows In today’s development world, Git is not just a tool, it’s a core skill. Whether you’re working solo or in a team, mastering Git will significantly improve your productivity and code quality. If you're not using Git regularly yet, now is the time to start! #Git #GitHub #GitLab #VersionControl #SoftwareDevelopment #WebDevelopment #Laravel #ReactJS #DevOps #Programming #Developers #TechCareer #CodeBetter

🚀 Learning Git & GitHub – My Journey Begins! Over the past days, I’ve taken my first steps into the world of version control using Git and GitHub, and it has been an exciting learning experience. When I first started exploring the tech world, I used to wonder: 👉 How do companies share source code with developers and testers? 👉 How do teammates collaborate on the same project? 👉 How do they review and fix each other’s code? As I began learning Git and GitHub, I finally understood how the tech world manages and shares code efficiently. I also discovered that, apart from GitHub, there are other platforms like GitLab and Azure DevOps that support similar workflows. 🔹 Here’s what I learned: • What version control is and why it’s important • Basic Git commands: init, clone, add, commit, push, pull • Creating and managing repositories on GitHub • Understanding branches and how to use them • The difference between git merge and git rebase • Fixing small mistakes and handling basic conflicts 🔹 Key takeaway: Git is not just a tool—it’s a must-have skill for every developer. It enables efficient collaboration, tracks changes, and helps manage projects professionally. 💡 What’s next? • Work on real-world projects using GitHub • Learn advanced concepts like pull requests and team collaboration • Start contributing to open source If you have any tips or resources for beginners, I’d love to learn from you! 🙌 #Git #GitHub #LearningJourney #BeginnerDeveloper #OpenToLearn #SoftwareDevelopment

🚀 Understanding Git File Lifecycle (with Real Practice) While working on Git, I explored how files move through different stages — and this changed how I use Git daily 👇 🔄 Git File Lifecycle Every file in Git goes through these states: 1️⃣ Untracked 👉 New files (Git doesn’t know about them yet) 2️⃣ Staged 👉 Files added using git add (ready for commit) 3️⃣ Committed 👉 Files stored in repository (git commit) 4️⃣ Modified 👉 Already tracked file, but changed in working directory 📊 Real-Time Example from My Practice git status -s M disk-usage.sh ?? tests.txt 👉 M = Modified 👉 ?? = Untracked 🔧 Commands I Used ✔️ git add <file> → Move to staging ✔️ git add -A → Add all changes ✔️ git commit -m "message" → Save changes ✔️ git push → Upload to remote repo 📦 Full Workflow I Followed git add calculator.py disk-usage.sh git add disk-usage.txt git commit -m "Local Changes" git push 🔍 Helpful Commands ✔️ git status → Check state ✔️ git status -s → Short view ✔️ git log → Commit history ✔️ git diff → See changes ⚠️ Important Learning 👉 git commit -a works only for tracked files 👉 New files must be added using git add 💡 Key Insight Git is not just commands — it’s a lifecycle system that tracks every change step-by-step. 🔥 Small practice → Strong Git fundamentals How do you track your file changes in Git? 🤔 #Git #DevOps #Learning #VersionControl #AWS #CICD #TechJourney #GitBasics

🚀 Basic Git Commands Every Beginner Should Know If you’re learning software development, Git is one tool you can’t ignore. It helps you track code changes, collaborate with others, and manage your projects efficiently. Here are some basic Git commands every beginner should know: 👇 1️⃣ git init Creates a new Git repository in your project folder. 👉 Use it when starting a new project 2️⃣ git status Shows the current state of your files. 👉 It tells you: Which files changed Which files are staged Which files are not tracked 3️⃣ git add . Stages all changed files before committing. 👉 Think of it as preparing your work to be saved 4️⃣ git commit -m "message" Saves your staged changes with a message. 👉 A commit is like a checkpoint in your project 5️⃣ git clone <repository-url> Copies an existing repository from GitHub to your computer. 👉 Use it when working on an existing project 6️⃣ git pull origin main Downloads the latest changes from the remote repository. 👉 Keeps your local project updated 7️⃣ git push origin main Uploads your local commits to GitHub. 👉 Shares your changes with others 8️⃣ git branch Shows all branches in your repository. 👉 Branches help you work on features separately 9️⃣ git checkout -b feature-name Creates and switches to a new branch. 👉 Perfect for building new features safely 🔟 git merge branch-name Combines changes from one branch into another. 👉 Commonly used to merge a feature branch into main 💡 Simple Reminder A beginner-friendly Git workflow usually looks like this: git init → git add . → git commit → git push ✅ Pro Tip Don’t try to memorize everything at once. Start with these core commands, practice them often, and Git will become second nature. Which Git command was the hardest for you to understand at first? 👇 #Git #GitHub #VersionControl #Programming #SoftwareDevelopment #Coding #DevOps #TechForBeginners #SoftwareEngineering #WebDevelopment #DeveloperTips #DeveloperJourney