[Monotone-devel] Comparison of Monotone and git

[William Uther]

Hi all,

  I was looking to do a quick comparison of Monotone and git and just  
wanted to make sure I hadn't missed, misunderstood, or misrepresented,  
anything (and I know Monotone much better than I know git, so claims  
about git are probably where most of my misconceptions will lie).  I  
have these in rough order of importance, but importance is subjective,  
so the order is perforce approximate.

  I'm a little wary of bringing this up as I don't want to get into a  
huge flame-war about which is better - just list the differences.   
Let's try to stay away from value judgements.  I've also tried to  
leave out areas where the two systems are basically similar (and there  
are many as Monotone heavily influenced the design of git).

Major differences:

 * Merging:
    - Monotone uses mark-merge and 3-way text merge
      - Monotone stores more information (which files moved when)
    - git uses heuristic merging
      - Git never gets stymied by something outside its model (e.g.  
die-die-die merge)
      - This doesn't mean git can handle everything easily - it might  
just dump a mess on the user - but the user can always fix things.

 * Network speed:
    - Monotone verifies all data received over the network
    - Git doesn't automatically verify all data received

    - Git only downloads one branch (and has some support for partial  
checkouts)
    - Monotone downloads all branches in one repository (by default -  
it can also be limited to a single branch)

    - Git has a reputation for being very fast, whereas monotone has  
a reputation for being slow.  It is unclear to me if this reputation  
is derived from workspace operations like 'status', or from network  
operations, or both.  I know that monotone has improved significantly  
since it acquired its reputation, and git has slowed down as it has  
gained more features.  I haven't seen any recent benchmarks to confirm  
or deny this legend.

Other differences:

 * History rewriting:
    - Git has an easy UI for re-writing history in a local repository
      - The re-base command that allows patch sets to be cleaned up  
before submission
      - There is no reason this couldn't be done in monotone, but it  
goes against the Monotone philosophy.  You'd end up using a bunch of  
'mtn kill_rev_locally' style operations that Monotone considers  
dangerous.

 * Command structure:
    - Git has a different command structure, more focussed on the  
particular development model for Linux.
    - Git also started as a collection of orthogonal tools.  This  
means that it doesn't have a reputation for having a clean UI.  In  
practice, the high level UI for git now seems fine.

 * Signing:
   - Both Git and Monotone use crypto-hashing on each revision and on  
the history.
   - Monotone signs every revision and handles keys itself.
   - Git allows tags to be signed and uses OpenPGP for the purpose.



I have more research to do on git, but as a first pass have I missed  
anything someone considers important?  (BTW, I don't want to get into  
tiny little details here...  I mentioned "considers important" for a  
reason :) )

Cheers,

Will         :-}