🚀 Day 02/100 – Git Configuration, Amend & .gitignore Today I focused on key Git operations related to commit management and repository handling. 🔹 What I revised today: • Git configuration to set username and email for commits • Using git commit --amend to modify the latest commit (message, author, or changes) • Understanding the purpose of .gitignore to avoid tracking unwanted files 🔹 Hands-on I practiced: • git config user.name / user.email • git commit --amend -m "message" • git commit --amend --no-edit • Creating and using .gitignore file 💡 Key Takeaway: Proper configuration and controlling what gets committed helps in maintaining clean and meaningful version history. ⚡ Insight: Using .gitignore effectively prevents unnecessary files from being tracked and keeps the repository organized. Day 2 ✅ #DevOps #Git #100DaysOfDevOps #LearningInPublic

Still confused with Git commands? You’re not alone 👇 Most developers use Git daily… but only a few actually understand it properly. So I found this complete Git guide (PDF) that simplifies everything 👇 👉 Core Concepts: ✔️ Version Control & Collaboration ✔️ Branching & Merging ✔️ Tracking Changes 👉 Essential Commands: ✔️ git init, clone, add, commit ✔️ git push, pull, fetch ✔️ branch, merge, checkout 👉 Advanced Commands: ✔️ stash, cherry-pick, rebase ✔️ reset vs revert ✔️ bisect, reflog 👉 Pro Tips: ✔️ Clean commit history ✔️ Resolve merge conflicts ✔️ Use aliases & flags for efficiency 👉 Real-World Use Cases: ✔️ Team collaboration on projects ✔️ Handling hotfixes in production ✔️ Rolling back buggy releases ✔️ Feature development using branches 💡 Git is not just a tool — it’s a must-have skill for every developer. 📌 Save this post 🔁 Repost to help others 👨💻 Follow Abhishek Sharma for more such content #Git #GitHub #VersionControl #SoftwareEngineer #Developers #TechJobs #CodingInterview #LearnToCode #CareerGrowth

Three phase of git in local machine. 1. Untracked 2. Staged 3. Committed Let discuss about them below: Untracked: Every file in a directory after git init is below in this. Basically file are exits but the they are not a part of git version control. That means if any files are deleted from here we can restore them via git. If we want check git status via the command: git status; this files are under the untracked files and the file names are red colored. Staged: Basically a file in being a part of version control from here. If any file which is add in this phase will show the file name in green color and under the changes to be committed category. We can restore any file from here if they deleted from our local machine. Committed: This phase is the final phase of a local git repository. Here we can create a version of our work with a meaning full message. If we commit anything we can see them via git log command. Git status command won't give us any result it will say nothing to commit. [N. B: If any file(s) or directory is included at .gitignore can't tracked by git. It will automatically vanish for git] #devOps #git #learnNewThings

⚠️ Handling Merge Conflicts in My Git Workflow As I started working with branches and pull requests, I encountered merge conflicts — a common situation when multiple changes affect the same part of the code. Instead of seeing it as an issue, I began treating it as part of the development process. A merge conflict happens when Git is unable to automatically combine changes from different branches. Here’s how I handle it: 📌 1. Attempt to merge branches git merge feature-branch 📌 2. Identify conflicting files Git highlights the files with conflicts 📌 3. Open and resolve conflicts manually Review both changes Decide what to keep or combine 📌 4. Mark as resolved and stage changes git add . 📌 5. Commit the resolved version git commit -m "Resolved merge conflict" I started facing these situations while working on multiple updates simultaneously, where the same files were being modified in different branches. This approach helps me: ✔️ Understand code changes more clearly ✔️ Avoid accidental overwrites ✔️ Maintain consistency in the codebase ✔️ Improve problem-solving during development Handling merge conflicts effectively has improved my confidence in working with Git in real-world scenarios. #Git #MergeConflicts #VersionControl #DeveloperWorkflow #SoftwareDevelopment #TechSkills

Ever had your git push rejected with a confusing message like: “rejected (fetch first)” “branches have diverged” I recently ran into this — and finally understood what Git was trying to protect me from. Here’s the simple breakdown What’s actually happening? You and the remote repository (GitHub) both made changes. Git blocks your push to prevent overwriting someone else’s work. The fix (clean & safe way): git pull origin main --rebase git push origin main What --rebase really does: Instead of merging, it: Temporarily removes your commits Pulls the latest changes Re-applies your commits on top Result: clean, linear history (no messy merge commits) Common blockers & how to handle them Unstaged changes? You modified files but didn’t stage them yet. Fix: git add -A git commit -m "your message" Not ready to commit? Use stash: git stash git pull --rebase git stash pop Conflicts during rebase? # fix files git add . git rebase --continue Key takeaway If your push is rejected: Always sync first, then push git pull --rebase git push #Git #DevOps #Terraform #LearningInPublic #SoftwareEngineering

#Git & #GitHub Production Issue-Based Interview Questions (Advanced / Real Production Scenarios) 👇 A developer accidentally pushed sensitive data (like passwords) to a repository on GitHub — how do you remove it from history? A commit was pushed to the wrong branch — how do you fix it safely? A production deployment failed due to incorrect merge — how do you rollback changes? Multiple developers are facing merge conflicts frequently — how do you manage and reduce conflicts? A branch was accidentally deleted — how do you recover it? Someone force-pushed to the main branch — how do you restore the previous state? Repository size has become very large — how do you reduce repository size? A developer committed large binary files — how do you handle large files in Git? Changes are not reflecting after pulling latest code — what could be wrong? A developer cloned the repo but cannot push changes — how do you troubleshoot permission issues? Pull request checks are failing — how do you debug failed checks? Code review approvals are required but PR cannot be merged — what could be wrong? Branch protection rules are blocking deployment — how do you troubleshoot? A merge introduced bugs into production — how do you revert safely? Git history became messy due to multiple merges — how do you clean it? Developers are working on outdated branches — how do you synchronize branches? A hotfix needs to be applied urgently to production — how do you handle it using branching? A feature branch has many commits — how do you squash commits before merging? A workflow in GitHub Actions is failing — how do you debug it? CI/CD pipeline is not triggering on push — what could be the issue? GitHub Actions cannot access secrets — how do you troubleshoot? Workflow runs successfully but deployment fails — how do you debug it? Pipeline works locally but fails in GitHub Actions — what could be the reason? GitHub runner is not picking jobs — how do you troubleshoot? Self-hosted runner is offline — how do you fix it? A user cannot access the repository — how do you troubleshoot access control? Unauthorized changes were pushed to repository — how do you investigate? API token used in GitHub expired — how do you rotate tokens securely? Repository secrets were exposed — what steps will you take immediately? How do you audit repository changes to identify who modified critical files?

💻 Getting Started with Git – A Developer’s First Step into Version Control 🚀 If you're new to development, one of the first tools you must master is Git. Recently, I explored the basic Git commands and how they help manage code efficiently. Here’s a quick breakdown 👇 🔹 Initialize Repository git init – Start a new Git project 🔹 Clone Repository git clone <repo_url> – Copy an existing project 🔹 Track Changes git add . – Add files to staging git commit -m "message" – Save changes 🔹 Check Status & History git status – See current changes git log – View commit history 🔹 Work with Branches git branch – Create/manage branches git switch – Move between branches 🔹 Collaboration git pull – Get latest updates git push – Upload your changes 📌 Git is not just a tool—it’s a core skill for every developer. I’m currently strengthening my skills in Java Full Stack Development and consistently improving my development workflow using Git. #Git #VersionControl #SoftwareDevelopment #JavaDeveloper #FullStackDeveloper #LearningJourney

Git conventional commits. feat, fix, docs, refactor, chore Honestly, these feel pointless when you're working alone. Nobody's going to review your commits. But I've been in enough team codebases to know what happens when nobody enforces this: "fix stuff" "changes" "wip" "asdfghjk" (we've all done it) Six months later, you're doing git log trying to find where a bug was introduced, and every commit is useless. Conventional commits solve three real things in teams: → Code reviews: the reviewer knows the intent before reading a single line of diff → Changelogs: feat and fix commits can generate release notes automatically → Debugging: git bisect becomes actually useful when messages are meaningful The format is simple: type(scope): description feat(auth): add Google OAuth login fix(api): handle null user on signup chore: upgrade Spring Boot 3.2 Building the habit now while it's just me, so it's second nature when it's not. Do you enforce conventional commits on your team — or is it a free-for-all?

I’ve seen coding agents get really good at finding information from a git repo. Once the repo is cloned locally, it’s looks natural for LLMs to use bash and file tools to find the necessary data. Think about it, it’s version controlled. Git provides a great way for collaboration. Looks ideal for humans and agents to work together. All your conversations, notes etc can be maintained by just having a conversation with your agent. This vault can be visualised using a good markdown tool. Eg Obsidian . While RAG can help provide information, git based local file can help agents find the missing data from the chunks and get full understanding of the document. Agents can extract exact chunk it needs. Eg line 20 to 100 from conversation[dot]md #git #rag #AIAgents #cliAgents #openzosma

Git Workflow (At a Glance) 🚀 Most developers use Git daily, but many still struggle with the difference between the Staging Index and Local Repo, or when to Merge vs. Rebase. If you’re guessing your way through your terminal, you’re eventually going to break a production branch. Stop memorizing commands and start understanding the architecture. 🛠 The Three Areas You Must Know: Working Directory: Where you actually write the code (Untracked/Modified). Staging Index: The "loading dock" where you prep your changes for a commit. Local Repo (.git/): Your personal history of snapshots. Remote Repo: Where the team collaborates (GitHub/GitLab). 💡 Key Technical Takeaways: Merge vs. Rebase: Merging preserves the full history with a "merge commit." Rebase rewrites history for a clean, linear timeline. Choose wisely based on your team's workflow. File Lifecycle: A file isn't just "saved"—it moves from Untracked → Staged → Committed → Modified. The "Safety Net" Commands: Learn git stash for temporary work and git revert to fix mistakes without destroying the commit history. The Reality Check: You aren’t a Senior Engineer until you can manage a complex branching model without losing data. Save this infographic for your next "merge conflict" headache. #DevOps #Git #VersionControl #CloudEngineering #SoftwareDevelopment #CodingTips #TechCommunity