What does "branching is free" mean in Git?
I hear this a lot whenever Git is mentioned in comparison to other version control systems.
I haven't had the opportunity (?) to deal with others (SVN, etc.), so how is branching "expensive" in others?
The claim that "branching is free in git" is a simplification of facts because it isn't "free" per se. Looking under the hood a more correct claim would be to say that branching is redonkulously cheap instead, because branches are basically references to commits. I define "cheapness" here as the less overhead the cheaper.
Lets dig in to why Git is so "cheap" by examining what kinds of overhead it has:
How are branches implemented in git?
The git repository,
That's basically it, a couple of text files are created. If you open the reference as a textfile the contents will be the id-sha of the commit the branch is pointing at. Note that branching does not require you to make any commits as they're another kind of object. Both branches and commits are "first-class citizens" in git and one way is to think about the branch-to-commit relationship as an aggregation rather than a composition. If you remove a branch, the commits will still exist as "dangling". If you accidentally removed a branch you can always try to find the commit with
So how does git keep track of which branch you're working on? The answer is with the
Switching branches simply changes the reference in the
How does this compare in other version control systems?
In Subversion, branches are virtual directories in the repository. So the easiest way to branch is to do it remotely, with a one-liner
You will want to do this action remotely on the server, because making that copy locally is a linear-time operation, with files being copied and symlinked. This is a very slow operation, whereas doing it on the server is a constant time operation. Note that even when performing the branch on the sever, subversion requires a commit when branching while git does not, which is a key difference. That is one kind of overhead that makes SVN marginally less cheap than Git.
The command for switching branches in SVN, i.e.
SVN's branching comes with a cost as it copies files and always need to be made publicly available. In git, as explained above, branches are "just references" and can be kept in your local repository and be published to your discretion. In my experience however SVN is still remarkably cheaper and more performant than e.g. ClearCase.
It's only a bummer that SVN is not decentralized. You can have multiple repositories as mirrored to some source repo but synching differing changes multiple SVN-repositories is not possible as SVN does not have uniquely identifiers for commits (git has hashed identifiers that are based on the contents of the commit). The reason why I personally started using git over SVN though is because initiating a repository is remarkably easier and cheaper in git. Conceptually in terms of software configuration management, each divergent copy of a project (clone, fork, workspace or whatever) is a "branch", and given this terminology creating a new copy in SVN is not as cheap as Git, where the latter has branches "built-in".
As another example, in Mercurial, branching started out a bit different as a DVCS and creating/destroying named branches required seperate commits. Mercurial developers implemented later in development bookmarks to mimic git's same branching model though
The real cost of a branch is merging it. Git makes this easier than some other source control systems. See Stack Overflow question How and/or why is merging in Git better than in SVN?.
In Git, a branch is just reference to a commit to the local repo. Creating it is very cheap, no network at all. Not quite free (you've got to type a command), but damn near.
Branching isn't particularly expensive in SVN - it's just a copy, which is a very cheap commit. SVN does have a central repository model, so it's a network access, but not a horrible one.
In the venerable CVS, on the other hand, branching is VERY expensive. Basically, CVS branches involve adding a tag, but in CVS that means that EVERY FILE AFFECTED has to be modified. Each file is re-written to include the new tag. That's horribly expensive. And if your repository is big, it's also horribly slow. In fact, if you're on a big project, it's slow enough that some folks tend to avoid making branches if they can.
SVN's branching is as free as Git's. It's just a bit of housekeeping data that says where the branch starts, no changes to the stored files whatsoever. A 'copy' in SVN is like adding a symlink to a Unix directory. Note that the SVN branch will not require a network trip until you commit your working copy changes (but there's not much point having a SCM if you don't commit off-local at some point).
Note that a Git branch will also involve some housekeeping - like adding that tag internally - that will have to be stored somewhere when you commit. It's not a big deal at all, which is why it's called 'free'.
It is 'free' (in this context 'free' really means quick and easy and not taking up space) because in some older version control systems a branch was a complete copy of the code at that point, so branches took up a lot of space and it was easy to end up with a lot of different completely full versions of the software lying around, which then took management. In others it wasn't a complete copy of the code but every file still needed to be modified for a tag so was slow and painful ('costly').
git's branches are essentially labels pointing at a commit and thus avoid the above issues.
Another aspect of "free / cheap / expensive" is to do with how much is costs in terms of developer resources to deal with the downstream consequences of branching; i.e. the process of merging changes from branches.
And here, merging branches in DVCS systems like Git and Mercurial is easier than in older systems ... because the DVCS systems do a much better job of tracking the history of the versions in the graph; i.e. where previous branching an merging has occured. This makes merges more accurate, reduces unnecessary conflicts and ... makes merging subjectively "easier" or "less scary" for the developers involved.