Track your changes to an open-source project with git: Difference between revisions

Latest revision as of 01:14, 3 May 2012

Purpose

Here are some of the projects on which I have overlaid my code, with the help of git:

mythtv
ampache
wordpressmu (now integrated into wordpress)
recess
a proprietary project hosted privately behind an openvpn connection

All of these currently use subversion, which git can read from and write to. Some of them (read: "mythtv") are insanely active. Git can help you remain sane while you try to overlay your changes on top of a moving target.

Overview

Historically, source control always kept your code in a central location, and each developer checked out file(s) when they wanted to do modifications. Sometimes you could not get access to a file because someone else had checked it out with exclusive access.

Open-source culture has no tolerance for this. Typical source control for open-source projects does not rely on checking out files. Anyone can grab the files and modify them at any time. Then conflicts are dealt with when you want to commit your files back into the central repository. The headaches are left for when you merge changes back into the project that has completely changed from under you.

git was made to ease life within this environment. But you have to step back and adjust your way of thinking. Code flows in every direction, and every developer is her own central repository.

Implementation

I have used three approaches, in reverse chronological order:

Managed publishing of your personal git repository - this is how I currently work, publishing my code in a clean controlled way to a gitorious repo.
Work on an open-source project from anywhere - this was a popular approach for a while, using an SVN-based master repo.
Setting up your own public repo on top of an open-source project - this is a technique useful with an SVN-based master repo but probably overly complex.

@@ Line 1: / Line 1: @@
-Here are quick and easy steps to track your changes to an open-source project.
+== Purpose ==
-Once you get a handle on git, you'll find it very powerful.  But getting started can be the biggest challenge.  Distributed source control requires a different way of thinking than using a central repository.  Use this to get past the first hurdles.
+Here are some of the projects on which I have overlaid my code, with the help of git:
-== Requirements ==
+*[http://www.mythtv.org/ mythtv]
+*[http://ampache.org/ ampache]
+*[http://mu.wordpress.org/ wordpressmu] (now integrated into [http://codex.wordpress.org/Create_A_Network wordpress])
+*[http://recessframework.org/ recess]
+*a proprietary project hosted privately behind an openvpn connection
-# Before you can start making changes to a project, you should get the code and make sure you can compile and run it.
+All of these currently use subversion, which git can read from and write to.  Some of them (read: "mythtv") are insanely active.  Git can help you remain sane while you try to overlay your changes on top of a moving target.
-# The next requirement is pretty simple:
-** access to the code in the svn development branch
-** my own branch off of the svn development branch
-**ability to overlay the latest svn changes on top of changes in my branch
-Notice how simple this is - I'm not even asking to commit anything yet.  These are fundamental requirements that any developer on a non-trivial open-source project would have.  You <strong>need</strong> to do this if you are going to bang on an open-source project.
+== Overview ==
-Now let's add one more requirement.  I'm going to have this code on at least three different machines, so I need to be able to have a common repository for my changes.
+Historically, source control always kept your code in a central location, and each developer checked out file(s) when they wanted to do modifications.  Sometimes you could not get access to a file because someone else had checked it out with exclusive access.
-<ul>
+Open-source culture has no tolerance for this.  Typical source control for open-source projects does not rely on checking out files.  Anyone can grab the files and modify them at any time.  Then conflicts are dealt with when you want to commit your files back into the central repository.  The headaches are left for when you merge changes back into the project that has completely changed from under you.
-	<li>ability to work from several locations, pushing/pulling my changes to a central repo</li>
-</ul>
-Another basic source control requirement.
+git was made to ease life within this environment.  But you have to step back and adjust your way of thinking.  Code flows in every direction, and every developer is her own central repository.
-But <strong>try</strong> to meet this set of requirements with CVS or subversion (SVN).  No longer simple.  I started looking into better ways to solve my problem, and ran into Linus Torvald's solution (git).
+== Implementation ==
-It's definitely a change to think in distributed terms when you're used to using CVS/SVN centralized repos
+I have used three approaches, in reverse chronological order:
+#[[Managed publishing of your personal git repository]] - this is how I currently work, publishing my code in a clean controlled way to a gitorious repo.
+#[[Work on an open-source project from anywhere]] - this was a popular approach for a while, using an SVN-based master repo.
+#[[Setting up your own public repo on top of an open-source project]] - this is a technique useful with an SVN-based master repo but probably overly complex.