# Understanding Git Rebase: An Alternative to Merging

When learning Git, programmers typically start with commands like `add`, `commit`, `push`, `pull`, `status`, `branch`, `checkout`, and `merge`. After mastering these foundational commands, it's important to understand the `rebase` command.

Rebasing is often used as an alternative to merging. It updates one branch with the commits of another by applying the commits of one branch on top of the other. For example, if you're working on a feature branch that is out of date with a dev branch, you can rebase the feature branch onto dev to include all the new commits from dev. Here's a visual representation of this process:

**Before Rebase**

```bash
dev:     A---B---C---D
              \
feature:        E---F---G
```

#### After Rebase

```bash
dev:     A---B---C---D
                    \
feature:             E'---F'---G'
```

In command line, you can achieve this with:

```bash
git rebase dev feature
```

However, the more common approach is:

```bash
git checkout feature
git rebase dev
```

### Typical Rebase Use Cases

#### Updating a Feature Branch

Imagine you're working on a feature branch, diligently adding commits.

```bash
feature:  E---F---G
```

Then you notice new commits on the dev branch that may impact your feature branch.

```bash
dev:     A---B---C---D
feature:  E---F---G
```

You decide to run `git rebase dev` from your feature branch to get up-to-date with dev.

```bash
git checkout feature
git rebase dev
```

During the rebase, conflicts may arise between your changes and the new commits on dev. Git will notify you of conflicts and the files that need resolution. After resolving conflicts, you add the changes with `git add` and continue the rebase process with `git rebase --continue`. If there are no more conflicts, your feature branch will be successfully rebased onto dev.

```bash
dev:     A---B---C---D
                    \
feature:             E'---F'---G'
```

Now, your feature branch includes the latest commits from dev, and you can continue working seamlessly.

#### Updating a Feature Branch Prior to Merge

Another common use for rebasing is to update a feature branch before merging it into the dev branch. Initially, the state of your branches might look like this:

```bash
dev:     A---B---C
              \
feature:        D---E
```

Once your feature is complete, you should rebase it onto dev before merging:

```bash
git checkout feature
git rebase dev
```

```bash
dev:     A---B---C
                    \
feature:             D'---E'
```

Next, merge your feature branch into dev. This is often done through a Pull Request for review. The result will be:

```bash
dev:     A---B---C---D'---E'
```

Rebasing before merging ensures that all commits from the feature branch appear at the end of the dev branch. This happens because rebasing rewrites commit history, giving new hashes and timestamps to the commits. Consequently, when you merge a rebased feature branch into dev, all the feature branch commits are ordered chronologically at the end.

### Summary

Understanding how to rebase is essential for efficient Git workflows. Whether updating a feature branch with the latest changes from dev or preparing a branch for merging, `rebase` ensures a clean and organized commit history.