version-control¶

Git File and Commit Operations: Managing Changes Between States

Introduction

Ever stared at your repo, wondering why a “small” change just won’t commit or push?

GUI tools like GitHub Desktop or VSCode extensions are convenient—but they hide the magic. When things go sideways, or when you need to carefully craft commits, stage parts of files, or undo a “tiny mistake” that isn’t obvious, the GUI often leaves you helpless.

Full CLI Git is where you gain real control. It’s the difference between:

• Clicking buttons blindly and hoping everything works
• Understanding exactly where each change lives (Working Directory, Index, HEAD, Remote) and moving it precisely

Even minor mistakes—like accidentally staging a debug log or overwriting a feature—can snowball into hours of frustration. By mastering the CLI, you can fix problems before they become disasters, cherry-pick changes, or sculpt your commit history like a pro.

Think of this guide as your toolkit: practical commands, clear flows between Git states, and actionable tips to tame your repo—even when the “small” fixes aren’t so small after all.

Simplifying Large File Management in Git with Git LFS

Introduction

Introduction

Have you ever faced the challenge of managing large files within a Git repository?

Whether you're an experienced developer or just beginning your coding journey, dealing with large files in version control can be perplexing. Often, developers resort to .gitignore to exclude files, but what if there are essential large files crucial for your project's integrity?

Enter Git LFS (Large File Storage), a solution designed to revolutionize how Git repositories handle large files. While some files are pivotal to track, keeping repositories lean and efficient remains a priority.

Understanding Git Pull vs Merge in Git Workflow

Introduction

Did you know git pull and git merge are quite similar commands ?

When it comes to managing branches in Git, understanding the nuances between git pull and git merge can significantly impact your workflow's efficiency.

Both commands, git pull and git merge, serve the purpose of integrating changes from a remote branch (dev) into your local branch. However, they employ different strategies to achieve this.

Mastering Git Branch Handling: Strategies for Deletion and Recovery

Introduction

Are you looking to master the art of handling Git branches with finesse?

Git branches are pivotal to managing project versions effectively. Understanding how to delete branches locally and remotely, as well as recovering deleted branches, is essential for maintaining a clean and organized repository. This guide serves as your compass, navigating you through the realm of Git branch management and ensuring a smooth and efficient version control process.

Deleting a Branch Locally (CLI)

Deleting a branch in Git locally can be done using the git branch -d command:

git branch -d <branch-name>

Nesting Repositories with Git Submodules: A Newbie's Guide

Introduction

Are you facing the challenge of handling multiple code pieces scattered across different repositories in your project, unsure how to seamlessly integrate them?

For developers new to the concept, managing disparate repositories within a single project can be overwhelming. Git submodules offer a guiding light, acting as a map through the maze of organizing and linking these separate codebases or libraries within your projects.

Real-Life Scenario: Aligning Frontend and Backend Strategies

Back in 2022, I found myself as the lead developer overseeing the backend team, while collaborating closely with a talented frontend developer responsible for crafting engaging user interfaces.

Our teams operated independently, each excelling in our specialized domains. However, this independence led to distinct branch strategies. The backend team adopted a unique approach, separate from the frontend's strategy.

Over time, this divergence in branch strategies caused disparities between our repositories' states. Aligning frontend changes with the evolving backend structures became a complex task. Ensuring seamless integration between our frontend branches and specific backend versions posed challenges.

Managing Local Modifications and Remote Changes in Git

Introduction

Git is, without discussion, a powerful version control system that enables collaborative development.

Ever found yourself in a twist trying to mix changes you made with updates from others in Git?

It's like trying to blend your cooking style with someone else's recipe without making a mess. Git's awesome for team coding, but when your tweaks clash with online updates, how do you sort it out ?

Indeed, when local modifications clash with remote changes, navigating these conflicts efficiently becomes crucial. Let's explore different strategies to handle this situation effectively.

Mastering Git Merge Strategies: A Developer's Guide

Introduction

Have you ever found yourself tangled in a web of Git branches, unsure of the best path to weave your changes together?

The world of version control can be a maze, especially when deciding between Git's merge strategies. Fear not! This guide is your compass through the wilderness of rebases and merges, shedding light on the best routes to keep your repository history tidy and your sanity intact.

Git offers two primary trails: the rebase, known for its clean and linear history, and the merge, preserving the unique storylines of each branch. Join us on this journey as we navigate the pros, cons, and conflict resolution techniques, empowering you to choose the right path for your project's narrative.

So, this document provides guidance on using Git merge strategies, specifically focusing on the rebase and merge options.