Mastering Git Fundamentals with TS Academy

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

🚀 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... Continuing my learning journey and diving deeper into Git and GitHub concepts. Today I focused on advanced Git topics and understood how version control works in real-world collaboration. 📌 Topics I covered today: 👉 Git branching concepts 👉 Difference between "merge and rebase" 👉 Stash commands (saving temporary changes) 👉 Introduction to GitHub and how it works 👉 Cloning, pulling, and pushing code 👉 Generating SSH key and connecting to GitHub 👉 Git tags and their usage 👉 Forking repositories and its purpose Learning these concepts helped me understand how developers collaborate, manage code versions, and work efficiently in teams. Practicing these in real scenarios is helping me gain more confidence in Git and GitHub workflows. Step by step, moving closer to my goal of becoming a DevOps Engineer. 🚀 #DevOps #Git #GitHub #VersionControl #DevOpsJourney #LearningInPublic #ContinuousLearning

🚀 Day 58 of my Learning Journey – Git Revert 📘 Discovered how to safely undo changes in Git without rewriting history. I explored a powerful Git feature that helps fix mistakes while keeping the project history clean and transparent. 💻 📘 What is Git Revert? Git Revert is used to undo a specific commit by creating a new commit that reverses the changes from the previous one. Instead of deleting history, it adds a new commit that cancels the old changes. This is very important in collaborative projects because it keeps the commit history intact while safely correcting mistakes. ⚙️ Key Commands & Concepts 🔹 git revert <commit-id> Creates a new commit that reverses the changes made by the specified commit. 🔹 Safe history management Unlike git reset, it does not rewrite Git history, making it safe for shared repositories. 🔹 Commit-based rollback Allows developers to undo a single problematic commit without affecting others. 🔹 Automatic commit message Git automatically generates a message indicating which commit was reverted. 🔹 Conflict handling If conflicts occur during revert, they must be resolved manually before completing the revert. 🎯 Key Takeaway Learning Git Revert helped me understand how to safely undo mistakes while maintaining a clean and collaborative Git history. ☁️ Real-World Industry Usage 🔹 Production code fixes – Teams revert problematic commits that break production systems. 🔹 CI/CD pipelines – If a deployment introduces bugs, the faulty commit can be reverted quickly. 🔹 Cloud infrastructure code – Infrastructure-as-Code repositories use revert to roll back incorrect configurations. 🔹 Team collaboration – Large teams rely on revert to maintain transparency and avoid rewriting shared history. #Git #GitHub #DevOps #LearningInPublic #TechJourney #CloudComputing #CareerGrowth

🚀 Day 57 of my Learning Journey – Git Reset 📘 I explored the powerful concept of Git Reset, a command that helps developers manage and correct their commit history in Git. Understanding how to safely modify commits is an important step in becoming confident with version control systems used in modern development and DevOps workflows. 💻 📘 What is Git Reset? Git Reset is a command used to move the current branch to a specific commit. It allows developers to undo commits, unstage files, or reset the working directory to a previous state. This is especially useful when mistakes happen during commits or when we want to reorganize our commit history. ⚙️ Key Commands & Features 🔹 git reset --soft HEAD~1 Moves the branch pointer back by one commit but keeps all changes staged. 🔹 git reset --mixed HEAD~1 Resets the commit and unstages the changes, but keeps them in the working directory. 🔹 git reset --hard HEAD~1 Completely removes the last commit and deletes all related changes. Use carefully! 🔹 Reset to Specific Commit git reset <commit-id> allows moving the branch to a chosen commit in history. 🔹Unstaging Files git reset <file> removes a file from staging without deleting its changes. 🎯 Key Takeaway Learning Git Reset helped me understand how developers can safely correct mistakes and manage commit history more effectively in real development workflows. ☁️ Real-World Usage in Industry 🔹 Code Correction in Development Developers use reset to undo incorrect commits before pushing code. 🔹 CI/CD Pipeline Preparation Teams clean commit history before pushing code to automated pipelines. 🔹 Production Deployment Safety Engineers fix commit mistakes locally before changes reach production servers. 🔹 Collaborative Development Helps maintain clean and organized commit history in team projects. #Git #GitHub #DevOpsLearning #CloudComputing #LearningInPublic #TechJourney #CareerGrowth

🚀 DevOps Multi-Cloud Learning Journey – Day 14 Today’s session was focused on advanced Git commands, which are essential for efficient version control and managing code history. Key learnings: ⚙️ git config – Configure username and email ✏️ git commit --amend – Modify last commit 🚫 .gitignore – Ignore unnecessary files 🔄 git reset (soft & hard) – Undo changes in different ways 🍒 git cherry-pick – Apply specific commits 📜 git reflog – Track all Git activities 🔍 git log -p – View detailed commit changes These concepts help in better control, debugging, and managing project history in real-time development. Frontlines EduTech (FLM) #DevOps #Git #VersionControl #AWS #CloudComputing #LearningJourney #TechSkills #ContinuousLearning #FrontlinesEduaTech #FLM

🚀 Day 22 of My DevOps Journey — Mastering Git Fundamentals Today I focused on strengthening my understanding of Git workflows, which are at the heart of modern software development and DevOps practices. Here’s what I worked on today 👇 🔹 Installed and configured Git Set up Git identity and verified the configuration to ensure commits are properly tracked. 🔹 Created a Git project Initialized a new repository devops-git-practice and explored the hidden .git directory to understand how Git stores project history and metadata. 🔹 Built a Git commands reference Created a git-commands.md file documenting commonly used Git commands with explanations and examples. 🔹 Practiced staging and committing Learned the difference between git add and git commit, staged files, and created meaningful commits to track changes effectively. 🔹 Built commit history Repeated the edit → stage → commit workflow multiple times to understand how Git maintains a clean and traceable history. 🔹 Documented Git workflow concepts Added notes explaining: Working Directory vs Staging Area vs Repository Purpose of the staging area What git log shows Importance of the .git folder This exercise helped me clearly understand the Git workflow used in real DevOps environments. 📂 GitHub Repository: https://lnkd.in/gQNbz24C #DevOpsJourney #Git #VersionControl #LearningInPublic #DevOps #OpenToWork #ContinuousLearning #90DaysOfDevops #TrainWithShubham

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

🚀 Week 10 of My Learn-in-Public Journey – Learning Progress & Key Takeaways 📘📈 This week, I wrapped up another consistent week of learning and spent time strengthening my understanding of Git and GitHub fundamentals. Every small concept learned adds one more building block to my Cloud & DevOps journey. 🔁 📘 Weekly Overview During Week 10, I focused on learning and practicing Git and GitHub basics through hands-on exploration. Understanding version control is extremely important because Git is the backbone of modern software development, DevOps workflows, and cloud-based collaboration. This week was all about building strong foundations and practicing real workflows used by developers and DevOps engineers. ⚙️ 📚 What I Learned This Week 🔹Understanding how Git tracks changes and manages versions of code 🔹Practicing branching concepts and how teams work on different features simultaneously 🔹 Learning how Git Stash helps temporarily store unfinished changes 🔹 Exploring Git Diff to compare file changes and understand modifications 🔹 Understanding Git Revert for safely undoing changes in a project 🔹 Learning Git Cherry-pick to apply specific commits from one branch to another 🔹 Practicing these concepts through hands-on commands and workflow simulations 💡 Key Takeaways / Reflections This week helped me strengthen my confidence in using Git workflows. I realized that Git is not just about commands—it’s about understanding how teams collaborate and manage code safely. Some concepts required practice, but each attempt improved my problem- solving and debugging skills. 📈 🌍 Real-World Relevance These Git concepts are widely used in real projects and DevOps environments: 🔹 Cloud & DevOps teams use Git for version control and collaboration 🔹 CI/CD pipelines rely on Git repositories to trigger automated builds and deployments 🔹 Developers use branching strategies to develop features without breaking production code 🔹 Tools like GitHub integrate with cloud platforms to manage code, reviews, and deployments Mastering Git is a key step toward becoming a Cloud/DevOps engineer. ☁️⚙️ #LearnInPublic #CloudLearning #DevOpsJourney #GitAndGitHub #ContinuousLearning #FresherJourney #TechGrowth

🚀 Day 60 of my Learning Journey – Git Cherry-Pick 🎯 Discovered how to copy specific commits between branches using Git Cherry-Pick. A small command, but extremely powerful when working with multiple branches in real-world projects. 📘 What is Git Cherry-Pick? Git Cherry-Pick allows you to select a specific commit from one branch and apply it to another branch. Instead of merging an entire branch, you can bring only the exact change you need. This is very useful when fixing bugs or moving small features across branches without affecting other changes. ⚙️ Key Commands & Features 🔹 git cherry-pick <commit-id> – Applies a specific commit from another branch to the current branch. 🔹 Find Commit ID using git log – Helps identify the exact commit you want to copy. 🔹 Resolve Conflicts if they occur – Similar to merge conflicts when changes overlap. 🔹 git cherry-pick --continue – Continue the cherry-pick process after resolving conflicts. 🔹 git cherry-pick --abort – Cancel the cherry-pick operation if needed. 💡 Key Takeaway Understanding Cherry-Pick helps me manage code changes more efficiently and is an important skill for working with Git in DevOps workflows. 📈 💻 Real-World Usage in Industry 🔹 Hotfix management – Developers move urgent bug fixes from development to production branches quickly. 🔹 CI/CD workflows – Teams apply critical commits to release branches without merging incomplete features. 🔹 Production stability – Only safe and verified commits are applied to production environments. 🔹 Multi-branch development – Used when maintaining different versions of software simultaneously. #Git #GitHub #DevOpsLearning #TechJourney #ContinuousLearning #SoftwareDevelopment #CareerGrowth