Make Your Life Easier With These Git Workflows: Part I

I will describe how to make your life easier as a programmer with these useful tips on using Git. Before reading this, I recommend that you have a basic understand on how Git works.

Essential Command Line Argument

My most used argument with git is probably

!$

. It is actually a command line argument. When you type this, the last used argument is replaced. For instance:

Type
```
mkdir myFolder
```
in the command line
Then type
```
cd !$
```
to move into the recently created folder

In the above example,

cd !$

will be translated into

mkdir myFolder

, and this is a bit simple, but think about the times you forgot to stage your files before committing:

git commit -m'feat: Add new kickass feature'

, but you forgot to add the src folder

Then you can write
```
git commit src/ !$
```
, saving you from typing the whole commit message again

I know that you can press the up key,

↑

, to get the previous used command, and sometimes that can be just as easy. pressing

ctrl+a

, to move the caret to the beginning of the command, and then use

alt + →

to move one word at a time, and input

src/

where it needs to be. This is also something I use quite often.

Include Changes In the Previous Commit

I almost always catch typos, excess whitespace, or missing new lines after I make a commit. My best advice for adding these changes is to add them to the previous created commit. You don't want to mess up the git history more than you have to. Use the

--amend

to accomplish this.

Use
```
git commit --amend
```
to add your changes to the previous commit.

By default, on Mac at least, the terminal will open Vim, and you will see the previous commit message. Unless you want to add more to the message, you can type

:wq

which saves the commit message as is, and quits Vim.

But I already pushed the changes to the repository. I cannot change the commit anymore.

Don't worry. You can still amend the last commit, but you need to force push the changes to the repository. If you try to amend a commit that is already pushed to the repo, you will get an error message similar to this

! [rejected] master -> master (non-fast-forward)

error: failed to push some refs to '[email protected]

You might get a hint, telling you to pull the changes from repo, but this will create a conflict in your repository, and you need to create a new merge commit to fix it. This is not what we want. Instead, force push the changes you amended.

```
git commit --amend
```
to add to the previous commit
```
git commit origin yourBranch --force
```
to override the changes in the repo

Using

--force

is a bit scary, because you could loose work permanently. Use it with care, and when you are 100% sure you know what you are doing. It is a powerful command, and with great power comes great responsibility.

I Want to Undo My Previous Commit

This is somewhat the opposite of the previous section. Instead of adding changes, we want to undo them.

I make a lot of mistakes as a programmer, and one of them is committing the wrong files to the wrong branch. What do I do? I want to keep my changes, but remove them from the branch. In order to do this, we need to reset the change:

```
git reset HEAD~1 --soft
```
will reset the last commit, and you keep your workspace changes. (passing
```
--hard
```
instead of
```
--soft
```
means you will discard your workspace changes)
Now you can change branch, and commit the changes to the correct one.

But I already pushed the changes to the repository. I cannot change the commit anymore.

Don't worry. We have a way of solving it, and it involves a force push this time as well.

```
git reset HEAD~1 --soft
```
to undo the commit, but keep the changes in our workspace
```
git push origin yourBranch --force
```
to change the git history in our repo
Now you can change branch, and commit the workspace changes.

Summary

```
!$
```
replaced with last used argument
```
git commit --amend
```
append changes to the previous commit
```
git reset HEAD~1
```
undo the latest commit
```
--soft
```
keep workspace changes
```
--hard
```
discard workspace changes
```
--force
```
overwrite existing code in repository