Day 02 : Mastering Branching and Merging in Git

Amulya Magadi — Wed, 15 Apr 2026 17:03:56 +0000

Today’s learning focused on one of the most powerful features of Git — branching and merging. This concept is essential for real-world development, especially when working in teams or managing multiple features simultaneously.

🚀 What is Branching?

A branch in Git is essentially a separate line of development. It allows you to work on new features, bug fixes, or experiments without affecting the main codebase.

By default, every repository starts with a branch called:

main (or sometimes master)

🌿 Why Use Branches?

Develop features independently
Fix bugs without disturbing stable code
Collaborate with team members efficiently
Maintain clean project history

🛠️ Important Branching Commands

1. Check existing branches

git branch

2. Create a new branch

git branch feature1

3. Switch to a branch

git checkout feature1

👉 Modern alternative (recommended):

git switch feature1

4. Create and switch in one step

git checkout -b feature2

👉 Modern alternative:

git switch -c feature2

5. Delete a branch

git branch -d feature1

👉 Force delete (if not merged):

git branch -D feature1

🔀 What is Merging?

Merging is the process of combining changes from one branch into another.

Typically:

Work is done in a feature branch
Then merged into main after completion

🔧 Important Merging Commands

1. Switch to target branch (usually main)

git checkout main

2. Merge another branch into current branch

git merge feature2

⚠️ Merge Conflicts

Sometimes, Git cannot automatically merge changes. This happens when:

Same file
Same lines modified in different branches

In such cases:

Git marks conflict in files
You manually resolve it
Then run:

git add .
git commit -m "Resolved merge conflict"

📊 Useful Commands for Workflow

Check branch status

git status

View commit history

git log --oneline --graph --all

Push branch to GitHub

git push origin feature2

Pull latest changes before merging

git pull origin main

🧠 Key Takeaways

Branching allows safe and parallel development
Always create a branch before starting new work
Merge carefully and handle conflicts properly
Keep your branches updated with main regularly

📌 Final Thought

Branching and merging are the backbone of collaborative development in Git. Once mastered, they make your workflow cleaner, safer, and much more professional.

Today was a major step forward in understanding how real-world development actually happens!

Starting My GitHUB Journey – Day 01

Amulya Magadi — Mon, 13 Apr 2026 16:42:58 +0000

Git & GitHub Fundamentals

Today I started my journey with version control using Git and GitHub. I focused on understanding the core concepts and practicing essential commands that form the foundation of modern development and DevOps workflows.

What I Learned

I explored the purpose of version control and how Git helps track changes, maintain history, and enable collaboration. I also understood how GitHub acts as a remote repository platform to store and manage code.

Commands Practiced

git status
Used to check the current state of the working directory and staging area.
git add
Moves changes from the working directory to the staging area.
git commit
Saves a snapshot of staged changes with a meaningful message.
git log
Displays commit history, helping track changes over time.
git push
Uploads local commits to a remote repository on GitHub.

Key Understanding

I clearly understood the Git workflow:
Working Directory → Staging Area → Local Repository → Remote Repository

This flow is critical for managing code efficiently and avoiding mistakes.

My Takeaway

Git is not just a tool but a fundamental skill for any developer or DevOps engineer. Even basic commands provide strong control over code changes and history.

Next, I plan to dive deeper into branching and collaboration workflows.

Git #GitHub #DevOps #LearningJourney #VersionControl

Forem: Amulya Magadi