Magit, the magical Git interface (2017)
emacsair.me
emacsair.me
I regularly do things like "stash some of my changes, switch branch, cherry pick a commit, switch branch, do an interactive rebase reordering commits and dropping one, pop one of my stashes", and they become routine, so working with code becomes a fluent experience, rather than fighting with your tools.
I would say that Magit and structural editing using Paredit are the two most important technologies that make programming great.
Reminds me it's time to tip some projects.
My 12 year old uses magit as a git interface and nothing else in emacs. That’s not a great testimonial as it was my direction to do that, but it seems to work just fine.
The areas where magit earns outsized praise is not around a basic “pull, add and commit everything, push” workflow, but rather around being selective about crafting self-consistent but single-theme revisions. That will not be as fluid for someone with no fluency in emacs keyboard navigation, but I think I’d still find it easier than using the git command line to do it. (Hard for me to say with 30 years of emacs in the rear view.)
Actually, I think git's got Magit beat on that. Magit might make it easier to stage specific lines, but git can stage specific parts of lines or even changes that are completely different than what's on the worktree, through the editing of diffs with `git add -p`'s `e` option.
(Ediff is a 2-way / 3-way interactive diffing interface, built into Emacs, with plenty of features for surgical diffing of files, buffers, directories and whatnot.)
This is news to me.
> select the section you want to stage and press 's'.
It stages line-wise for me. How do I get it to stage less than an entire line?
cd $(mktemp -d)
git init
echo bar > file.txt
git add file.txt
git commit -m "init"
echo foo_bar_baz > file.txt
# select only "foo_" in magit-status and press "s"
git diff --cached
diff --git a/file.txt b/file.txt
index 5716ca5..2fd000c 100644
--- a/file.txt
+++ b/file.txt
@@ -1 +1,2 @@
bar
+foo_bar_baz
diff --git a/file.txt b/file.txt
index 5716ca5..2fd000c 100644
--- a/file.txt
+++ b/file.txt
@@ -1 +1,2 @@
-bar
+foo_bar
I just updated magit, too. It seems to have been published 3 days ago.
I could swear I remember this working in the past, but I can find no hint of it in a few quick searches, so I'm likely mistaken.
I'm sorry for the misinformation. Thanks for saying something.
I could swear I remember this working in the past, but I can find no hint of it in a few quick searches, so I'm likely mistaken.
I'm sorry for the misinformation.Thanks for saying something.
After hearing so much good of Magit in a previous thread here I thought 'ok why not?' and installed emacs and magit. That alone wasn't a walk in the park as I never used emacs before. Maybe I did something wrong but what I remember from it is mainly 'wtf x 10 and what kind of documentation is this'. After some hours I got the hang of it, and I see why it is liked, but still it didn't make me any faster with git because I already have everything needed for my main workflows (SublimeMerge + aliases). Also felt like to get any real value from it I'd need many extra hours on the learning curve and it wasn't clear to me whether the end result would actually be better than what I do now. So I skipped on it, but again: I fully understand that if you use emacs anyway it would be crazy not to use magit.
It's just keyboard oriented, text-light interaction design if you will.
invoke versionning (key 1), see what's changed, pick the parts you like (few navigations keys and 2 keys to pick/unpick), invoke commit (key 4) write and accept (key 5) (amend is key 6 if you made a mistake)
It's just fast, lean and tailored. Apparently people did it in vi too. I just wish it was the case in more places. Actually, whenever I write a vuejs thing, I try to embed keyboard as much as possible.
https://marketplace.visualstudio.com/items?itemName=kahole.m...
> working with code becomes a fluent experience, rather than fighting with your tools
I also do this regularly, but on my terminal. I don't feel like I'm fighting the git tools. Is this a common experience?
I enjoy using git GUIs as well, especially for visualizing branches, commits and diffs. I just don't understand why the git commands seem to cause so much trouble.
After the pandemic started and I had to witness over screen share how colleagues "use" (fight) git with all sorts of GUI tools, I had to realize that no GUI can be good enough while one doesn't understand git, or, even worse, it can be contraproductive, because people using these GUIs _think_ they understand, but they don't.
I even ended up creating a (tailored) 2x90min git course...
All that said, I heard magit praised so many times, I still have some hope that it's really as good as its reputation.
(Tried fugitive, which is the vim-world's answer to magit, even learned it properly but realized I always juzt <C-z> to the terminal and do stuff with the cli)
https://eagain.net/articles/git-for-computer-scientists/
I'm not a computer scientist and I think it's understandable. Everything became a lot more clear in my mind once I understood the inner workings.
The git tool itself, though, often operates at a much higher level of abstraction. I think that's more where the reputation of being hard to learn comes from. For instance, you'd probably need to write a paragraph or two to explain what "git checkout <branch>" does in terms of the actual object store. Add to that that the CLI is poorly designed - many commands have misleading names, a given command will do completely different things depending on the flags, there's a lot of implicit / counterintuitive behavior, and so on. See https://stevelosh.com/blog/2013/04/git-koans/ for some funny examples.
1. Discoverability. It'll display the contextually relevant options and commands at most points. By using magit, you're learning the git CLI commands at the same time, including commands that you'd normally never come across without a comprehensive read of the manual or release notes.
2. Fewer keypresses. Also, extra shortcuts for some common operations.
3. The bits that CLIs aren't very good for: staging and unstaging pieces of files, viewing conflicts.
(I do still use the Git CLI a lot of the time too.)
I also think that the experiences of:
* looking into a stash and applying only selected changes from it, * browsing all your changes and staging only some of them, * quickly killing changes that you simply want to drop, e.g. not commit and remove from your edits
are much slower when using the command line.
Staging part of files is the only thing I found hard with cli but then fugitive or simply git difftool helps with that too (using vimdiff)
For everything else I defined my own git aliases (git graph, git mr, etc)
sounds like hyperbole but it's not.
edit: magit is like if you spent months crafting a bunch of aliases for the command line and then made a nice little menu of all of them and committed that to memory but also has it as a popup. and even then magit is an order of magnitude better... handily so.
Examples where undoing an operation looks totally different to doing it:
- To stage a change you `add` it, to unstage you `reset HEAD`
- To commit you `commit`, to undo a commit you `reset --hard HEAD^`
The last example is also where you get pointed to an unsafe command for a fairly benign operation. Uncommitting is not particularly dangerous, but anything with `--hard` ought to give people a pause for thought. If you mistype it and nuke more than the last commit, that's also a bit bad - and fairly easily done.
Some other examples include shenanigans around pushing and pulling remote branches. After 10 years of using git, I still need to google it each time.
I think these commands are an accurate and reasonable representation of its inner state, but IMHO users should at least have the option of being somewhat isolated from it. Git is not a tool for algebraic manipulations on directed graphs, it is a version control software.
It has to be said, to git's credit, that although the commands are confusing to some (myself included), the tool works very well. I wanted to like mercurial more, but ended up going back to git, as much as I dislike the UI.
The last example is also where you get pointed to an unsafe command”
Who pointed you there? If I want to undo my last commit, meaning the commit itself, not the changes to my file tree, shouldn’t I say `reset --soft`?
But this in fact reinforces my overall point. I don't want to be messing with `reset`, hard or soft. What is `reset`? [I now know because I had to learn, but I'd really rather not].
What I want is `uncommit`, or something like that.
On the plus side, Git’s man pages are (sometimes) useful and pretty complete. In this case, if you type `man git-commit` you’ll get a thorough rundown of all the options and it will be clear which one you should use to get what you want.
EDIT: Also, since there are three arenas to keep track of, the file tree, the index, and the commit history, even if there were an `uncommit` command it would need all the flags that `reset` accepts. So it would just be `reset` renamed, which you can do yourself. But maybe some of the `reset` options should be broken out into separate commands.
But, if you haven't pushed something up to a remote, the right command to make more changes is to use `git commit --amend`.
That's another pet peeve (though maybe less git's fault): immutable, yes, but then rebase is pushed quite liberally. Arguably not by git itself, but by many online learning resources.
It's convenient, and mostly works, but then occasionally really stings you.
...yet undoing the last commit, arguably the least aggressive of history-rewriting commands, remains awkward.
"History is immutable" is generally accepted as describing the contents of commits, not their id's or relative ordering.
Perhaps git should have a "checked rebase" command that requires a `--force` flag if there's an upstream branch set.
*And even then it's kind of okay as long as no one else has made commits on top of the rebased commits.
Which BTW I learned it exists when magit switched "p -f u" to use it instead of plain --force.
For me, this is where the problem with got lies. I use so many of it's commands infrequently enough that I don't know where the weird disastrous edge cases are, where I should use.
I think git would greatly benefit from a topical man page; a list of common and uncommon situations that shows the recommended commands for solving them, and explains what those commands do. I know that hundreds of random "guides" exist, but are they outdated, are they cannon, do they have bugs? When your UI is esoteric, situational documentation is really important.
If git at least had good man pages. The man-page's description is "Given one or more existing commits, revert the changes that the related patches introduce, and record some new commits that record them." [1] I have a hard time parsing that to mean what it's supposed to mean.
It contains a note that's much better at explaining what git revert does, then goes on to explain alternatives for other things you might want to do, but doesn't mention how to undo a commit without creating a reverting commit.
Can’t disagree. That part could certainly be written better. I’m not saying I would want to learn Git from the man pages, but they’re pretty good in general after learning it elsewhere.
- git revert {rev} to nuke changes and go back to how the world was
- git uncommit to return to the state literally before git commit
- git unstage to unstage a file
The latter arguably should go with git stage but it’s a bit late for that. NB git add and git rm are totally not inverse operations...
So then I can uncommit, and unstage if need be. Reverting is for discarding changes, and should come with an interactive confirmation prompt and other safety and hygiene messages.
This is ambiguous because there are many such states.
1. Clean working tree, before you began hacking on the code.
2. Modified working tree.
3.1. Modified working tree with staged changes.
3.2. Clean working tree with staged changes.
It's impossible to know which state you want to go back to without telling git. That's what hard, mixed and soft resets do: they bring you back to states 1, 2 and 3.2, respectively.
The default is a mixed reset. I suppose state 2 is what most people want when they try to undo a git commit. So it already does the right thing by default, no?
The only remaining problem is the git reset argument. An undo command will always reset to the previous commit, there should be no need for arguments. Stuff like HEAD^ or HEAD~1 is quite obscure to the uninitiated. We could certainly have a git undo command that runs git reset HEAD^ and allows hard and soft resets. Not sure why it doesn't already exist. Has anyone ever attempted to get that merged into mainline git?
[alias]
undo = reset HEAD~1 --mixed
Glad you found something that works for you but this is definitely not true for all of us.
I think the problem with add, commit and reset is they aren't low level enough. The reset command in particular is juggling several concepts at once: HEAD, the index and the working tree. The add and commit commands work with fewer concepts: working tree to index and index to commit, respectively.
I too google the commands I don't use often. There's no shame in that.
> I too google the commands I don't use often.
So, spend more time getting the same result is fine for you?
Sometimes I have to use some command I'm not familiar with. Sometimes familiar commands gain new options. It's perfectly okay to use some reference for that. Also, "more time" is like 1 minute.
If you ever run into this, you can use `git reflog` to see the history of your local actions. It's possible to revert almost any action with it.
Reset a few commits that you've never pushed to remote? No worries! Just go to `git reflog`, find a point before it happened, and `git reset` to it.
$ git reset --hard HEAD^^ # OOPS
$ git reflog
c48300f3 (HEAD -> master) HEAD@{0}: reset: moving to HEAD^^
527e26e0 (origin/master) HEAD@{1}: commit: air-interpreter-wasm = "=0.14.10"
$ git reset --hard HEAD@{1}
If you don’t know git internals, mistype a non-obvious command and lose a bunch of commits, then “look in the reflog” advice is frankly adding insult to injury.
What's right for one isn't right for all.
I want to get things done fast and with less cognitive load, magit allows me to, git doesn't.
I've still managed to do it (or maybe I used git rm to delete some files that weren't committed?) so let me give one more shout out to 'git fsck' which saved me here.
Git is garbage collected, even if a commit is dropped from a branch it won't simply disappear immediately afterwards. The object is still in the git repository and it can still be reached, most easily through the reflog. Only when garbage collection is performed will any unreachable commits be deleted.
You're not meant to delete commits like that. Git encourages you to stop "lying about the past", and you will run into a fair amount of trouble if you try to do so with shared history. You don't remove a commit "backwards" and change history; you add a new commit that undoes the previous one (git revert)
Couldn't disagree more. To me, one of the massive advantages of Git over other VCS tools is the support and completeness of its ability to edit time. You are the editor not just of the content under control, but over its branched evolution. Accepting this and working with time gets you to a next level of control.
The first step in this process is really internalizing the tree of commits, and seeing branches not as lines of development as much as simple pointers on that tree. In many VCS systems, branching is a big deal. In Git, a branch is just a smart tag that is automatically updated by HEAD. Users new to Git need to get comfortable creating branches at a whim as the tree grows.
The next step is getting comfortable with editing the tree itself. Primarily, I recommend using interactive rebasing liberally. This has multiple positive side effects:
1. It causes the author to think at a higher-level of the primary artifact they're constructing — the tree of incremental changes.
2. Authors begin to think about the repository as more than a dumb file backup system, but instead as a history with true utility, and so begin to construct "stories" in that evolution that are instructive and useful to future readers of that history.
3. It takes the author out of the flow of time, and encourages them to think about ways to change the past (within limits, of course) so that the constructed history is improved.
All of this, of course, with the caveat that shared history changes must be coordinated (and frequently avoided). You can get very far thinking this way just about your un-pushed topic branch.
There's a very real philosophical difference between those who see VCS as a secure audit trail (where changing history is "lying about the past"), and those who see a repository as a whole constructed artifact of intrinsic value, wholly editable as its contents. In this latter view, editing a line of source isn't "lying" about that line's contents, and neither is editing time.
I did specify that rewriting shared history is going to cause you trouble (unless you really know your way around things), but apparently it wasn't clear enough
After trying a couple of times, I haven't been able to get used to magit, and I gave up. I'm very used to the git command line interface, and magit is just too different from that. For instance, it seems to assume I want to operate only on a file, whereas most of the time I want to operate on the whole repository. I have no idea why someone would want to work like that.
I found it was taking a lot of extra research to get it to do what I wanted, and I was completely confused by its choice of default behaviours, so I gave up trying. I would welcome an interactive tool that is more oriented around the way the command line tooling works, but magit does not seem to be it.
I do have magit installed however, because I really like how it controls emacs buffers while using interactive rebase. But I never use the rest of it. I have no interest in trying to memorize which hotkey does what, and how to bend yet a new interface to my will (that apparently disagrees with my preferred default behaviour), when I already know the git command line.
you don't have to, most of the time `git subcommand` counterpart is just `M-x magit-subcommand`
There is also nothing wrong with copying your entire tree to a different directory, diffing, applying patches by hand, and keeping track of what goes where.
Those are different levels of automation for the same fundamental task, but they are all legitimate solutions to the same problem, although you might end up spending more or less time to perform the same fundamental task, depending on the level of automation.
What? There is plenty wrong with that. I've worked with people who did that. There are lots of problems with this approach. It's extremely hard to work with and it only gets harder the more people are involved. At least in git the commits have unique identifiers, everything is hashed and checksummed automatically, branches are properly tracked, etc.
I've even worked with non-programmers whose version control was emailing each other files named like:
Presentation final final REALLY FINAL (2) (3).ppt
All that means is that git tools, and your front door, work well once you have mastered them. The ease of use and discoverability of tools over the life of their learning curve is what determines if they are a Norman door.
For lots of people, using a Unix command line or Git for the first time feels like a Norman door. This is why other interfaces exist (like guis) for the same tools.
What is a Normal door - 5 min Vox short https://youtu.be/yY96hTb8WgI
My big hang-up with interactive rebases is that I do them just infrequently enough that what exactly a set of choices will yield—what's going in the commit message, et c.—is something I have to sit there and reason about for a really long (by the standards of something that really is not that complicated an operation) time. I can also never keep it straight when editing messages in-line will have an effect, and when it'll be ignored (in some commands it is, IIRC, in others not? I can never remember, but either way, why the hell let me edit it if it won't do anything?)
What I could really use is a live preview of what the effects of my current choices will be.
If I want to rebase changes onto a different commit, re-order them and squash some of it, I'll rebase as-is first, then do another rebase and reorder everything so that squashes are next to each other (and yes, sometimes this means unnecessary conflict resolutions), then a final rebase to squash. I'll edit messages last.
Yes. Today I spent way too much time explaining to a coworker that what he was complaining “should be easy to do but seems impossible” was actually quite simple, only to spend ages explaining how git works, why he wasn’t understanding the paradigm. And after all that help what he needed to do was simply to “git checkout feature-A && git merge master” we didn’t even touch on rebasing, and it’s not like he hasn’t used git before, he had at least half a decades worth of experience working with codebases managed in git.
And this is far from the first time that I’ve had to help out people with something that seems extremely straight forward to me and others who have git under our skin, but is overly complex and difficult to people who might not be experts but have worked with git for several years in a state of “minimal viable knowledge”.
Git has the same problem as it’s creator, it is arrogant, and has for way to long tried to explain the fact that new users find it difficult with “well they are just dumb” instead of accepting that it needs to make its user experience and interface more intuitive. Some of these changes are finally happening now, so I no longer have to explain why “git checkout” is used for seven completely unrelated things, but there are still tons of cases where the “straight forward way” to do something is only accessible to people who have spend way too much time doing deep dives with git and fully explored all the edge cases just for the fun of it.
It doesn’t help at all that googling issues is swamped with advice of “just force it” or “delete the repo and clone it again” which can cause permanent damage to the codebase, for a tool that is at its center suppose to avoid permanent damage to your codebase. No matter how stuck up some blinded advocates of the “git is and has always been perfect”-camp you are, everyone should understand that needing to give advice like “and if you have an issue don’t Google it, go see me or another git expert first to avoid loosing code history” is at its core spotlighting fundamental issues in the tool interface.
Isn't there some middle ground between "minimal viable" and "expert" that you could (should) aspire to, like "reasonably competent"?
I think it's not a matter of "just" a version control system; it's vital enough to (most of) our jobs that being more than just "minimally viable" good at it is an integral part of being reasonably competent.
But who am I to talk; at work, I almost exclusively use Informatica's built-in "version control system", which IMO... isn't much of one; actually, hardly is one in the first place. Getting to use git (or similar) again is what Idream of. Then again, maybe that just means I'm only "minimally viable" with Informatica's system. :-)
(All out of Spätzle, have to wait for next "Alpenfest" week at Lidl. :-( )
To me the git command line is one of the tools that are great if you use them often. But if you use it less often it's really hard to remember the correct syntax especially since it's really easy to mess things up. (If know WPF, the binding syntax is in the same category. Really powerful but if you take two months break you struggle with the syntax). It really bugs me in git when normal things need 3 or more parameters and if you forget one of them you mess things up.
Years ago I worked with mercurial for a while and I thought the commands were much cleaner and easier to remember.
But there is one thing I believe is still not-very-smooth in the git cli: splitting hunks.
if I do interactive add in git, and I get small hunk that adds a line, deletes a line, adds another line, and deletes a line, then if I want to include only the addition of the second line, it is pretty annoying in git cli. In magit, it is basically selecting the line and pressing "s".
I don't feel like I am either - I think some people are not fans of CLI. Full disclosure: I also don't "get it" when people say they can't use tar without looking up the help/man pages.
I get by with less than 10 git commands - in rough order of decreasing frequency: pull, commit, add/rm, push, stash, checkout, merge, and more rarely bisect, revert and reset.
Trying to stash some of the changes is pretty annoying, yes. New files don't want to cooperate with stashing, and there's no way to stash just staged things like making a commit; you have to use -p.
That would be a nice feature!
Or use magit that has a stash index option.
I would also add undo-tree to that list, it's like having a lightweight VCS on every file without needing to resort to git.
That's interesting because those are two tools I've tried to adopt multiple times, but never have managed to do.
Paredit is at least partly due to my long use of vi (and almost as long use of vim) keybindings; I use evil-mode, and bind << and >> to the appropriate adjust-parens functions for strucutural editing.
Magit is due to me having used git for so long that it takes me at least 5-10x as long to do something with magit as with the git terminal, and I'm just not at a point in my life where I desire to fight with my VCS when there is another option.
I suppose I'm just stuck in local maxima with regards to those two things, but I'd say I'm fast enough.
Hopefully that's just because VSCode didn't allow arbitrary widgets until recently. Presumably they're working on it.
[0] https://marketplace.visualstudio.com/items?itemName=mhutchie...
In the Source Control window, select your file then in the right panel:
- Select the first range of lines
- Alt + select the second range of lines
- Cmd + Shift + P > "Git: Stage Selected Ranges"
or in multiple steps (I usually do it like that):
- Select the first range of lines
- Cmd + Shift + P > "Git: Stage Selected Ranges"
- Select the second range of lines
- Cmd + Shift + P > "Git: Stage Selected Ranges"
I wish magit-forge [0] had more features though - like I cannot create new labels from it.
Please consider donating [1] to the developer if it has made your life any easier.
git add -p
Then you can decide if each hunk is staged or not.
Just select any parts of the diff using regular edit text select commands and press "s" for stage.
What is Tig?
Tig is an ncurses-based text-mode interface for git.
It functions mainly as a Git repository browser, but
can also assist in staging changes for commit at
chunk level and act as a pager for output from
various Git commands.It’s not hard (`git add -p`) unless you need line-wise selection.
The main issue in my experience is that it’s completely linear so you need perfect memory and to never make any mistakes: git shows each hunk individually and tells you to make your choice before it shows the next, no take-backs.
Magit shows the entire diff and lets you jump around, and selectively unstaging is just a “d s” away.
As someone without perfect memory and makes mistakes, I consider git add -p ergonomics very user unfriendly. But I guess that's your point :)
I also routinely use line-wise selection and often revert unnecessary lines when crafting the index.
That requires finishing the current staging, moving to unstaging, processing the unstaging (also a linear hunk-wise process), restarting the ataging, and remembering to skip the stuff you’d mistakenly staged.
The workflow of magit is much easier here, and the staging / unstaging integrates very well with reviewing the local or staged diff. Crafting good commits has way less friction and error recovery is much better.
For example, the fact that you can just jump around the buffer and stage/unstage things as you go, means you're free to use whatever you most like for that "jumping around" part. Incremental search? Sure. Ace-jump? Yes. M-x occur? If you must.
Magit on a bare-bones Emacs is extremely ergonomic on its own, but if you use and adapt Emacs for yourself, all the improvements compound on each other.
- some people swear by the integration of Git into IntelliJ or other JetBrains IDEs, which is pretty good (but personally i don't really like it)
- others enjoy a Visual Studio Code plugin or two that provides a vaguely similar and enjoyable user experience
- personally, i rather like completely separate Git GUIs, like Git Cola (https://git-cola.github.io/), SourceTree (https://www.sourcetreeapp.com/) or GitKraken (https://www.gitkraken.com/)
- of course, there's also a group of people who prefer more text based approaches (Vim or Emacs plugins?)
- and there are those that enjoy using the CLI because to them it feels like the most "true" option with the least leaky abstractions
In my eyes, however, staging/unstaging/discarding changes to particular lines or chunks of code, as well as having visual diffs is a really useful use case for GUI solutions of any sort.
EDIT: also, it isnt 'line-by-line'. Its logical-chunk-by-logical-chunk. The algorithm will try to group local changes together and you need to explicitly tell it to split the chunk up if it is over eager.
The hunk algorithm is not very good in my experience and following the prompts to split them is just about as nice an experience as editing files with `ed`.
Have you tried using a GUI or an editor that supports staging selected lines?
Obviously, my experience must be unique, because everyone loves Magit. It might be the most-loved piece of software ever. Every other week, there is an article on Hacker News about how it's the best piece of software ever to exist, and I've never seen anyone say anything bad about it. So I wonder what marketing techniques they use to make people feel this way; the emotions are strong, and widely shared.
Maybe there is some fundamental insecurity about Git, and Magit makes people comfortable? I've never felt that way, but I did start using Git the weekend it came out, and my Github user ID is in the low 2000s, so I might have had time to get Stockholm Syndrome with the Git UI. I suppose it's possible that the people writing these articles may not have even been born when Git came out, which is interesting to think about actually!
Many many people use git as cvs and are confused once it goes past “commit and push”.
I know I don't really know what to do if someone pushed to master whilst I was working and it complains. Usually I just make a new checkout and merge in by hand.
I know immediately what magit is going to actually do when I use it. I could easily do everything in the terminal but I don’t because magit lets me do things so much faster and with fewer keystrokes.
Interactive staging of hunks in magit is far superior to doing the same thing with the CLI. Making interactive staging easier helps prevent hunks from ending up in the wrong commit. Oftentimes 2 different parts of a changed file in the worktree should not be in the same commit, so being able to stage hunks lightning fast in emacs is a game changer.
Here is an example of what I would do in magit with spacemacs which has evil-magit
SPC g s — pulls up magit
Tab to expand a file
s to stage
c c to commit
l L to see a detailed graph of all local branches
Move cursor to commit I want to cherry pick
A a to cherry-pick commit that my cursor is under
p p to push my branch to remote
When I’m deep in work it’s so incredibly lower friction to do that sequence of actions in magit than using git CLI.
Sure I’ll still drop down to the real thing if I need to do some really esoteric spelunking through the repo with plumbing commands but if I’m already in emacs magit is amazing.
I am a magit lover and have been using it for at least a decade now and can't imagine going back to a terminal.
It's not the marketing. It just works really darn well and it speeds up my workflow.
So yes, most Git users are just like you and see no upside to Magit. Call it the silent majority.
I like magit, but I never figured out the rebase flow with it, so I just do that on the command line.
Where magit really shines for me is being able to stage and unstage hunks of code very easily. Looking at my current changes, stashing and un-stashing, searching through git log, seeing the diff of a particular commit, quickly fetching from upstream or switching branches... All of that becomes quick and easy once the key bindings become second nature. There are definitely major quirks of the UI / UX, but I found it worth fighting through that.
edit: I've re-read your post again, and I would just like to reiterate that staying away from magit's interactive rebase might be a good idea. Besides that, I also try to stay away from triggering ediff mode -- even after spending time with it and getting to know how it works, I've decided that it's simply not very good.
It would only pop up from running `git rebase -i` (or whatever) if your $EDITOR is set to emacs. I'm a heavy emacs/magit user, and even I find the idea of setting my $EDITOR to `emacs` abhorrent.
I use emacs as my daily driver also, however if bash wants an editor it's usually a small task, so I'm just as happy to use vim or nano. Most often I can't install emacs on remote servers anyway.
For other things... you'd have to ask somebody else. I generally do any type of branching or merging or similar using the git cli, and that's part of the beauty of magit: she doesn't care when I cheat on her that way.
It's easy. 1) Listen to the fans when they suggest a feature even if it doesn't click when first hearing about it, but then approve upon the initial suggestion, turning it into something I myself would want to use too.
2) Ignore the haters except for telling them how to disable that one feature that is so abhorrent it makes the whole tool unusable:
(with-eval-after-load 'git-rebase
(setq auto-mode-alist
(delete (cons git-rebase-filename-regexp 'git-rebase-mode)
auto-mode-alist)))Rare, yes.
> , because everyone loves Magit. It might be the most-loved piece of software ever. Every other week, there is an article on Hacker News about how it's the best piece of software ever to exist, and I've never seen anyone say anything bad about it.
> So I wonder what marketing techniques they use to make people feel this way; the emotions are strong, and widely shared
Ah, you've lost me. Why are you dismissing the other possibility that you have bad judgement?
I'm using magit, along with tig, plain git and sometimes (!) even plain "vc", depending on context. I'm in the camp that thinks it's ok and it's pretty comfortable to use within emacs, but I don't see the earth shattering praise I see every time it's mentioned here.
Tig for example is so much faster for history and blame perusal that I find it faster to keep it open in another terminal and just switch to it.
Altenatives? Contrarians?
Maybe the reason is another? Personally, I once had Magit act real slow at times because git-annex had added some git hook for something that I didn't need. Just removing that hook improved performance massively. Perhaps something similar is happening.
Also, I'm not sure Emacs Lisp can interface directly with C libraries, so using libgit2 might not be an option.
I only work on Emacs in small projects though... so maybe that's why it's fast for me?!
I believe these days (i.e. since emacs 25) it can via dynamic modules. There are ffi libraries built on top of it.
In a perfect world, Emacs would link to libgit2 and Magit would be adapted and folded into the core distribution.
Whatever is causing the slowness you're seeing, I don't think it's just because of the number of calls. It's probably the slowness of one or two specific commands, perhaps due to repo size.
Seems like there's something going on in the windows world.
However, my own cited example about browsing history and blames is one case where I cannot just stomach the subpar efficiency. Tig also runs git as a subprocess, but every view is truly incremental and you can scroll through any buffer in any view and there's absolutely zero delay. Night and day even when comparing emacs with JIT.
Like for magit, tig has one keystroke shortcuts that make sense (which IMHO is pretty common on good TUI programs) and can perform many git operations directly from the spot you're looking at.
I also consider the visual space usage in tig to be much more efficient as well. Especially the blame view, which I find still wasteful in all modes compared to tig's. I frequently use a customized vc-annotate instead.
Magit hooks also considerably slow down operations on remote files, which can be quite annoying if you don't actively need to use git while editing.
Don't get me wrong - I like magit. But like org-mode, I don't get the glorification it gets.
- I generally dislike layers on layers; while I seriously hate the git UI, I'd rather learn that, as it's a more portable skill, than learn another UI, that relies on emacs and a package installed. First thing I do on e.g. a new cloud instance is clone a bunch of stuff, and often work on an under-setup machine for a while. For similar reasons, I don't use shells like Fish, which, nice as they may be, funnel me into something totally incompatible with good old sh. Bash and zsh, as far as I use them, are compatible.
- I work in tmux, and emacs in terminal, the overhead of switching to a terminal and typing some git stuff is tiny.
- I tried magit and just didn't get it. I couldn't couldn't find a happy path where I thought, "ah yes this is niice".
I mostly use plain git instead of Magit, for more or less the same reason, although I like git's UI.
I did find a happy path, though. Magit's blame interface is very nice to recursively call git-blame and navigate history of pieces of code. I ended up making a CLI program to improve git blame[1] so that I didn't end up switching to Magit just for that, but doing git-blame from Magit is still better.
I'm surprised to hear this. Magit is a very thin layer on top of git. Not thin in the technical sense, but in UI/UX sense. Keybindings map almost one to one with git CLI. Arguments to the git CLI are explicitly stated. Executed git command is reported. I learned git better by using Magit.
FWIW, most Magit commands have 1:1 correspondence with git commands; when I'm worried I'm doing something with Magit that I wouldn't be able to replicate with CLI, I just press '$' to pop up the "process buffer", i.e. the buffer containing actual git commands being executed, along with their output. Conversely, I still read git documentation to figure out more advanced Magit workflows.
My way of looking at it is, Magit is just an ergonomics layer on top of git - it doesn't introduce new abstractions, it just lets you do stuff in a more efficient and interactive way. The love comes from that efficiency - the improvement is big enough to make a qualitative difference and affect the way I interact with git.
(And, of course, you can just press !! and type in whatever git CLI command you want, to run in context of your repository.)
> the overhead of switching to a terminal and typing some git stuff is tiny.
Switching cost is low, but typing cost is much greater.
Of course, everyone has their own preferences. I personally swear by Magit, and I'd love to have more command line tools be integrated with equivalent interface. Magit's UX paradigm isn't a total replacement for all CLI - but it's perfect for tools you repetitively invoke with different parameters to sculpt something.
That typing cost is why I use a GUI. While many times I can just enter `git add -u` into the terminal, there's still plenty of times where I want to be selective about what goes into the commit. If a simple glob pattern can't do it, then I'm going to reach for the GUI where I can just click on all the things I want to add to the commit in far less time than it would have taken to type all of the file names.
The GUIs also keep me immediately informed on the state of my repo. On the terminal, I'll be running `git status` a lot, just to be sure the state I think the repository in in and the actual state match up.
The popup-based paradigm for keyboard operation helps with discoverability - first few times around, you'll be going slow to learn what key does what, but after that, you'll be issuing most commands from memory.
The key point I was trying to make is that an interface that minimizes the amount you need to type out and that gives you instant feedback to your actions is a superior experience for working with Git in many cases. I say this as someone who uses Git from the command line a ton (to the point where I've added some custom command scripts) but then when I need to do anything complex or browse the logs and diffs I'll enter `gitex` to bring up the Git Extensions GUI.
I prefer IntelliJ's git interface.
Magit can do everything IJ can, but in IJ, I can find how to do things more easily and it just feels easier to do things, probably because it's much more GUI than text compared to Magit. For example, difficult merges are extremely easy in IntelliJ, I can edit code in the diff view itself while I resolve conflicts... in Magit it requires getting used to the different diff views, something I am still trying to figure out, but it seems trickier to do "in-place" changes in the code.
That said: I probably only prefer IJ because I've been using it much longer than I have used Magit... and the difference for me is very small, so I suspect the more I use Magit, the more the gap will close and I may eventually like it even more than IJ.
Not the biggest deal since neither of those commands require interacting with the output which makes them equally easy to run from the terminal, but it's strange that they're not available in an immediately obvious place.
In the lower right, there's the vcs "where you're at" that shows the current branch. From there you can see the status of your branch compared to others (if you need to fetch them), or you can update branches (even those you're not currently on) along with branch specific operations including push. You can access the same in the git panel with right clicking on branches in the log.
At any time, you can double tap shift to bring up the "search everything" window. Within that, if you type "git push", it will display that action along with the menu that action is in and any key shortcuts that are bound to it.
Also, glance under the "Help" menu - there's a productivity guide. That shows you a whole bunch of features (and how often they're used) and how to use them.
Maybe you disabled the git toolbar in the menu?
There's a little bit of discussion on it.
Its UI for resolving merge conflicts is so intuitive and powerful. You get 3 panels: local changes on the left, remote changes on the right, and merged in the middle. It's got colored highlighting going across from each of the side to the middle, showing where the changes want to go to, and you click arrows to accept/dismiss left or right, and sometimes it'll even have a suggestion for a way to take both of the changes (indicated by a magic wand). And you can also just type into the center editor if you want to not use either side, and manually rewrite the resolved change yourself, whether that be copy-pasting from each side or whatever you want to do.
It's saved me so many times, it's practically worth the cost of the entire IDE on its own.
It's very cool and flexible and doesn't tie you in to any big tech provider (yay!), but it's just an outliner at the end of the day.
I will say that I won't be using it, as I use GUI tools, with a far smaller "power" level, and use command-line Git for the few times I need anything fancy.
While working on kernel I sometimes get "looks nice, but can you reorder and re-split this 15-patches series in completely different way?" and magit is a big time-saver for that. It wasn't as useful on my previous jobs where 1k-lines commits with message like "Implement feature X" were the norm, though.
interactive rebase: no
cherry-picking: yes
That said, I’ve financially backed Magits development (Kickstarter iirc) and I use it almost everyday, but I don’t do merges with it. I’ve had some large merges go really slow thru Magit. So I always do my merges in the terminal using the plain git CLI.
Sublime Merge and vscode + git plugins are pretty close to each other but Sublime Merge does everything I need with less fuss. vscode just has some rough edges due to it's swiss-army knife approach that Sublime Merge doesn't.
People should try this kind of thinking instead of big engineering principles that only slow the machine and the user down.
It's only the 13th time I wrote this.
It reads like it wants to convince you to try magit, without demoing a single example of how it's superior.
It also sounds magical in the worst kind of way.
Also, while in magit, you can type `?` to see the list of available commands from the location where you're pointing at... the commands are single-letters, so you normally do `?`, find the description you want, type `p` (push I think!?) or `c` (commit) or whatever... it's really easy and convenient.
Git is full of that kind of thing. Tealdear and friends usually save me from digging through SO posts or manpages, so remove much of the pain, but it's still worse than having a reminder already on the screen.
(actually, some kind of automated tealdear in a second term or tmux pane, reading what I'm typing with some kind of auto-complete magic so it can show me options quickly even for longer commands, and smart enough to look up "git rebase" as "git-rebase" or whatever, would be amazing... I'll have to look into that)
#!/usr/bin/env bash
emacsclient -c --eval "(progn (magit-status) (delete-other-windows))"
The only downside I have for now about magit is when using `pre-commit` it can run for long sometimes, so it would be nice to see the progress/output of pre-commit while waiting for the commmit message buffer to appear. If you know a way I'm all ears.
But does it make me much more productive? I don't know.
While developing typically I add some debug code mangled with the actual stuff. So when I am ready to commit I've got to remove that first. I had done this manually in the editor before, now from within magit I can just select the lines I'd like to stage and press "s". Then proceed to commit pressing "c". Finally, by just selecting the remaining lines and hitting "k" ("kill") I get rid of all debug code. That's pretty nice and I will never ever forget to remove debug code again. Similarly, you can manage your git stash with a couple of key strokes.
Branching and merging works well, too. But I don't think magit makes it much easier as you still need to type in branch names. Autocompletion is supported, but git provides this as well.
Merge collisions are still a pain. And for more complicated tasks like interactive rebases, reflog rescues or bisecting I still keep dropping to the shell. I actually like the expliciteness, here, because it prevents me to stupid things in dangerous maneuvers. And "git help" is always there to remind me on all gazillion command line arguments.
But yes, I do drop to the shell for some actions when I know exactly the sequence of git commands that I need to execute. Also somehow I often use the shell to switch branches, some habits are hard to change.
Same here. I've found completing-read for branch names to be one of the biggest draws for Magit, personally. I can tab-complete them in my shell, but it's much slower and less reliable.
git, as a classic unix cli app, doesn't provide autocompletion
git, as a classic unix cli app, doesn't know nothing about the result of a previous command, etc.
These aren't the git flaws, but Unix ones.
I also like git-timemachine for stepping a file forwards/backwards through commits (that's not part of magit, I just think it's neat)
Also inspired me to try out Emacs but that's a longer story
Compared to opening up Github, or stashing and checking out via git manually, it was so much faster.
I tried to learn emacs once, and the tutorial started with "I've been using emacs for about 25+ years and I'd say I'm about a middle of the road user"... that was when I was like, "No, I'll just keep using IntelliJ or vscode or whatever".
It's not that I love or even care about any IDE, I just literally haven't the first clue as to even get started with emacs. So what should I do if I want to give it a second chance?
I am a new Emacs user. I decided to give it a try about ten days ago, so I followed the built-in tutorial, read a bit about minor and major modes, buffers, global and buffer-local variables and it started making sense. The online documentation is extensive and the built-in documentation system is very easy to use.
Now if I could only find an emacs email client whose interface I can tolerate...
In my particular case, it was cute for a while until I did my first "git rebase -i" to reorder some patches or whatever and found myself in some kind of magical editor mode where nothing worked the way I knew. I literally couldn't figure it out from what was on the screen. Totally greek. Utterly useless without further learning.
Did I stop and read the docs to figure out how it wanted me to rebase in this brave new world? Hell no. I restarted emacs, disabled it, and never looked back. Right into the garbage it went.
Do. Not. Break. Workflows. Software that doesn't understand this principle is something I don't trust not to break itself when its developers decide to get cute. Stay away.
(Does seem pretty though)
What use would magit be if it presented the exact same interface as `git rebase`?
Do you know what it would lose?
> Did I stop and read the docs to figure out how it wanted me to rebase in this brave new world? Hell no.
I suppose you don't since you didn't read the docs.
Why try it in the first place if you expected it to be the exact same?
Speaking of "nanny knows best," your pretentious use of punctuation and capitalization triggers a three-alarm d__che alert.
I'll assume your patronage of incontinence products followed naturally from applying this maxim when potty training.
I use it everyday and it's pretty awesome.
e.g. with tig, you invoke "!git commit" by pressing C from the status page.
With magit, from the status page, commit is performed by pressing cc. But, if you press only 'c', a context menu is brought up which shows the flags which can be set, and commands which can be run.
e.g. 'cc' is 'commit', but 'ca' is 'amend'.
e.g. An example of a flag might be "--force-with-lease". So, press 'P' opens the push context menu, '-f' enables the "--force-with-lease" flag, 'p' pushes to the remote. (Or just 'P-fp' quickly works, too).
tig looks like 80% of the benefits (much nicer to use than git) for 20% of the effort (not having to learn Emacs).
And I have no idea how to use emacs. Is there any helpful user manual? Should i give up on magit?
The learning curve is fairly steep in the beginning, but after ~15 years, I feel that the initial effort has paid off a lot. Not everyone likes emacs, and that's okay. But I do think it is worth giving it a try and seeing for yourself.
(As for the whole vi-vs-emacs debate, I have used both over time, and I do use vi quite regularly for quickly editing some config file. There are packages for emacs, like evil-mode, that emulate vi's key bindings and behavior, but I have not tried any of them.)
Then you're in the magit window with menus and prompts and so forth.
So yea, people are building it out of emacs!
Do you have any specific workflows that you prefer one over the other?
It's frustrating for me because I believe magit is the best git interface there is. Using it increases your understanding of git and decreases your chances of error. I'd really like the rest of my team to use it instead of the CLI. But when I think about it outside of emacs, it just doesn't work.
Aware of this, and tried it. However much of these distributions is streamlined towards EVIL keybindindings so you don't really get the full experience. Furthermore, a lot of the Emacs keybindings have been opinionated, which again isn't bad but a little jarring.
Also the vi keybindings tend to reactivate every now and again, and often you can take a few goes to realise this as you fumble in frustration and lose your train of thought.
> It relaxes the learning curve.
Yes but you'll have a learning curve either way, and by the time you've passed it you'll know neither vim nor emacs, and you won't get to experience the joy of tailoring your own development experience nor will you have be able to make use of much of to the decades of support content that's available on the web.
As I said, it makes more sense if you've already worked with VIM and want to have the best of both worlds but even then I think you're still missing out on some of the finer experiences Emacs has to offer.
Disagreed with "start with Vanilla Emacs and build your own config" though, if you just want to get started quick. Hell no, you'd be discouraged within the first 5 minutes and spend all of your time searching which ctrl-alt-meta-whatever to press to do trivial things, or copying/pasting obscure elisp snippets that you don't fully understand from stackoverflow.
That was my point when I said
> if I was coming to emacs from VIM ... if you want to do emacs from scratch it’s probably easier
There is no quick start with any of these environments .. and even then it takes some detailed technical knowledge to get them up and running. They do sure look pretty! Although I found some of the default theming a little hard on the eyes for prolonged work.
> Default config is almost 'good enough'
The problem I had, was that to go beyond that it's a little trickier than what I'm used to, and there really isn't the same degree of support as what you get with more orthodox approaches. Though the community small is it is around these distributions are enthusiastic, helpful and friendly.
Like I say, the whole muscle memory thing feels quite alien at first, it soon becomes quite delightful, but not a lot more difficult to learn I think than VIM. I do like VIM, and there's many occasions where I'll use that for a quick command line based edit, and perhaps at some stage I will learn the VIM keybindings properly to the point where EVIL mode makes more sense.
I wouldn't gripe too much about the complexity of emacs, since that's where a lot of it's power lies (even if I never fully use it myself), but I wouldn't be in the habit of just copying/pasting random elisp. Usually if you've to go that much trouble it's not worth it, as somebody would have made it easier already.
alias magit='emacsclient -t -c -e "(progn (magit-status) (delete-other-windows))"'
Is magit good enough to actually force people to learn that little bit of Emacs?
I believe I was the first to implement a major feature in it which was rejected upstream! So now I maintain a fork :)
https://github.com/magit/magit/issues/4285
Thankfully, package managers such as straight.el make it very easy to configure using a fork of some repository, without breaking dependencies.
Checking logs, checking and merging changes, searching for files and commits… all this is much easier to do with a GUI. Of course, for complicated stuff one should still know the cli commands, but 99% of the time the GUI is what makes me more efficient and faster.
Ok, soft G might be the best choice.
https://github.com/TimUntersberger/neogit
Similar Git tooling can be found in https://github.com/frontaid/git-cli-tools
Magit 3.0 - https://news.ycombinator.com/item?id=27274670 - May 2021 (140 comments)
Magit – A Git Porcelain inside Emacs - https://news.ycombinator.com/item?id=24431216 - Sept 2020 (83 comments)
A walk through the Magit interface - https://news.ycombinator.com/item?id=21729597 - Dec 2019 (81 comments)
Forge – Work with Git forges from the comfort of Magit - https://news.ycombinator.com/item?id=19137353 - Feb 2019 (34 comments)
Magit 2.13 released - https://news.ycombinator.com/item?id=17220630 - June 2018 (49 comments)
Show HN: Magit, the magical Git interface - https://news.ycombinator.com/item?id=15358723 - Sept 2017 (5 comments)
Magit Kickstarter fully funded - https://news.ycombinator.com/item?id=15312288 - Sept 2017 (71 comments)
Magit (fantastic Git mode for emacs) is running a crowdfunding campaign - https://news.ycombinator.com/item?id=15263869 - Sept 2017 (4 comments)
Magit on Kickstarter - https://news.ycombinator.com/item?id=15154712 - Sept 2017 (1 comment)
It's Magit the Magical Git Client by Jonas Bernoulli – Kickstarter - https://news.ycombinator.com/item?id=15150476 - Sept 2017 (2 comments)
Emacs and Magit - https://news.ycombinator.com/item?id=14819256 - July 2017 (174 comments)
Magit maintainer taking a break - https://news.ycombinator.com/item?id=11077526 - Feb 2016 (1 comment)
Magit: a Git porcelain inside emacs - https://news.ycombinator.com/item?id=10643977 - Nov 2015 (14 comments)
What's new in Magit 2.x - https://news.ycombinator.com/item?id=9936095 - July 2015 (23 comments)
Using Emacs and Git with Magit 2.1 - https://news.ycombinator.com/item?id=9873237 - July 2015 (29 comments)
Magit a Git Porcelain for Emacs - https://news.ycombinator.com/item?id=9547948 - May 2015 (2 comments)
Meet Magit - Git Mode for Emacs - https://news.ycombinator.com/item?id=2543265 - May 2011 (4 comments)
Magit: Emacs mode for Git - https://news.ycombinator.com/item?id=361697 - Nov 2008 (2 comments)