Thursday, July 12, 2012

Call for a new open source economy model

DISCLAIMER: This post is incredibly self-serving. It only makes sense if you believe that open source is a cost-effective way of building software and if you believe my contributions to the PyPy project are beneficial to the ecosystem as a whole. If you would prefer me to go and "get a real job", you may as well stop reading here.

There is a lot of evidence that startup creation costs are plummeting. The most commonly mentioned factors are the cloud, which brings down hosting costs, Moore's law, which does the same, ubiquitous internet, platforms and open source.

Putting all the other things aside, I would like to concentrate on open source today. Not because it's the most important factor -- I don't have enough data to support that -- but because I'm an open source platform provider working on PyPy.

Open source is cost-efficient. As Alex points out, PyPy is operating on a fraction of the funds and manpower that Google is putting into V8 or Mozilla into {Trace,Jaeger,Spider}Monkey, yet you can list all three projects in the same sentence without hesitation. You would call them "optimizing dynamic language VMs". The same can be said about projects like GCC.

Open source is also people - there is typically one or a handful of individuals who "maintain" the project. Those people are employed in a variety of professions. In my experience they either work on their own or for corporations (and corporate interests often take precedence over open source software), have shitty jobs (which don't actually require you to do a lot of work) or scramble along like me or Armin Rigo.

Let me step back a bit and explain what do I do for a living. I work on NumPy, which has managed to generate slightly above $40,000 in donations so far. I do consulting about optimization under PyPy. I look for other jobs and do random stuff. I think I've been relatively lucky. Considering that I live in a relatively cheap place, I can dedicate roughly half of my time to other pieces of PyPy without too much trouble. That includes stuff that noone else cares about, like performance tools, buildbot maintenance, release management, making json faster etc., etc..

Now, the main problem for me with regards to this lifestyle is that you can only gather donations for "large" and "sellable" projects. How many people would actually donate to "reviews, documentation and random small performance improvements"? The other part is that predicting what will happen in the near future is always very hard for me. Will I be able to continue contributing to PyPy or will I need to find a "real job" at some point?

I believe we can come up with a solution that both creates a reasonable economy that makes working on open source a viable job and comes with relatively low overheads. Gittip and Kickstarter are recent additions to the table and I think both fit very well into some niches, although not particularly the one I'm talking about.

I might not have the solution, but I do have a few postulates about such an economical model:

  • It cannot be project-based (like kickstarter), in my opinion, it's much more efficient just to tell individuals "do what you want". In other words -- no strings attached. It would be quite a lot of admin to deliver each simple feature as a kickstarter project. This can be more in the shades of gray "do stuff on PyPy" is for example a possible project that's vague enough to make sense.
  • It must be democratic -- I don't think a government agency or any sort of intermediate panel should decide.
  • It should be possible for both corporations and individuals to donate. This is probably the major shortcoming of Gittip.
  • There should be a cap, so we don't end up with a Hollywood-ish system where the privileged few make lots of money while everyone is struggling. Personally, I would like to have a cap even before we achieve this sort of amount, at (say) 2/3 of what you could earn at a large company.
  • It might sound silly, but there can't be a requirement that a receipent must reside in the U.S. It might sound selfish, but this completely rules out Kickstarter for me.

The problem is that I don't really have any good solution -- can we make startups donate 5% of their future exit to fund individuals who work on open source with no strings attached? I heavily doubt it. Can we make VCs fund such work? The potential benefits are far beyond their event horizon, I fear. Can we make individuals donate enough money? I doubt it, but I would love to be proven wrong.

Yours, leaving more questions than answers,


  1. this comic strip from today sounds very appropriate to the first part of the post:

  2. I know this doesn't address your core concerns but could the Software Freedom Conservancy handle the money from Kickstarter to make it a viable option for you?

    I think there is a need for developers to set specific goals and intentions. Giving money to "developing pypy" is nebulous and hard for me to support. Managing releases; supporting the user community through bug triaging, IRC, mailing lists, etc; increasing performance of the parser, JIT, GC, GIL, etc; getting 3rd party libraries (Numpy, Django, database clients, etc) working on pypy; these are all goals I'd happily support. They all fall under "developing pypy" but give me a much better idea of what I'm actually funding.

    You could kind of convert those goals into Kickstarter projects, but that's a ton of overhead per "project" and maps poorly. Hopefully there's a better way like you outline that reduces the overhead of funding while still allowing funders visibility and confidence in what/who they're funding.

  3. With regards to open source and money, you might be interested in reading about fairware, an experiment (still ongoing) I started nearly two years ago:

    It is project-based (well, not as in task based, but rather "product-based"), so it doesn't work with your postulates, but I'm thinking you might rule out project-based systems too fast. Of course, it might be very hard to get people to directly contribute to an eventual fairware PyPy, but what if end user projects using PyPy would pledge, let's say, 3% of their contributions towards the paying off timelogs in the PyPy project? Then it could work.

  4. You raise good questions, and I have not yet seen any easy answers.

    It seems to me that you are asking for a peer-based "sponsorship" site. This sounds reasonable in principle, but the devils are all in the details. I think Gittip and Kickstarter have chosen the models they did because of the nature of the problem. If people contributing money have no expectation of receiving concrete, useful work product, then it's just a tipping site like Gittip. If people contributing money receive some assurances of useful deliverables, then someone has to do the evaluation of whether or not payment should be released. This then makes it very "project-based", like Kickstarter.

    "in my opinion, it's much more efficient just to tell individuals "do what you want". In other words -- no strings attached."

    While I don't know that I would say it's more "efficient", I do think that one is more likely to obtain superior results by giving people the freedom to explore and solve a problem in their own way.

    However, there are very, very few people in the world that will give up their money to others just to let those other people "explore" and "play". Historically, artistic patronage was really reserved for the very wealthy and the very artistically talented. Because I think software is a craft, I think it *can* in fact be funded via a patronage model. However, the bottom line is that the patrons have to be able to enjoy the fruits of artist's labor. In your case, since you are building low-level, developer-facing tools, it's unlikely that you will find an individual sponsor who will support open exploration. (Contrast this with, say, someone who does digital art or is making a cool indie game.)

    Which means you have to look at businesses and organizations for sponsorship of your type of technical projects. In these cases, the people giving the money almost always have to be accountable for how that money is spent. You are unlikely to find sponsorship of open-ended exploration, unless the organization is both very small and very well-capitalized.

    The only effective approach I've seen is to essentially be your own sponsor. Do the consulting, product dev, or whatnot to raise funds for concrete work for paying customers, then use that money to fund your own explorations. On the basis on those explorations, build the next set of products or tools with which you can then bootstrap the next cycle.

    "Now, the main problem for me with regards to this lifestyle is that you can only gather donations for "large" and "sellable" projects."

    The core issue is that you have to balance your own technical interests vs. how others value your time and expertise. While some open-source hackers have managed to avoid or "opt out" of the need to answer this question, most end up in one of a limited set of stable equilibrium positions, especially as they get older and have more financial obligations.

    To be completely honest, there is nothing in your list of requirements that fundamentally precludes a product-based approach. You just have to be more creative with the pricing and licensing. For instance, you can create ransom-ware, which is proprietary or dual-licensed until some fixed amount of monies have been raised, at which point it gets re-released as LGPL/MIT. You can do temporal licensed things which charge a premium or dual-licenses the latest version, and releases the previous version for free. Etc.

    (Then there are also more traditional OSS approaches of "support-ware" which charges for support and bugfixes, or "consultant-ware" which is stuff that looks pretty useful, but ultimately funnels users into need to engage your consulting business in order to employ your project at larger scale. These two, I think, are less optimal than the first two I mentioned, because they mis-align the incentives of the users and developers.)

  5. Good points Peter.

    My point is that typically I ask people who *already benefit* from my software, so they have a vested interest in ongoing maintenance or more new stuff. Open Source is very much reputation based, so being able to attract donations (also from companies), is mostly based on the stuff what I've already done not what I promise.

  6. I think open source has a lot to learn from commercial endeavors. There are no rules and there is nothing stopping a marketing and sales-savvy development team from cashing in. Throwing up yet-another-post on HN is a good start, but you need a sales funnel. You also prob need $10k to get there.

  7. I keep thinking that we should have an App Store for open source software.

  8. There are many startups and other organizations willing to sponsor open source work, but how is the money going to get from them to you? How are they going to find you or the projects you work on among the thousands of packages they use? They could go for easy targets like Python/PSF or Debian/SPI, but those organizations usually don't sponsor development, only infrastructure, meetings, sprints, conferences, etc. There are social and legal reasons for that. Once you start paying developers, there is a serious risk to cause disputes within the project and to alienate fringe contributors. And then if you pay developers, you might lose your non-profit status, you have to pay taxes and insurance and all that.

    You say you don't want government involved, but I think things could move that way. Many functions that grew out of volunteer-driven efforts, such as social services and welfare, are being taken over by the government to some degree. I also know people who get sponsorship for non-mainstream open source development from some fairly broad government programs, so maybe it's something to look into more.