Workflow on Commentary of Takao

Migrating from git checkout to git switch and restore

Wed, 25 Mar 2026 00:00:00 +0900

One of the very first commands developers learn when starting out with Git is git checkout. However, git checkout is a notoriously overloaded command. It handles too many responsibilities, making it a common source of confusion and accidental file loss for beginners and experienced developers alike.

To solve this, Git version 2.23 (released in 2019) introduced two dedicated, task-focused alternatives: git switch and git restore.

In this post, we’ll discuss the design problems surrounding git checkout, explain the roles of the newer commands, and show you how to transition to using them today.

Git Merge vs Git Rebase: Operational Guidelines

Wed, 25 Feb 2026 00:00:00 +0900

When integrating changes from one branch into another in Git, developers generally rely on two primary commands: git merge and git rebase. While both serve the same ultimate purpose—bringing code from two branches together—they approach the problem differently, resulting in vastly different commit histories.

Understanding when and why to use each option is key to keeping your project’s repository clean, readable, and easy to debug.

In this post, we will compare the mechanics, advantages, and drawbacks of git merge and git rebase, and outline a set of operational guidelines for teams.

Undoing Merge Commits Safely using git revert -m

Tue, 25 Nov 2025 00:00:00 +0900

Directly after merging a feature branch into your primary release branch (main), you might discover a severe bug that requires you to immediately roll back the integration.

With standard commits, you can easily undo changes using git revert <commit-hash>. However, attempting to revert a merge commit directly results in a Git error: fatal: commit <hash> is a merge but no -m option was given.

In this guide, we’ll explain why merge reverts require special handling, walk through using the git revert -m option, and reveal the hidden trap of re-merging reverted features later.

Advanced git stash: Saving Untracked and Restoring Partially

Wed, 20 Aug 2025 00:00:00 +0900

Introduction

In team development, you often need to switch branches to address an urgent bug fix while in the middle of writing code for a feature branch.

While you can commit your half-finished work as a temporary “WIP” commit, a cleaner approach is to use git stash.

This article covers advanced git stash techniques, including saving untracked files, labeling stash items, and restoring specific files from a stash.

1. The Basics of git stash

Let’s review the most common commands:

Using git worktree for Concurrent Branch Development

Tue, 20 May 2025 00:00:00 +0900

Introduction

In daily software development, it is common to get interrupted by an urgent hotfix request while in the middle of writing code for a feature branch.

Traditionally, developers handle this in one of two ways:

Temporarily shelf active changes using git stash, switch branches to fix the bug, commit, switch back, and run git stash pop.
Clone a completely separate copy of the repository into another directory to work on the hotfix.

However, stash runs the risk of conflict errors on restore, and cloning multiple copies of the same repository wastes disk space and complicates local commit synchronization.

Safe Usecases of git cherry-pick for Specific Commits

Tue, 25 Mar 2025 00:00:00 +0900

Introduction

In team development, you often encounter situations where you need to deploy a specific bug fix from an ongoing feature branch to your production branch (main) immediately, without releasing the half-finished feature itself.

Merging the entire branch would pull in unfinished code.

This is where the git cherry-pick command comes in handy. This article reviews how to safely apply individual commits to a target branch, handle conflicts during execution, and avoid common history pitfalls.

Cleaning Commit History with Interactive Git Rebase

Thu, 20 Feb 2025 00:00:00 +0900

Introduction

During daily software development, it is common to end up with a messy commit history full of logs like “WIP,” “fix typo,” or “testing deployment.”

If you merge these commits directly into your main branch, finding where a specific bug was introduced or understanding why a line of code was added becomes extremely difficult.

Git’s interactive rebase (git rebase -i) allows you to clean up your commit history before creating a pull request. You can squash multiple commits into one, edit commit messages, reorder history, or delete redundant changes. This article covers the step-by-step workflow of utilizing interactive rebasing.