Hacker News new | past | comments | ask | show | jobs | submit login
Magit, the magical Git interface (2017) (emacsair.me)
658 points by Tomte 46 days ago | hide | past | favorite | 344 comments



Magit is such an unbelievably good piece of software. If you haven't used it, please at least take a look. It seems like "just a GUI for git", but that's missing the point — many operations suddenly become frictionless, so your entire workflow changes.

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.


> 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

> 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.


What I dislike with git terminal UI is that commands reflect the innards of git, not what the user wants to do. It also forces a deeper understanding of the innards for basic commands than ought to be necessary.

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.


> If you mistype it and nuke more than the last commit, that's also a bit bad - and fairly easily done.

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}
And you're back before "OOPS" :) It's really hard to lose changes once they've been committed.


Yes, except... again, this is fighting fire with fire.

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.


The age old adage applies here: know your tools.


Software is for people, not for software itself.

I want to get things done fast and with less cognitive load, magit allows me to, git doesn't.


And he knows it well enough to prefer a different tool.

What's right for one isn't right for all.


If it was that easy, https://blog.waleedkhan.name/git-undo/ wouldn't be a thing.


The reflog is awesome! It keeps pointers to commits that have been dropped, rewritten by rebases, stuff like that.

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.


> It's really hard to lose changes once they've been committed.

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.


Yeah, git is certainly a low level tool. That's actually what I like most about it. There's a few fundamental concepts I get to manipulate directly with git commands. I like dealing with innards like this because I can form a mental model of the tool. High level tools are a lot harder to understand.

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 probably pushed and pulled O(100) remote branches over the past decade (jeepers I'm getting old), so roughly once a month. It's not that rare, yet I still haven't memorised them, because I find them so unintuitive.


Once a month is close to my usage and it's often enough to remember things in principle but not often enough to remember the d#$%#$%^#$n syntax with all its obscure details.


> Yeah, git is certainly a low level tool.

> I too google the commands I don't use often.

So, spend more time getting the same result is fine for you?


Depends on the result. I do interactive rebases extremely often, I don't have to look up how it works.

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.


“ - 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”

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`?


My bad, misgoogled.

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.


That’s a valid point. I think there’s a near consensus, even among people who admire Git and use it constantly (like me, although I’m no expert), that the porcelain commands are confusing in some respects.

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.


What is "uncommit" though? Do you want your changes gone, staged or unstaged?


I’d like something like:

- 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.


> git uncommit to return to the state literally before git commit

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?


You can always:

[alias]

undo = reset HEAD~1 --mixed


git revert is probably what you want?


This creates a new commit that reverses the changes of a past commit. That’s different from undoing your last commit, as in, you made a commit but then changed your mind, and want, say to make some more changes before you commit. (Explained in man git-revert.)


> Explained in man git-revert

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.

1: https://git-scm.com/docs/git-revert


“ I have a hard time parsing that to mean what it's supposed to mean.”

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.


They are decent for reference, and some are genuinely great (like git-everyday [1] or git rebase [2]). But just as often as they are helpful they just leave me scratching my head, either because they are too deep in git-lingo or because they forget to clarify some crucial details

1: https://git-scm.com/docs/giteveryday

2: https://git-scm.com/docs/git-rebase


That's by design; Git history is intended to be immutable when working with others.

But, if you haven't pushed something up to a remote, the right command to make more changes is to use `git commit --amend`.


> Git history is intended to be immutable when working with others.

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.


Rebasing has a simple rule: it is perfectly fine as long as you haven't shared those commits.*

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.


It's also very wise to make sure you disallow force pushing to master/main/production. If you force push to a topic branch, it's usually ok. If you accidentally overwrite someone's changes, it's because you are working together and you can communicate that you messed up and for them to `pull --rebase` or however you want to resolve it. Usually that is. There's always room for disaster :)


> Usually that is. There's always room for disaster :)

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.


Ya, the git UI is not great. It has improved a ton over the years but still not great. Have you ever seen Git Koans? It's good for a laugh. https://stevelosh.com/blog/2013/04/git-koans/


--force-with-lease

Which BTW I learned it exists when magit switched "p -f u" to use it instead of plain --force.


Oh right. I always neglect to do that mostly out of laziness of typing it out on the command line. It's funny, though, I maintain a branch plugin for vim (it's a fugitive extension) and I recently accepted a PR to switch `--force` to `--force-with-lease` yet I still don't do it. I need to start doing it!


How is "git reset HEAD~" "awkward"? It's not obviously named, but as was noted above, if there was git-uncommit, it would need every option that git-reset has, and so it would just be an alias, without the final argument.

"History is immutable" is generally accepted as describing the contents of commits, not their id's or relative ordering.


I've been using git for ~8 years and I've never heard of --soft


The default for `git reset`, which is `--mixed`, may do what you want. The difference between `--mixed` and `--soft` is that the former resets the index as well as moving the HEAD pointer; the latter only moves the HEAD, so if you’ve `git add`ed any changes, they will remain staged.


Wow this is a new level of Git hell I haven’t even heard about!


Yeah, keeping track of Git’s three areas (files, staged changes, repository) can get confusing. After some thought I think my advice to you to use `git reset --soft` would be better as just `git reset`, because that’s a neater “starting over”: it’s more of an “undo” of the last commit action, I guess. I often find myself reaching for `git reset --hard` after screwing up and not feeling like tracking down how I broke things.


"It also forces a deeper understanding of the innards for basic commands than ought to be necessary."

Glad you found something that works for you but this is definitely not true for all of us.


"- To commit you `commit`, to undo a commit you `reset --hard HEAD^`"

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)


> You're not meant to delete commits like that.

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.


Interactively rebasing your local changes instead of sharing a hodgepodge of brain vomit is great, but don't go around rebasing history that's already out there between a team of developers unless you have a really, really good reason to.

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


Reset is a powerful command that happens to work for the “uncommit” use case. I use reset for a completely different use case: my CI system watches a specific branch for changes and when they occur builds it with a specific configuration. If I reset-push a branch, I get a build of that branch with that configuration.


I am the same.

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)


Why would I use magit over the git CLI?

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 think (2) is why I use it, it's just much faster. It doesn't let you skip over understanding Git, it just makes you work faster.

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.


I tend to avoid using stash in that fine grained way because branches are cheap in git, and you get a rich set of operations using a local branch to stack up unorganized code changes. Rely on stash on only very quick setting aside of work then returning to it. If I stash and find it needs to live longer than that - I’ll stuff it into a named branch.


Re: 3 ... I find that the CLI ("git add -p") works here when the scale of the changes I've already carried out is fairly small and there are not too many orthogonal changes in the file tree that I want/need to commit separately. If that happens, it's off to magit I go.


I'm usually a pro-GUI person but I've always found git GUIs to be confusing/trying to paper over the model in a way that made me not like them. Though I don't mind what IntelliJ has. Maybe I need to give this magit tool a try as well.


Sounds like the same for which I started using (and then eventually abandoned) fugitive.

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)


1 is really true. Magit is how I learned about workstrees!


Magit is absolutely fantastic and it reduces friction, discoverability and joy. rebasing is easy. commiting is easy. staging is easy. discovering is easy. everything is easy. it's incredibly powerful and also incredibly easy to use. it's simply the best software i've seen written in a long time.

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.


I gained a better understanding of git through this document:

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 underlying model of git is not too hard to understand, and is actually pretty elegant. There are a number of good explanations online, including the one you linked.

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.


That's a really cool article. The wording could be a lot simpler but the important part is that it does not abstract the concepts. They don't need to be abstracted because they are really simple. Situations can become very complex, especially when someone does not know what they are doing. Developers need to learn the priciples without lies and overzealous simplifications. If you know what's going on it's a lot more doable to not end up in a super complex situation, but not a lot of people have a really good explanation of git even if they understand it very well themselves.


This free book[1] is authoritative and explains Git very well IMHO.

https://git-scm.com/book/en/v2


Same.

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.


If you start from the magit status buffer, most things operate on the repo, except file-specific commands like staging, unstaging, etc. For those, if you run the command with your cursor on the heading, rather than with it on a file (e.g. on the “unstaged files” heading rather than on a particular file), it will ask for confirmation and apply the operation to all of the files.


More generally, magit applies operations on whatever the cursor is on, when it makes sense to do so. This is very convenient e.g. for staging parts of a change at different granularities: I can stage everything, then unstage a file, then stage a hunk within that file. It only takes a few keypresses, compared to a long set of commands followed by dredging through add -pi.


> I have no interest in trying to memorize which hotkey does what, and how to bend yet a new interface to my will

you don't have to, most of the time `git subcommand` counterpart is just `M-x magit-subcommand`


There is nothing wrong with using git commands in the terminal.

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.


> 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.

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
It was a hell unlike anything else I had ever experienced before.


> I don't feel like I'm fighting the git tools. Is this a common experience?

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.


“minimal viable knowledge" describes my git knowledge. I simple don't have time to become a git expert. After all git is only a source control tool, there are way more important things to deal with that impact our customers.


> “minimal viable knowledge" describes my git knowledge. I simple don't have time to become a git expert.

Isn't there some middle ground between "minimal viable" and "expert" that you could (should) aspire to, like "reasonably competent"?


I think I am reasonably competent to do my job. I just don’t think there is much value in learning more. It’s just a version control system.


> I just don’t think there is much value in learning more. It’s just a version control system.

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. :-( )


I like having both. I use fugitive in vim which is great for partial staging, blaming, and committing (and status). Almost everything else I do on the command line. I will also commit from the command if I already happen to be there. The one thing fugitive is indispensable for is looking at a file on a different branch right in the editor.


> 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?

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.


I prefer to do my interactive rebases in steps, instead of all at once.

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.


Interactive rebases are my favorite git feature. I get to pick, drop, reorder, reword, fixup, squash, split and of course rebase commits. Pretty much everything I need to create a nice history before pushing.


> I don't feel like I'm fighting the git tools

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.


Yeah, it's definitely the mnemonic single-key and terminal gui that makes magit great. That, and the genuinely low occurrence of bugs in the software.


"I just don't understand why the git commands seem to cause so much trouble."

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.


I was like you for a really long time. Then, I watched someone do stuff in Magit that took longer or I struggled with to get perfect in the terminal. Took a few weeks to get comfortable, but once I did, it was really nice.


I'd just like to say I'm not opposed to the GUIs at all. I use gitk and sublime merge a lot. They are really nice too.


You probably don’t feel like you’re fighting your front door when you walk out of your house or apartment also right?

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


If you know git cli very well, most of the stuff are straight forward. Most people struggle with git if they have not spent the time to understand how it works.

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".


Agree. I always use either gitk or sublime merge for dealing with hunks. Diffs too.


git gui


> 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?

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.


You have to do it in two steps with --keep-index.

Or use magit that has a stash index option.


I used this feature enough that I forgot/never even knew that it wasn't built in to git-stash.


> there's no way to stash just staged things like making a commit

That would be a nice feature!


i agree, i do all those things using git. no reason to learn another abstraction. maybe create a few aliases to reduce typing.


Can I like magit if I don’t like emacs?


You can, but it will be worth it for you to spend a little effort to learn the basic buffer, window, and cursor management keystrokes.

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.)


> but rather around being selective about crafting self-consistent but single-theme revisions

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.


I'm somewhat convinced you can replicate that last feature (staging arbitrary / sub-line pieces of your changes) through ediff-staging (E s), but ediff is a complex tool in itself, and I don't know how to use it properly yet.

(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.)


Magit has great support for staging parts of lines - select the section you want to stage and press 's'.


> Magit has great support for staging parts of lines

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?


When your press 's', you should have a region selected, in order to stage that region - if your cursor is just sitting on a line without selecting part of it, you'll (probably) just get the whole line staged.


When I press s, the entire line is staged even if my region is a subset of that line.


...huh. I just tested this in my Emacs instance and it works as you describe.

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.


The second line you quoted tells you how.


It does not. As I said, pressing s does not stage less than a line for me, even if my region is a subset of the line.


When selecting only part of line, 's' will still stage the full line for me.


Indeed.

  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
will show

  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
rather than the desired

  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 can't really imagine this feature working that well with just selection. Editing of the diff seems required.

I just updated magit, too. It seems to have been published 3 days ago.


..huh. I just tested this in my Emacs instance and it works as you describe.

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.


What percentage of git users do this compared to the percentage of magit users staging line-by-line or confidently amending/cherry-picking/interactive-rebasing?


In my experience: yes but it I have the impression it'll remain a bit of a struggle unless you go all in and learn emacs as well.

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.


There's a VSCode plugin based on magit. In my experience, it's basically identical (though occasionally a bit slow when there's lots of files).

https://marketplace.visualstudio.com/items?itemName=kahole.m...


you can try https://github.com/jesseduffield/lazygit, i think its quite similar. It is a TUI for git. It has made my git workflow very friction-less. Makes it very easy to cherry-pick commits, rebases, selecting chunks of files to add in atomic commits, and simplifies the resolutions of merge conflicts. It is also integrated into lunar vim if vim is more up your alley


Depends on what you mean by not liking emacs. If you prefer vim, then you can just install Evil to get similar-ish modal keyboard controls. If you are more of an IDE-person who likes controlling stuff with a mouse in VS or IntelliJ, then probably no.


I believe magit underlying ideas are good no matter what software you use, it's not an emacs only principle.

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.


Absolutely. I can honestly say I learned Magit first (since it was directly applicable to my job) before I "properly" learned emacs.


I used my own emacs for several years, then switched to Spacemacs. It's far easier to learn and use for most people, and also works with Vim keybindings. I'd recommend giving it a try.


if you like vim i'd suggest you install spacemacs and the git layer.


The first two extension I set in Emacs.

Reminds me it's time to tip some projects.


> I would say that Magit and structural editing using Paredit are the two most important technologies that make programming great.

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.


> I would say that Magit and structural editing using Paredit are the two most important technologies that make programming great.

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.


Magit is an exceptionally well made interface to Git. Yes, it’s built on top of Emacs, and that might stop many from even looking into it. - I am glad I made a deep dive into Emacs last year, and although I stopped using it as an IDE (VS Code is just too good), I still come back to it because of Magit (and macros, general text editing and org-mode). Yes, I have an interface for Git in VS Code as well, but it‘s very rudimentary compared to Magit, and it’s limited to the narrow left bar. And to give an example: Making „micro commits“ by staging various lines of changes is super easy in Magit, but I still haven‘t found out how to select several disconnected lines for staging in VS Code.


You should check out edamagit, magit for vscode! https://github.com/kahole/edamagit


I just found this earlier this week and this as a key ingredient of VSpaceCode (Spacemacs bindings) enabled me to finally able to switch to VS Code for Elixir & Javascript programming, which has made me so much happier.


> I still haven‘t found out how to select several disconnected lines for staging in VS Code.

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"


Or just right click on the selected lines and Stage Selected Range


VSCode with Gitlens is the best git GUI experience I've had. I prefer most operations via git cli, but for commiting partial changes and merge conflicts, it's everything I could ask for.


I just discovered that GitLens has been acquired by GitKraken. Considering that GK's entire business is "buy our premium Git GUI because the free ones suck", I have to wonder if they'll try going to intentionally wreck the extension. Fortunately it's MIT licensed.


I disagree. It's ok. But it doesn't even have a DAG viewer. What kind of GUI doesn't even have `git log --tree`?

Hopefully that's just because VSCode didn't allow arbitrary widgets until recently. Presumably they're working on it.


Git Graph [0] already exists as a different extension from GitLens. It works quite well, although of course it would be nice if the two extensions could integrate with each other.

[0] https://marketplace.visualstudio.com/items?itemName=mhutchie...


That looks nice! Yeah these things are so integral to development it would be nice if they were just core features of VSCode.


i agree. vscode is my magic these days.


Spacemacs.org brings the vi modal editing configuration to bear and is highly recommended.


If you just want that you don't need spacemacs, just evil mode.


Well, I physically cannot take the keystroke geometry if stock emacs for any stretch of time; the space bar approach is crucial for me.


Evil mode supports leader keys. It’s pretty trivial to setup.


The real value of Spacemacs is which-key and having everything already configured with semantic leader key setups. Like you can absolutely do that yourself but at that point you're implementing Spacemacs.


Open the diff, select the lines, right click, "stage selected lines".


But how do you select lines / changes spread all over the file? Doesn‘t work via Shift or Command click.


Actually it might require the gitlens extension. It's very well integrated and I've been using it for so long I don't know where one ends and the other begins. Regardless, if you open the diff view, the right hand side is editable and you can make selections like any other view.


You can either do it multiple times (my preference), or you can use Alt for multiple selections.


Have you used Git Lens yet?


Magit is insanely ergonomic. Like how easy is it to selectively stage portions of files in the git CLI? In magit it is usually just a few keystrokes.

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.

[0] https://github.com/magit/forge

[1] https://magit.vc/donate/


> Like how easy is it to selectively stage portions of files in the git CLI?

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.


>not hard[...] you need perfect memory and to never make any mistake

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.


I very often do line wise selection with magit, so that my commits are atomic and single-topic.


I think 'git reset -p' lets you unstage a selection, and I'd use '/' in both searching for the chunk to unstage and to continue where I left off.


> I think 'git reset -p' lets you unstage a selection

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.


Importantly, and this is why Emacs users tend to love Magit, the workflow integrates well with rest of Emacs. Your staging and diff buffers are just that - Emacs buffers. Meaning all your quality-of-life configurations and extensions are available as well.

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.


How many other Git GUIs have you used? Over commandline git, almost any GUI will feel like an improvement for tasks like selective staging or diffing.


I think this largely depends on the particular person and their preferences:

  - 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
Personally, i think that you should use whatever you feel the most comfortable with and let the people around you do the same.

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.



A terminal ncurses alternative to Magit :)

    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.


Does anyone actually do line-by-line staging using the CLI? That sounds masochistic. Most editors/GUIs make it very easy.


I ALWAYS use git commit -p. I can't count the number of times clion/intellij/pycharm or vscode have done something unexpected, and I often catch things that shouldn't be committed, e.g. logging statements, commented code, etc. It takes an extra minute, but it really helps the code quality. Every senior engineer I work with (developing trading system) does the same.


Is it not easier just to review your changes? I always read through a PR after I've sent it just in case.


I always use `-p`. Its my default so its not 'more work'. Its the best way to get clean, atomic, history. It also lets me do things like mock out services or hardcode connection strings without having them accidentally exposed. I've had way too many accidental commits in the past to go back to full file add.

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.


I wasn't really asking how many people do line-by-line commits in general. Obviously it's useful for all the reasons you said. But it's particularly masochistic to do it via the CLI rather than through a GUI or editor.

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?



> Like how easy is it to selectively stage portions of files in the git CLI?

git add -p

Then you can decide if each hunk is staged or not.


In my experience magit version is much faster to use since you can simply select which lines you want to stage without having to refine the hunk.


Not even just lines - you can selectively stage arbitrary regions too.


Cool, didn't know about that. To boost Magit a bit, you can stage parts of patch hunks, I use that quite a bit.

Just select any parts of the diff using regular edit text select commands and press "s" for stage.


I've never seen the upside. I use Emacs as my primary editor, and I regret it every time I say "today is the day I start using Magit". It is exceedingly invasive, triggering itself even when you don't ask for it (like running "git rebase -i" on the command line). The invasive stuff changes how the text editing itself works, but doesn't add deep features. In the interactive rebase case, I lose the ability to treat the interactive rebase text as text, but I also don't gain anything. I can't just navigate around, kill a line, and put it somewhere else. Well, I can do that, but the usual keybindings don't work, they just made their own for no reason. And, for example, if I do use their UI and pick "reword" as the operation for a certain commit, I should be prompted for the desired rewording then and there, right? But that's not what happens, I press C-c C-c to commit my changes (why isn't it C-x # which is how I'd normally close an emacsclient session?), then Emacs goes away, then it comes back up, then I can type my rewording. If you pick it more than a few times, you just get a seizure from all the flashing lights. This isn't a good user interface. It's a bad user interface.

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!


> So I wonder what marketing techniques they use to make people feel this way; the emotions are strong, and widely shared.

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)))


Let me rephrase that: Give those that already love your project more of the same instead of wasting time on making those who think your approach is fundamentally misguided slightly less dissatisfied.


Using git for so long is almost certainly what’s up - you not only know all the various commands but “grew up” with git so you didn’t get them all in a rush.

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 knew git at a deep level before picking up magit and I can’t disagree more with how you paint magit. Magit is the one and only git GUI that actually aligns with the git CLI and doesn’t present git as just another VCS like perforce.

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.


Perhaps I misread both of you, but I think you are in agreement actually


I've not experienced this and I suspect most people don't is all. It's probably not personal and certainly not magic marketing sauce.

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.


Just to clarify, does emacs/magit really pop up when you run "git rebase -i" on the command line? I haven't experienced this, but maybe that's because my EDITOR env var is set to "vim". I would find that very annoying.

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.


> Just to clarify, does emacs/magit really pop up when you run "git rebase -i" on the command line? I haven't experienced this, but maybe that's because my EDITOR env var is set to "vim".

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 have a systemd user emacs service running and set my EDITOR is set to emacsclient so it is really snappy.


Magit's log command made my Doom emacs unresponsive for hours, after which my patience gave up and I killed it and restarted. I guess it just doesn't work on larger repositories.


> Obviously, my experience must be unique

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?


Some tools inspire reactions like this. Nix and NixOS also fall in this camp. The small number of people who love them write blog posts and comments evangelizing them. The much larger number of people who find no use for these tools, or who tried them and do not like them, do not find it worth the energy to write something about why they did not like the tool or why they just never bother to try it. Even if they did write something, it wouldn't get upvotes - "I tried this Magit thing, and it's supposed to be better than vanilla git, but really it isn't, so I keep using vanilla git," is just not an interesting blog post.

So yes, most Git users are just like you and see no upside to Magit. Call it the silent majority.


Is there a name for this type of bias?


It might be a case of survivorship bias: https://en.m.wikipedia.org/wiki/Survivorship_bias .


For your everyday stage->commit->pull->push I think magit is damn near perfect. Staging individual files, or even individual blocks is simple and not verbose (unlike cli equivalents). Picking out eg. problems with my gitignore I find to be easier while looking at the magit status page as well. I think conflict resolution also bears looking at.

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.


Ah, for me it doesn't invade the command line at all, perhaps because I don't have emacs set as $EDITOR?

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.


Why would you run "git rebase -i" from the command line if you have magit? It's cool that it works, but it's far from normal. Just do it with magit and you won't get the "flashing lights". The rebase workflow in magit is one of the best parts.


I like magit because it stays very true to Git's native theory of operations and is much quicker. I'm an evil/Spacemacs user and the bindings make sense to me. Marketing has nothing to do with it.


C-c C-c is a natural "do it" binding in many emacs dialogs, as opposed to C-c C-k. I understand you might prefer C-x # if you often use emacsclient as your EDITOR, but I would venture to say that most people might not.


Just curious, are you a primary evil user?


For the sake of discussion, can we get some contrarian views?

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?


Ok, let me try.

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.


IntelliJ's git interface is basically the only way I can use git, or at the very least pull off anything other than the most standard tasks.

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.


IntelliJ GIT ui/ux is so completely frictionless it's magical at times. The only downside is that it makes incredibly complex operations trivial that I never learned git from the cli beyond the very basics.


Really? I tried it yesterday from within Rider and I gave up on it because I couldn't even figure out how to push or pull. Best I could find was fetch.

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.


You can customize the menu (and I do) to add a Git menu sub panel (for lack of a better word) that has an up and down arrow for push and pull.

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.


Oh wow I didn't know that search everything in Jetbrains products included the menus and not just the contents of the project. That's handy to know. I've been a fan of Ctrl-Shift-P in Sublime Text, so it's always good to see similar features in other software.


I've used it for the "where is that show whitespace menu setting? meh... shift shift whitespace. Change setting."

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.


Double-shift can show too much, to find only actions try `Cmd+Shift+A` and type the name of the action you want to run.


Others mentioned the shortcuts, but there's also obvious buttons in the toolbar with a green up-arrow for commit+push (the button for Commit has an option to also Push) and a blue down-arrow for pull.

Maybe you disabled the git toolbar in the menu?


Ctrl-T for pull, Ctrl-Shift-K for push.


IntelliJ is amazing, and I'd love to have a standalone version of its git frontend for my slower machines.


https://youtrack.jetbrains.com/issue/IDEA-152437

There's a little bit of discussion on it.


Being able to edit the diff directly in the status buffer would be a great additional feature in magit!


I use emacs and git, and never got on with magit. Not entirely sure why, but here's a braindump:

- 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 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.

[1] https://github.com/jolmg/git-reblame


> I generally dislike layers on layers; while I seriously hate the git UI, I'd rather learn that

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.


> I'd rather learn that, as it's a more portable skill, than learn another UI, that relies on emacs and a package installed

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.


> Switching cost is low, but typing cost is much greater.

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.


Yup. But then, clicking time (or rather, navigating your mouse) is also slow. Where Magit shines is in being a GUI (a TUI), so you're always informed on the state of the repo, but it's also fully keyboard operated, so you don't have to click on things.

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.


I say "click" but I really mean select. Mouse or keyboard doesn't matter to me. Something being a GUI instead of a TUI doesn't mean it can't be designed to be entirely keyboard driven (and hell that goes the other way too: since a TUI can get mouse events, you could write one that isn't fully keyboard driven).

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 remember when magit went from 1.x to 2.0, a couple of common commands changed keybinds and it was extremely painful to change the habits as they were commands I typed hundreds of times per day. Still it didn't take long to adapt.


I'm not a terminal maximalist, but most git actions are easy to perform from the terminal. Switching to a terminal and typing the right git command has little overhead, and it's a universal way of doing things.


My contrarian view: I pronounce it maggot. I think Mag-it sounds weird.

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.


Magit is unfortunately so slow on Windows that it's unusable. This is a real shame, because the UI is fantastic. I think a better architecture would use libgit2 calls rather than launching multiple git processes for every single magit operation.


Magit is not particularly fast on *nix either. Most of the UI operates on buffers which are prepared infrequently, so the latency doesn't have significant impact. This is a very good UI design for magit itself, since staying within emacs provides bigger benefits in most cases.

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.


Is the launching of processes on Windows so much slower than on Unix-type OSes that it would cause it to be "so slow" for that reason?

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'm pretty sure it's the main reason. Look how many times Magit shells out to git to render the status buffer, too many to count: https://github.com/magit/magit/issues/1327

In a perfect world, Emacs would link to libgit2 and Magit would be adapted and folded into the core distribution.


I just called the status buffer from magit on a repo. It was 23 calls to git, mostly for rev-parse. The status buffer appeared instantaneously on a decade-old laptop.

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.


Try opening the status buffer on a project with 50+ submodules. On microsoft Windows. Prepare to wait over 1 minute.


or when you are in the middle of a very large merge.


Are you testing on Windows though? I am specifically talking about Windows being the (biggest) problem with this architecture. It is very expensive to create new processes on Windows versus Unix (threads are cheaper on Windows though).


Another commenter said that they also experienced slowdowns on macOS, so I thought the OS actually didn't matter much on this, but based on disgruntledphd2's comment, I guess it does.


Well, I definitely notice the difference between using magit on Windows vs magit in WSL (on the same box).

Seems like there's something going on in the windows world.


Unfortunately, it's pretty slow on macOS, as well. I love Magit, but there are times when I feel like it's hindering me more than helping due to the performance.


I use it on a low spec MacBook Air, and it works just fine for me... never noticed any kind of slowness.

I only work on Emacs in small projects though... so maybe that's why it's fast for me?!


Yes it will depend on repository size.


That, and I often have multiple projects open at once. There's a note in the Magit manual about this and how it affects performance, but unfortunately, the workaround means that buffers don't get refreshed and you might see stale information unless you perform a manual refresh.


I noticed better performance using native-comp in magit (and the rest of emacs for what it’s worth) on macOS. Might be worth a shot!


> Also, I'm not sure Emacs Lisp can interface directly with C libraries, so using libgit2 might not be an option.

I believe these days (i.e. since emacs 25) it can via dynamic modules. There are ffi libraries built on top of it.


I get the same impression using org mode vs hearing people talk about it. It's great! but the way it's talked about makes you think it will change your life and finally stop you being a lazy procrastinating fool.

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 like org mode, I use it every single day, and I'd agree most of the time. 9/10 I'm using it as a glorified markdown editor, but on that 1/10 occasion where I get to do something really cool is where it feels magical.


I really like https://gitup.co.


I picked up Sublime Text + Merge a few months ago (I wanted Sublime Text and figured I'd try out Merge since the bundle was cheaper), and it turns out I use Sublime Merge way more. (Sublime Text is fine but for my workflow it has a bunch of gaps with Visual Studio that I haven't been able to fill).

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.


I'm not familiar with tig. Is it convenient for staging chunks of code or even individual lines? Interactive rebase including re-splitting commits? Cherry-picking stuff?

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.


chunk/line staging: yes

interactive rebase: no

cherry-picking: yes


I can't imagine (haven't tried it so I'm just speculating here) that Magit functions very comfortably on something like a deep clone of the Linux repo, but I think there would be very few monolithic projects most of us would encounter with that kind of lengthy history in our day-to-day work. Maybe some Googlers could weigh in on how their large repos are handled by Magit?


I'm not going to post anything "contrarian," so to speak, because this really does seem to be an excellent tool.

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.


I'm using Visual Studio Code for basic git functionality and switch to Visual Studio proper when I have to deal with gnarly merges. Merge UX is fantastic in VS.


Magit should be studied in computer classes. I'm from the eclipse j2ee college era. They tried heavy OO guis, none matched the ergonomics of magit. I'm still surprised to this day how lean and translucent magit feels.

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.


This post is the epitome of "tell, don't show", when it should be the opposite.

It reads like it wants to convince you to try magit, without demoing a single example of how it's superior.


Then this post may be more appropriate https://emacsair.me/2017/09/01/magit-walk-through/


Thank you for sharing. If the original post had included stuff from the one you sent, that would be a high-quality blog post worth reading.


On Magits homepage the articles are shared together as well https://magit.vc/


> Commands are invoked, not by typing them out, but by pressing short mnemonic key sequences.

It also sounds magical in the worst kind of way.


Actually, what makes Magic fantastic is that it continually shows the commands and the various action keys in the gui. This provides a very accessible way of learning a very complex tool.


I love command line tools that provide hints or "command palettes". Typical CLI stuff is great for things I use at least once a week, and usually only in a couple ways. It's terrible at presenting me stuff I could be doing that I don't know about [edit: yes, I know how to use apropos, which is great but still something you have to think to go query on your own], or reminding me how to do the fifth-most-common thing I do with a tool, but that I do only 10% as often as the fourth-most-common, so I have to look it up every single time.

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)


It's not magical. I forget commands all the time, then all I need to do is type `M-x` (to enter a command, like `Ctrl+P` in VSCode I think) and enter `magit ...` where I get auto-complete (if I do it often, I try to remember the keyboard shortcut, but that's optional).

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.


This is one of the things that makes Emacs one of the coolest pieces of software to me. 98% of the operations it can do, are defined in functions, which you can search for easily in the M-x pane with something like Helm, and boom. Even navigation. It's a near fully self-documenting editor that I rarely need to look up help on. Never forget how to activate an action again. Remember what the action is, type it, find the matching command that is aptly-named, push enter to run it. And, with Helm for example, it even shows the keybind next to it.


It's just like vi, for whatever that's worth to anyone. It also has "transient", which shows you what the key sequence you've input so far will do and lets you customize it.


In the same way that abbreviations are magical relative to spelled-out words.


Even though I use magit and I think it's the best git porcelain that exists, I felt the same way before I started using it, and a little of the same way whenever I need to go find out how to do something I haven't done before.


Tip of the day: you can have `magit` as a fast and standalone tool by using this script (require emacsclient to be setup properly):

  #!/usr/bin/env bash
  
  emacsclient -c --eval "(progn (magit-status) (delete-other-windows))"
This will open the repository under the current path in a maximized magit window.

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.


You should just be able to hit `$` in the magit buffer to watch the output.


Oh… when git fails I always have to navigate to the end of this buffer so I thought it would not auto-scroll. I should have tried earlier. Thanks!


I was pretty skeptical about magit at first because I know all the basic git commands for my daily workflows by heart and I don't find them to be very difficult or slow to use. But since I am also an Emacs user and everybody kept telling me to try it out I finally forced myself to use it. And I must say it is very easy to pickup and use productively. It is way better than most of the git integration features you get with your typical IDE (like VScode for example) because magit supports most git workflows pretty seamlessly. It integrates itself nicely in Emacs' keyboard driven UI. So now I don't need to drop to a shell anymore to interact with git.

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.


> I was pretty skeptical about magit at first because I know all the basic git commands for my daily workflows by heart and I don't find them to be very difficult or slow to use

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.


I find magit very nice for interactive rebases. The ability to instant fixup older commit is also nice.

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.


> Autocompletion is supported, but git provides this as well.

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 started using it recently. It feels more like a git app in emacs, you use it in a separate buffer from your files. The shortcuts are ergonomic (single key presses, no gymnastics with modifier keys) and mnemonics are good: s(tage), c(ommit), p(ush).


Note that magit-blame can be run from a file buffer.

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)


Seeing a co-worker use magic inspired me to try out fugitive on the vim side and I'm actually blown away. So it's excellent in more ways than one.

Also inspired me to try out Emacs but that's a longer story


Fugitive is amazing. I was once pair programming with someone, noticed a weird line in the code, used the in-line git blame, then open that whole commit, and could analyse all the changes right there in neovim.

Compared to opening up Github, or stashing and checking out via git manually, it was so much faster.


I'm surprised that I had to scroll this far down to find mention of fugitive. I haven't ever used magit but I use fugitive every single day and absolutely love it.


Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: