Here’s the Deal

The Command Line vs fugitive (via vim)

186 31

13 0

When comparing The Command Line vs fugitive (via vim), the Slant community recommends The Command Line for most people. In the question“What are the best Git clients for macOS?” The Command Line is ranked 1st while fugitive (via vim) is ranked 10th. The most important reason people chose The Command Line is:

Using CLI gives access to every single git function available.

Ranked in these QuestionsQuestion Ranking

Common Questions

What are the best Git clients for macOS?

Pros

Pro
The most powerful way to use git

Using CLI gives access to every single git function available.

Pro
Best community support

Since most devs invoke git via CLI there's a higher chance of getting an answer to a CLI based git problem than a GUI-based.

Pro
It's the same across all the platforms

Pro
Gives a better understanding of how git functions

By using the git from the command line, it's possible to learn how it functions and how to get the desired result.

Pro
Available in Homebrew

brew install git

Pro
Fast and straightforward

There's no additional layer of abstraction.

Pro
Simple

Pro
Even a visual representation of various branches and how they're merged is possible

To visualize history:

 git log --graph

Pro
Customizable

You can customize it and/or integrate it into automated workflows. It has support for plugins, additional subcommands, and event hooks to perform automated tasks such as updating a bug database or kicking off tests.

Additionally, because it is a simple command line program, it is easy to create shell aliases, write scripts that invoke it, or integrate it into a text editor.

Pro
Gives you full control over what is happening

Any GUI would just use command-line in the background, so by using command-line you are in control.

Pro
Great visualization and interactive workflow

The visualization and workflow are great in fugitive. You can do side-by-side or even intra-line diffs all without having to leave your text editor.

Pro
Uninterrupted workflow for common tasks

Simple tasks, such as commits, can quickly be made without leaving the editor.

Pro
Seamlessly "Dive into Diffs" to trace the origin & intent of code

git blame only shows the last change (e.g. a variable rename), but how do you find the origin of the code?

:GBlame to open blame window

o on the relevant line to "git show" the commit

select a diff line from a previous version of the file, and hit o to open it

repeat 1 - 3, jumping back through history to find the origin of the line

Ad
Cons

Con
Steeper barrier to entry as compared to a GUI solution

Since you have to learn all the different commands and you don't have the visual help that a GUI app gives you, it has a rather steep learning curve.

Con
Hard to solve complex conflicts

Con
Difficult to overview complex project histories

Con
Recalling is more difficult than recognizing

Although there's autocompletion for commands, it still requires recalling at least the beginning of a command while all that's required using a GUI is recognizing the desired outcome.

Con
Hardest part of the learning curve is the ambiguity of some terms (us/them)

When merging (e.g. git checkout master && git merge my-branch), us refers to master, them is the branch you're merging in. When rebasing (eg git checkout my-branch && git rebase master), us refers to master, them refers to your current working branch. This seems counter-intuitive at first, making it harder to use the CLI to some, but after a while you kind of understand why the terminology is used in this way, and you get used to it.

Con
Diffing

GUI diffing is way superior.

Con
Is a badly designed API

Git has awesome architecture but a bad CLI. The meanings of many commands overlap and contradict each other depending on the arguments passed. e.g. Just some: When checkout is used with file path arguments it is a mutative action, changing the working tree but without those arguments it is for passive navigation. reset is just like the mutative behaviour of checkout except it does it for all files.
branch requires a flag to create a new branch but tag doesn't to do the same with a tag.
https://stevebennett.me/2012/02/24/10-things-i-hate-about-git/