The uproar between @dhh and @ryanbigg on twitter the other day go me thinking.

Where should open-source projects start and end? Or rather, to what extent should developers make, and to what extent should users make, on making the project more sustainable? Is there even a recipe for sustainable open-source projects? If so, what is it? As that recipe surely could have quite the impact on the way we all do things.

Having made a fair few open-source projects myself, I know that open-source is a challenge. So lets break down the complex issue of open-source into more digestable sections. Yummy.

Creation

Open-Source projects seem to be created in three ways:

1. To scratch an itch for intrinsic value
2. To scratch an itch for extrinsic value
3. As a generic component in a closed-sourced system. Generally the closed source system is one built for extrinsic value.

To the uninitiated, intrinsic value is when you draw enjoyment from the task itself, and extrinsic value is when your draw motivation from an external factor. Generally the way society goes about this today is to do something of extrinsic value that we don't enjoy but earns us enough money so we can do the thing of intrinisic value that we do enjoy but doesn't earn any money. The ideal environment is to have the same thing provide both intrinsic and extrinsic value*.

Maintenance

Open-Source projects seem to maintained in three ways:

1. For intrinsic value
2. For extrinsic value
3. As a side effect of another project that meets either 1 or 2

To be a successful and self-sustainable open-source project, you gotta hit all three aspects. Successful in regards to a growing ecosystem, and self-sustainable in regards to able to be maintained long-term. Hitting any less than all three aspects, will raise the following issues:

Just 1 will mean your involvement is limited to how much spare time you have available - I use "spare time" here as you will still have to perform other work to pay the bills. This appears to be the biggest killer of individual open-source projects.

Just 2 will mean your involvement is limited to how long you are being paid to do it - which can end when the project no longer becomes useful to a client, or you move onto a different project that provides better extrinsic incentives. This appears to be the biggest killer of startups.

Just 3 will mean your involvement is limited for however long the parent project is useful, or until the parent project doesn't need the open-source sub-project anymore. This appears to be the biggest killer of company open-source projects.

Now a combination of 1 and 2 may have seemed feasible at first, however unless the project has point 3 as well then the project is limited to its own eco-system and does not benefit from the eco-systems of the projects people create with it.

Only a combination of all 3 provides the magic formula for a successful and self-sustainable open-source project. You need people that are motivated to work on it (often for free) for the simple reason of believing in it (these are the early adopters, newbies, advocates, and evangelists). You need people that are able to be paid to work on it so they can be involved with it full time and provide dedicated support and maintenance that the project needs (these are the core team that handle development, marketing, sales, support, etc). And finally, you need people that are able to use your open-source project to create their own projects that add their own value (these are the 3rd party providers, extenders, and clients - with them the open-source project will always be relevant as long as their is a parent project still using it - they are also important as they can finance point 2 if their own project becomes successful).

Expectations

However, it seems that most people's expectations do not fit this grid. It seems that the typical expectations for open-source projects are:

1. Release as much as possible as open-source, even if it means creating unsustainable projects or even working against other players for personal gain (and in the grand scheme of things, its a lesser gain than what would be accomplish if people worked together)
2. If I disagree with the way you did or do things, I'll do my own project my way, rather than understand why you did things the way you did
3. If I want support for your open-source project, I expect it from you as you created it anyway
4. I do not want to pay for support, as that should be free in my opinion
5. If I see an unmaintained project, then it failed, haha, and I should do my own from scratch rather than picking it up

Which are all detrimental to the survival of an open-source project. Open-source projects need collaboration and sharing, they need understanding and appreciation, they need financial support, and most importantly they need an sustainable and gowable eco-system.

So how can we fix this?

Honestly, I don't know. That's why I'm writing this.

There's a few things that I've identified that help:

1. Providing great documentation and resources to empower your users to not only help themselves but also to help you and the project too - otherwise you're time will be caught up explaining things, rather than growing things
2. Working together with people (even opponents) to come up with a better solution and eco system
3. Being very clear on the support channels people can utilise and what their expectations should be in regards to support and why they should have those expectation

However, for projects that hit intrinsic value as well as parent-project value - which is probably the majority of open-source projects created by an individual in their spare time, and is actually useful) - then hittig the financial support target to make it full time is incredibly illusive. Illusive as people don't like paying for support, developers are often not the ones in the position to make the financial calls, and charging for support can be counter-intuitive when your goal is to improve documentation so people can help themselves.

So I'm turning to the community to get a discussion going. What needs to happen in order for us to start creating more sustainable open-source projects? Or rather, if there were a recipe for creating a sustainable open-source project, what is it? Lets get cracking and solve this issue for good! It's time.