The Cherry-Pick Adventure: A Git Story

Once upon a time in the bustling town of CodeVille, a team of developers worked on a project called AppX. Every day, they added new features and fixed bugs, producing a stream of commits. However, one day, they faced a challenge: how could they select a single, valuable change from a feature branch without merging all of its incomplete or experimental work?

The Problem

In CodeVille, there were two primary branches: main and feature-branch. The main branch was known for being stable and reliable, while the feature-branch contained some exciting, but unfinished, work. One day, the team discovered a particularly important commit — let’s call it Commit B. This commit contained a feature they wanted to add to the main branch. But, the team was hesitant to merge the entire feature-branch, as it still had some unfinished and potentially unstable code.

Enter Git Cherry-Pick

A wise mentor, who had seen similar situations before, suggested, “Why not use Git Cherry-Pick? It lets you select just the commit you need, without pulling in all the other changes!”

Excited to try this approach, the developers gathered at their computers to learn how to use this powerful tool.

Step-by-Step Guide: Using Git Cherry-Pick

Step 1: Locate the Commit

The first thing they needed to do was find the commit hash of Commit B. They ran the following command to view the commit history:

git log        

This command displayed a list of commits in their terminal, showing the commit hashes, dates, and messages. They identified Commit B and noted down its hash.

Step 2: Switch to the Main Branch

Next, they switched to the main branch, where they wanted to apply the changes from Commit B. They ran:

git checkout main        

Now they were ready to bring the feature from feature-branch into main.

Step 3: Execute the Cherry-Pick Command

With bated breath, they used the cherry-pick command to bring Commit Binto the main branch:

git cherry-pick <commit-hash>        

In an instant, the terminal flashed with success! Commit B was successfully integrated into the main branch, but with a twist: it was now a new commit called Commit B’. Even though it contained the same changes as Commit B, it had a different commit hash because it was created on the main branch.

Step 4: Resolve Conflicts (If Necessary)

However, all was not smooth sailing. Git alerted them that there were some conflicts between the changes in Commit Band the existing code in main. The developers quickly sprang into action, collaborating to resolve the conflicts. After carefully editing the affected files, they staged the changes and completed the cherry-pick:

git add .
git cherry-pick --continue        

With the conflicts resolved, Commit B’ was successfully added to the main branch.

The Celebration

The developers cheered as Commit B’ was now part of the main branch, bringing the desired feature without cluttering their project with incomplete or unstable changes from the feature-branch. Their main branch was now pristine, ready to move forward with the next phase of development.

From that day on, Git Cherry-Pick became a favourite tool among the developers of CodeVille. It allowed them to selectively bring in valuable changes while maintaining a clean and focused project history.

Visualizing the Cherry-Pick

Let’s take a look at how cherry-picking works in action with a simple example:

Initial State

Imagine you have the following commit history:

 A---B---C feature-branch
     /
D---E---F main        

Here, commits A, B, and C are on feature-branch, while commits D, E, and F exist on main.

Cherry-Picking a Commit

Suppose you want to cherry-pick Commit B from feature-branch to main. After running the git cherry-pick B command, your repository history would look like this:

  A---B---C feature-branch
     /        \
D---E---F------B' main         

• Commit B’ is a new commit on the main branch that contains the changes from Commit B.
• The commit hash for B’ is different from B because it was created on the main branch.