For a long time, we've been talking about migrating from Subversion to
Git. It's time to start getting more serious about it.
First: the need to do this. There is pretty broad acceptance that we
should move to a distributed version control system (DVCS). Our
current Subversion-based version control system has served us well,
but we're in need of a more suitable version control system for our
development effort. Our community is very distributed, with many
parallel efforts and needs to integrate many different feature
efforts. While we've developed lots of coping mechanisms, we sure
could use a system that's well suited to more fluid branching and
There has been resistance to this in the past, and there still may be
some resistance. However, I think we've worn everyone down. :)
Next: the selection of Git over other DVCSs. Over the past couple of
years, other systems have been mentioned (Bzr, Hg), but there hasn't
been any evidence (at least on this mailing list) for anything other
than mild support for the alternatives. As you might have seen, our
Ops folks have already moved to Git, and while they're right in the
middle of the tough part of the learning curve, they seem to be
adjusting just fine. The complaints seem to be of the "I really need
to get used to that" variety rather than the "why are we doing this
again?" variety. So, given the momentum that Git has, the ample
discussion we've had on the subject, and the fact that Ops is already
planning to support Git, this seems to be a settled question.
So now, the questions shift from "if?" to "when?" and
When? After some amount of arm twisting by Erik and Brion (*hugz*),
I've agreed to float a plan that has us making the migration by the
end of the year. This is completely contingent on our ability to get
1.19 deployed in a rapid fashion (which, if we can get through the
code review queue at our current rate, could be done in November).
Until we have a more fleshed out plan, though, "end of the year"
purely a guess, and subject to change (partly based on any ensuing
conversation after this mail). However, assuming we can clear the
technical hurdles, there's not any procedural issues I can see getting
in the way of a rapid transition.
How? Lots of unsorted pieces. There are still decisions we need to make:
* Code review tool: barring unforeseen complications, we're planning
to use Gerrit. We need to make sure it'll be a suitable replacement
for our existing tool
* How do we break up the repository? One big repo? Extensions each
get their own? We need to sort all of that out.
A draft plan is available here:
 ...or so I've read on Slashdot, so it must be true: