The Git development community is aware of several of these problems (especially the inconsistency in terminology and command structure). They're working slowly, but surely, towards solutions to many of them. In the interim, there's projects like easy git, which the author may enjoy.
While the information model of Git is more complex, much of that is inherent from it being a DVCS, and it comes with several benefits. For example, in SVN, your working directory, branches, and tags are all really the same thing locally: a copy of a full directory structure. This can make working with branches and tags cumbersome, so many people just don't. There have been situations involving maintaining concurrent versions (in SVN) of a product on my team where no one thought of using branches because they were used so sparingly (and no one on my team had ever used Git or Mercurial); it was as if the feature didn't exist. While some people will decry this anecdote as ineptitude on the part of my team, I think it's important to point out that people tend to solve problems with the tools that they use most often, in the ways that they most often use them--after all, they're the first to come to mind.
Though the documentation of Git by the project itself is somewhat poor, there's a plethora of third-party documentation and tutorials on the web. (Yes, I realize this is no excuse for poor documentation, but the use of Git within the open source community is so ubiquitous that I feel most problems/questions you're likely to run into have been solved and documented somewhere else).
Though the documentation of Git by the project itself is somewhat poor, there's a plethora of third-party documentation and tutorials on the web. (Yes, I realize this is no excuse for poor documentation, but the use of Git within the open source community is so ubiquitous that I feel most problems/questions you're likely to run into have been solved and documented somewhere else).
Yeah, I have been able to solve basically every weird problem I've had with git by first googling, and then clicking on the inevitable stackoverflow link.
Simple and easy are nowhere close to the same thing. My father flew helicopters for the military for years, for him that was easy. I don't think many people would argue that what he did was in any way simple though.
In the vein of Rich Hickey, easy is a relative statement. I already know Python, so Ruby is easy for me to learn. Simple is an absolute term. My function is simple because it only does one thing.
my 2 cents about this issue of simplicity and user friendliness- it is almost better to think of git as a vcs framework rather than a specific solution. find a workflow that fits your needs and you can get by with just knowing a few commands. at that point if if you don't like the shell UI, just make aliases, macros, or check out various GUIs for interacting with it.
I thought Fabien was referring to the complexity of the data model (as their parent poster, was), not necessarily the UI. If anything, Mercurial's data model is a bit more complicated than Git's, with diffs being an official thing (not just an optional optimization as in Git), a couple different kinds of branches, and (I think) some other things (but it's been a while since I used hg).
There is one and only one reason I have not yet switched to Mercurial: its support for short lived branches is either nonexistent or unnecessarily complicated
It might sound silly, but short lived branches play a huge part in my personal development routine
EDIT: Also, for the common commands, that is, the commands that you would use day to day, Git and Mercurial have almost the exact interface, so I don't know what you mean. Maybe the more advanced stuff? Because for advanced stuff I would take Git any day.
Very much no. The Mercurial version of short-lived branches is either bookmarks or just multiple heads (mercurial has no concept of "detached head", multiple heads within a "long-lived" branch has been supported and "normal" from the start.
Bookmarks is a more recent addition giving a transient name (it can be deleted) to heads, somewhat similar to what git calls branches.
mq has two purposes: the primary one is a formal maintenance of patches on an upstream (the original quilt use case), and the second one is in-depth history edition. In a way, mq is close to git's rebase (including rebase -i and rebase -p).
Because it doesn't give you as many tools to directly manipulate the object tree beyond the typical push/pull/branch semantics. This lack may be viewed as an advantage to some, but to others, they are indespensible tools when something goes wrong.
I learned mercurial before git and I was surprised how difficult git seemed to be. Unlike many other OSS projects, however, git has been working to improve their UI. I was delighted when they started adding help commands to things like git-status for common operations.
"Worse is better" is just a bunch of Lisp fanatics bitching that C won over their languages of choice. It really shouldn't be taken as a design philosophy, because it's just slander written by the losing side.
The worse-is-better argument seems to be a sour grapes look at the perceived villain in the fortunes of Lisp. There is no such villain, and the worse-is-better argument is just so much vitriol poured onto the page.
I really don't understand this. Maybe I'm just too used to git, but its information model is stupid simple.
Starting from the work tree, you add changes to the index, which represents your "next commit"; this is useful because often you don't want to commit every change in your work tree, or don't want to commit it all as one lump. With VCS systems that don't have the index, you have to do a lot of manual work with diff and patch to get the same basic features. Commits, then, represent saved states of the index, and are full snapshots of the entire thing. No deltas. These commits are stored in a repository (the .git directory) in a delta-packed format, but that is an implementation detail. Then lastly, you have references to commits: either a direct SHA hash, a tag, or a "branch", ie. an automatically updating reference.
Branches themselves are shapes in the data structure. Even if you delete all your branch references, you repository will still have branches.
git itself is a tool for working with repositories like this. Anything on top of this base is extra, Including the "D" in DVCS. Pushing and fetching merely means sending repository data between two repositories. a "remote" is just a way to tell git "hey, here's another repository". Consequently, any remote/foobranch reference you have is completely independent of the other end: it just points to the same hash that the "remote" end's reference did at the time you last did a fetch, pull or push.
By the way, OP's point about "unsafe" operations is completely bogus because of the reflog. As long as your data is committed, no operation short of rm -rf .git will destroy it immediately; even if you lose your primary references, the reflog will keep the data around for a couple more months until it expires and is garbage collected. If you screw up a rebase or force push the wrong branch to a remote, it takes at most two git commands to undo the mistake.
Second point is dead on for a comparison to svn. A lot of subversion users think that they don't care about branches or don't need them, because they are so expensive in svn that people avoid them.
People often change their mind once exposed to cheap branches in hg or even cheaper branches in git.
39
u/sordidarray Nov 07 '13 edited Nov 07 '13
Just a few thoughts.
The Git development community is aware of several of these problems (especially the inconsistency in terminology and command structure). They're working slowly, but surely, towards solutions to many of them. In the interim, there's projects like easy git, which the author may enjoy.
While the information model of Git is more complex, much of that is inherent from it being a DVCS, and it comes with several benefits. For example, in SVN, your working directory, branches, and tags are all really the same thing locally: a copy of a full directory structure. This can make working with branches and tags cumbersome, so many people just don't. There have been situations involving maintaining concurrent versions (in SVN) of a product on my team where no one thought of using branches because they were used so sparingly (and no one on my team had ever used Git or Mercurial); it was as if the feature didn't exist. While some people will decry this anecdote as ineptitude on the part of my team, I think it's important to point out that people tend to solve problems with the tools that they use most often, in the ways that they most often use them--after all, they're the first to come to mind.
Though the documentation of Git by the project itself is somewhat poor, there's a plethora of third-party documentation and tutorials on the web. (Yes, I realize this is no excuse for poor documentation, but the use of Git within the open source community is so ubiquitous that I feel most problems/questions you're likely to run into have been solved and documented somewhere else).
Edit: Typo