During his speech at Google "[after reviewing the alternatives] the end results was I decided I can write something better than anything out there in two weeks. And I was right"
http://www.youtube.com/watch?v=4XpnKHJAok8&feature=youtu.be&...
http://www.youtube.com/watch?v=4XpnKHJAok8&feature=youtu.be&...
I'm pretty sure the only reason git took most of the mind share instead of hg was (1) github (2) Linus admiration.
- git has an 'email' centric workflow
- The index with git (git add -i) awesome for people doing patch maintenance
- the rebase workflow is great when you want to maintain against an upstream that you expect someone other than you to commit your changes to, or you have a "pre-publish" phase.
It's almost like those reasons follow the linux workflow.. almost perfectly.
My workflow for a lot of the projects I contribute to is something like:
edit -> commit (repeat as necessary) -> rebase -i -> format-patch -> send patchset by email
Which is surprising, given how rough all the email-involving commands of git are. Badly documented (git-send-email man page doesn't even come close to documenting all options properly), awful error reporting and a badly explained (although, in itself, quite sane) workflow when sending the patches.
When setting up my email setup, I consulted the underlying Perl script more than the docs :(.
That's a good observation. Git seems to assume its distributed issue-tracker is email.
- Mercurial also has an email-centric workflow, look at its mailing list: http://mercurial.markmail.org/search/?q=#query:+page:1+mid:p...
- The staging area can be achieved in hg in several ways, or it can be avoided as desired. One easy way is to just pick apart your commit with hg (c)record --amend and just keep adding to your commit as necessary.
- Rebasing has also been available in hg forever (and wasn't available in git from the beginning). We also have some really interesting changes brewing for rebasing in Mercurial: https://www.youtube.com/watch?v=4OlDm3akbqg
These ideas in hg were all for following the Linux workflow too.
Nothing against git, but it's important to not deify Linus as if he were a unique genius. He has his flaws, and so does the software that he's responsible for.
Mercurial beat git past the starting gates, but git has the advantage of being used on a very widely used, widely developed, immensely high profile project. While Hg has its own commendable set of projects, git has simply won the mindshare battle.
Could be worse: there's arch and bzr and probably some others.
Hell, even GNU/EFF are looking to ditch their own VCS in favor of git from what I understand.
GNU Emacs decided to switch from bzr to git, but GNU as a whole doesn't have a recommended VCS yet. In GNU Octave we will keep using hg. I don't think the EFF is too public about which VCS they use.
But yes, I meant "FSF", not "EFF".
Hg eventually came around but, for me, the damage had been done. It's the second biggest reason I went with git.
(The biggest, of course, is you use git if you want to interact with kernel devs. But lots of kernel devs hated git in 2005/2006. Mercurial had a reasonably big window of opportunity... all imo, fwiw)
There's a strong aversion of using tools done in Python outside of Python community. It is irrational, but it being an inherently interpreted language puts it into the same perception bucket as Perl and who'd want to use a control system written in Perl?
If you integrate source control with issue-tracking, you start to want source code changes to correspond to issue numbers, and changes to be pushed if an issue is in a certain state or owned by a specific developer. But you can't get this information when you are offline without access to the issue-tracker.
Either there's a case for distributed issue-tracking too, which would give you that information, or issue-tracking being centralized pushes back on source control wanting to be distributed.
I wish this was addressed in Git's assumptions.
> So I've been thinking about this for basically months, but the way I work, I actually want to have a good mental picture of what I'm doing before I start prototyping. And while I had a high-level notion of what I wanted, I didn't have enough of a idea of the details to really start coding.
So two weeks seems reasonable to me, especially if he built a prototype first. (Did he?)
1: https://plus.google.com/102150693225130002912/posts/X2XVf9Q7...
This muddled language later turned into a muddled UI that was supposed to get cleaned up, but never did.
He was definitely right about that, what I like about Linus is he really does seem to prefer to do things in as concrete and simple a way as possible instead of getting mired in abstractions.