
Forking, The Future of Open Source, and Github - jlhamilton
http://redmonk.com/sogrady/2010/04/01/github/
======
rlpb
You can't just mix and match patches automatically. Someone has to resolve
merge conflicts. There is a cost to this: developer time.

Distributed version control systems are being so successful because they allow
developers to more easily do what they have been doing all along anyway (take
Linus' job, for example).

I don't think there is a major paradigm shift here; just a revolution in
tooling. There will still always be a main line. That main line will not be
"distributed", even if the way that changesets get there might be.

Most of us will only be using releases taken from the main line. Forks will
carry on happening from time to time, but just like now most will work to
avoid them because of the inefficiencies that result.

~~~
steve19
For me it has been a revolution. No language, framework or concept has changed
my development process more in the past decade.

I have been able to contribute patches (both code and documentation) to many
projects where I otherwise would have not had the time or energy to bother
contributing.

Sure, my previous attitude may have been selfish, but if it took an hour to
fix a bug in a library that I am using for a throwaway script, I am not going
to spend another hour subscribing to mailing lists, emailing developers and
then persuading them that my patch is worth merging.

In GitHub I just fork, push my patch, and notify the owner of the original
repo. If he chooses to pull in the patch, that is his problem. If anyone else
who is having the same problem wants to use my repo, they can do so.

~~~
rlpb
I agree with you - my experience has been the same. In the past you'd have had
to work out a patch by hand and then perhaps publish it somewhere, which was a
pain to do and so didn't happen often.

Now the tools have improved making this much easier and so is happening much
more everywhere. I have personal branches of the Linux kernel and a dozen or
more libraries, _and_ can keep them up to date easily.

But the process remains the same. Your fork is no doubt invaluable to you, but
unless the original maintainer pulls your patch, your fork is likely to be a
dead end in terms of development - except perhaps for the odd person who needs
to fix the same bug and finds your patch.

My point is that the development model has not changed. The maintainer can
still optionally pull in your patch, or not. Most users will continue using
the maintainer's releases. If the maintainer drops the ball then there will be
a fork - but that would have happened in the past anyway.

Distributed version control _has_ been a revolution - but a revolution in
tooling, not of the centralised release model.

------
blasdel
About the only useful thing the Apache Software Foundation can lend your
project is their imprimatur of enterpriseyness, though that comes with a lot
of bureaucracy to back it up.

"Nobody ever got fired for buying IBM", and the ASF practically _is_ IBM!

~~~
omouse
Wow. Are you seriously complaining about that? One day someone's bitching that
open source is for commies and can't make you any money and then another
someone's complaining that the open source companies that _do_ make money are
TOO enterprisey!

~~~
olefoo
Being dissatisfied with the status quo is one of humanity's best and worst
traits.

------
njharman
"Fork" is a poor choice of verb for what I think he is describing/dvcs/github
allows. More like experimental branch this dudes gonna do his thing on and if
it's good we'll absorb it into the "main" project. Which, btw, has been going
on forever, git[hub] just makes it easier.

A Fork means there's irreconcilable differences and the dev base is splitting
into 2-3 camps, old mainline, new forkers, people who leave in disgust over
lack of coop.

~~~
JulianMorrison
Sure, it _used_ to mean that, in the days of CVS.

But a github-style fork is a fully independent project in theory, it could go
anywhere. It doesn't have to reintegrate. It might out-speed the main project
and come to replace it. It might change emphasis and shoot off on a tangent.

It's not really the same thing as having a copy of the source and making some
private changes.

