Introducing a simpler, faster GitHub for Mac (github.com)

Since it was just released, I doubt many outside of github have an established workflow with this.

Maybe someone with the Windows client can provide more insight, given the similarities.

I don't, but I do know that at my last job the documentation team started using it to bring writers into version control. It allowed a lot of them to grok what was happening without being scared of the command line.

I use it. My work git repo isn't github, so switching between this tool for github and cmd line for work has become part of my habit field. I still go back to cmd line for more complex stuff though.

(Biased, I work at GitHub and helped design the original GHfM)

I use it every day, almost all of the time. I don't use a lot of it, but what I do use is tremendously useful. My workflow is usually:

1. Navigate to the folder in terminal (old habit, or starting servers) and type in `github .` which launches the client for this repo.

2. Sync to pull in new changes (cmd + s)

3. Create a new branch (cmd + b)

4. Commit as I code (visual diff helps me do light code review on the spot). This is definitely the core usage for me — seeing what uncommitted changes I have, selecting out partial commits, drafting up good commit messages, amending bad commits, etc.

5. When I'm ready to publish my branch, sync again (cmd + s)

The key for me really comes down to some really simple stuff: a visual editor for creating commits, and quick keyboard commands to common actions (branching, switching branches, push/pull). It's possible to do fast in terminal, but muscle memory serves me personally much better with real keyboard commands.

  cd /your/src/dir
  git pull

  <edit stuff>

  git diff

  <look at stuff; possibly edit more stuff>

  git commit -m "edited stuff"
 
  <oops...forgot something; edit another file>

  git commit -a --amend
  git push origin
  

  git checkout -b new_branch
  <edit edit edit>
  git commit -a -m "i'll merge this branch"
  git checkout master
  git merge new_branch

  git checkout -b new_branch
  <edit edit edit>
  git commit -a -m "did stuff that i'll rebase this time"
  git fetch
  git rebase origin/master
  git checkout master
  git merge new_branch

  git checkout -b new_branch
  <edit foo.txt and bar.txt>
  git add foo.txt
  git commit -m "edited foo"
  git stash
  ...
  

    cd /yor/src/dir
    bash: cd: /yor/src/dir: No such file or directory

    <edit stuff>

    git diff

    git comit -m "edited stuff"
    Did you mean this? git: 'comit' is not a git command. See 'git --help'.

I use this but I use it primarily as a diff'ing tool. It's very convenient for that and is also handy on the occasions I'm working on something and then look and realize I have several commits worth of uncommitted changes. Where the UI excels for this is easily just unchecking a couple files or highlighting a few lines from one file to commit only exactly what I want to and then quickly re-checking and committing the rest. This doesn't happen all that much but when it does it's great having a tool that makes it easy to deal with.

Other then that I just find the command line to be quicker for most things.

I've used the Windows version... When it isn't crashing it's extremely laggy.

Mind you I am working on repos in the several hundred mb size or at least double digit mb.

The mac version seems to be similar issues, for example if I look at a commit with more like then 150 file changes it pretty much either lags to the point where I force quit or crashes.

Maybe it's just me, but the command line still works better for me.

This is one of around 4 or 5 applications that I have open 100% of the time on my Mac. I still use the command line for some things, but for the most part I've saved massive amounts of time (and prevented a lot of bugs thanks to the visual code diff view) thanks to GitHub for Mac.

The GUI has dramatically increased the rate of contributions for web, content, and design work from our non-hardcore devs. I also use it when I want something really low friction.

I used to use it just for the ability to individually stage chunks/lines, because I find "git add -p" incredibly hard to use. Now I tend to use GitX-dev for OSX [1] to do that instead, because I find it more powerful than Github for Mac. There's also a ncurses-based interface for git called tig [2] which can also do the chunk staging, but I only use it when I don't have a GUI.

[1] http://rowanj.github.io/gitx/ [2] http://jonas.nitro.dk/tig/

I use this. It's actually a nice client even for non-github repos.

I use it occasionally, even though magit has largely taken its place. In part, I like the way it ships the command-line git program: inside its .app bundle. Very clean and convenient if you don't fell like pulling in Homebrew or polluting /usr/local. Many other graphical Git clients are not hygienic in this way (i.e., they pollute areas of the filesystem outside their .app bundles).

I've seen designers on a team use it.

I don't use this, but have used GitHub for Windows. I can see it being useful for those less technically inclined, or 'afraid' of the command line.

Personally, I don't have an issue with using the command line for Git, but I get by just fine with SourceTree.

It's helpful in visualising Git concepts with its tree graph, and I don't have to remember commands. I also realise this goes counter to the command-line culture of HN :)

I use this every day basically for pushing and pulling to and from Github. For pretty much every other git function I use SourceTree.

I find the Github app too limiting for most git functions other than pushing and pulling (and the resulting rebase or merge) to the remote repositories, but the interface is much much better – simpler, quicker and easier – for those specific tasks than SourceTree.

This is the only reason I have installed the app. Patiently waiting for a good desktop notifications system. I'm on far too many projects at any time, some high volume open source, and I really would like notifications built in. Currently giving The Hub App a spin.

http://thehubapp.com

I just tried it out and found that it can work with repositories that are hosted elsewhere, but I haven't yet found a way to clone a new local repo from a non-github remote repo.

If it's anything like Github for Windows, then yes, you can, but it's not exactly intuitive. Here's a stackoverflow post which should cover all the basics, and a bit more.

[0] http://stackoverflow.com/questions/13664949/use-github-for-w...

However, overall, the application is pretty basic (assuming it's just like the Github for Windows client, plus the new features announced). It has a nice diff viewer, and can push/pull. But that's about it. The interface is beautiful, and the Mac app seems to look just as good. But any other advanced git features, you'll need to do through the command line.

I wonder why are there no good git GUIs that offer git's full feature set? I guess it's a harder problem than it seems. Or maybe just every dev who uses git's advanced features would just prefer to use the command line anyways.

You could try loading the assemblies up in dotPeek and poking around. You miss out on the XAML (though you'll see the code the XAML was transformed into), the compiler generated stuff for await is a little ugly, and obviously you wouldn't be able to re-use any of the code you see, but if you're just curious...