[harpastum]

I think it's very possible that these pretty wrappers allow people to hobble along with little to no understanding of how git actually works.

If that's the only way that you'll use version control, it's better than nothing. On the other hand, I heartily endorse actually learning how the git model works -- it's not too bad, I promise!

.

Good places to start:

  [1] Peepcode's "Git Internals" PDF - $9 - short, sweet, to the point
  [2] The Git Community Book [2] - free - thorough (if a bit wordy sometimes)
  [3] Pro Git - free online, $23 dead trees - Haven't read it, same author as [1]

[1] http://peepcode.com/products/git-internals-pdf

[2] http://book.git-scm.com/

[3] http://progit.org/book/

[mechanical_fish]

Do not underestimate the potential usefulness of a git utility that lets people do a couple of basic operations on a git repo while teaching them nothing. I know lots and lots of people who have no desire to learn version control but who need to interact with a VCS.

But I think I understand where you're coming from. My take is that all of these supposedly-simpler interfaces are nowhere near radical enough. If you try to make git easier by deleting half the feature set you end up with Emasculated Git. It's still obviously git, but it isn't git, so (e.g.) you ask your friend how to use git and they tell you ten things, half of which you can't do because the tool doesn't support them. Or you consult a git book and it seems both familiar and unfamiliar.

What I wish someone would try is designing a tool that has, say, 5% of Git's features, and a different name, but uses Git's protocols to interact with Git repos. The user presses a button to download a project from a URL. They tinker. Occasionally they press a button which saves a milestone copy of their directory tree. They can optionally give milestones names. With another button, they can send their milestones to a server in the cloud. They can also browse the cloud looking for other people's milestones and fetch those. They can see the diffs between two milestones. And there probably needs to be a tool to help merge a set of changes into a directory, which can then be saved as yet another milestone.

Think: "what would Git look like if Apple designed it?" The result is probably not a tool that a hacker would use directly. But I would hand it to all my non-hacker colleagues in the hope of capturing their work in a repo which I could then pull, sort out, and merge into the main tree. And it would let them browse the history and pull stuff out of it without having to bother someone like me.

[aaronblohowiak]

In the Git community they call this an "alternative porcelain".

For subversion, changesapp or cornerstone might appeal to you.

DVCS has high intrinsic complexity, though i agree that simplifying assumptions could reduce git's apparent complexity

[wolfish]

I find that committing parts of a file in GitX is much easier than using interactive mode in the terminal. That's not a question of understanding the git model, it's just choosing the best tool for the job.

[uxp]

I completely agree. For many tasks the command line sequence of add, commit, push may be sufficient, but sometimes I don't care to wade through my editor merging and selecting portions of diffs to commit. The GitX interface is much more usable in that instance.

[p3ll0n]

If you want to learn git, open a terminal and read the man pages, create a dummy repository, push changes to it, pull from it, clone it, merge it, etc. Don't start with something like Gitbox because its hides all the details and more importantly the beauty and elegance of git.

[viraptor]

I think that's the point of the project - to hide the details. I'm a developer of project X, but a user of git. I don't care about it - I want to see it as little as possible, because it's just another tool. Whether it's beautiful or not, I've got a work to do.

It's a bit like with the compiler: it can be pretty and all, but ultimately I just want to write `make` and get my binary. When I need the details, I know where to find them.

[schacon]

I would argue that your SCM tool should be less like a compiler that just needs to get out of your way and just do it's job how you expect it and more like a text editor. Do you use emacs or vim, which have learning curves but are powerful and help you ultimately do your job much better and more efficiently? Or do you use Notepad, which just edits text and who cares? I think most developers prefer Emacs or Vim or even an IDE. You invest time in a more complex tool so that you can be a better developer.

That being said, I think this will be useful for a lot of less-techy designers or copy-editors or QA people, etc. People who can just open stuff in Notepad because they don't need to craft code.

[sh1mmer]

I think the argument here is that

a) basic Git isn't that complex b) Learning a dumbed down subset of Git won't help you long term

I would say that giving people a gentle introduction to stuff is great, but it's important to make sure that it is a launch-pad for really learning the tool properly in the future.

[dagw]

I can see this being useful where you have lots of developers, most of whom simply need to get stuff done and don't particularly care about the beauty of git. You have your local git expert who can do the hard stuff and fix all the problems, and everybody else uses gitbox.

[p3ll0n]

Don't get me wrong Gitbox (and similar 'pretty wrappers') have their place just not as a learning tool.

My rule of thumb for 'mission critical software' like version control systems - if you can't access its fully functionality at the shell when logged in to a remote machine then forget about it.

Gitbox is great for your workflow until the day you have to actually use git and you have no time to 'actually' learn git.

[rfugger]

Seems to me like the perfect time to learn git is when you need to use it.

[eru]

You should prefer Darcs then. It's written in a lazy language that does everything at the last possible moment (if at all).

(Disclaimer: Tongue in cheek.)

[fourneau]

Yes, the point of Gitbox is to hide the details but that's not necessarily a bad thing.

I've had to teach plenty of people how to properly merge files using Git and no one has ever said "oh that makes sense". If a tool can hide the ugliness of merging conflicting files, even a little, it'll help a ton of people get used to using Git.

[nailer]

So rather than a tool which shows a diagram of my project with all the branches I've made, you'd rather I read a book with a diagram of someone else's project with all the changes they made?

Interfaces are interfaces. CLIs are good for some things, but bad at discoverability and limited in their communication.

[CountSessine]

Another vote or Pro Git - great book. And the last chapter where the author steps you through manually inserting objects into the git database is revelatory.

[herval]

not everyone needs to understand how git works. In a couple of projects I work on, for instance, there are webdesigners who NEVER touch code and never used any sort of VCS before (and no, they DO NOT need to learn it) - making it simpler for them to use git is a big win for everyone in the project :-)

[jerome_etienne]

just an addon, #git channel on irc.freenode.net are skilled and very helpfull.