Topic: Best way to make periodic contributions to "all" significant Bitcoin developers. (Read 1302 times)

I was just about to respond to this thread about bounties for ultimate blockchain compression, but this was actually something I had been meaning to post in this thread for a while.  So I'm posting it here, because it's a more general thought about bounties and donations, etc, and it just so happens that the UBP/UBC idea is a perfect example of why I propose this:

tl;dr -- I'd like to see us move away from "traditional bounties."  Fund the developer to do the work, don't pay for a completed product.  "Completion" is too fuzzy and controversial.  Build and leverage trust, and give developers some leeway to make decision on their own without worrying about the financial security of their endeavor.

My general thought on bounties:  "completion criteria" is frequently too complicated and too controversial.  The bounty-driven idea might be reshaped, reprioritized and improved over the course of development, at which point the original criteria are no longer valid.  The question of whether the idea was actually implemented becomes controversial.  People will complain the money shouldn't be released until it's 100% done even when 95% of it is completed, and even when it's not clear exactly what should qualify as 100%.  If certain aspects of the design happen to be infeasible, but the spirit of it was still completed, does the developer get 80% of the money?  0%?  100%?

Some bounties are fairly clear-cut, because the task is relatively simple and well-defined.  A task as epic and complicated as Ultimate Blockchain Compression is going to fall into this gray area.  Parts of the idea may be found to be infeasible, major aspects of its implementation may be swapped out with something better/similar/possible in order to try to achieve results.  Additionally, for some bounties, it may be found to be completely infeasible, period.  Should the developer who spent 3 months demonstrating that it was infeasible be left with 0% of the bounty?  Strictly speaking, he still made a valuable contribution to the community (probably because he kept a thread going and collaborated with lots of smart people to try to figure out how to work around problems, and there was no reasonable path forward).  If the bounty is supposed to be released only upon completion, even users who otherwise would be satisfied with his work may have to give into others who argue that he didn't do the job, he shouldn't get the money.

So what's the solution to all this?  Not bounties (in the traditional sense).  Just like justusranvier posted on that thread, the solution is trust -- you are donating money to someone you trust to put in a reasonable amount of effort to solve your problem in reasonable time.  Someone whose judgment you trust to do the right thing, and make good decisions, which may involve changing directions of the original task for various reasons.  It would be best if a task was not held hostage to the complaints of users who don't understand the technical complexities of what is being implemented.

This works in the long-run:  developers solicit "funding" to accomplish some task that would otherwise be covered by a bounty.  There may be a threshold, or it may be part of a series of funding whereby the developer agrees to work primarily on the task that receives the most funding.  Then the developer receives the money and does his best to complete that task.  This has the added benefit of providing financial security to the developer. 

If that developer does nothing -- well then people will be pissed at him and he won't be trusted anymore.  He won't receive any further bounties/funding.  If he's untrusted  at the beginning, he wouldn't have received the money at the beginning.  Someone who has very little reputation may develop reputation by presenting evidence that he has already developed some significant portion of a task that would otherwise receive funding.  Therefore, he develops reputation by "donating" his own time to a project with no guarantee of receiving money, and people are willing to give some money to see it completed.  After that, donors can judge how much bang they got for their buck (bang for their bit?), and offer their money to someone else if they were unhappy.  

Discussion on the forums will aid in smoothing out the opinion -- those with more technical background can help inform others how challenging certain things and whether the developer is BS'ing about why things don't work.  Not everyone will be happy, but I think satisfactory equilibria can be reached.

This is not too much different than "the real world", I just got there by explaining why "traditional bounties" are not ideal for some of the things we want the most.  In the business world, companies get contracts from other companies (sponsors) to do some kind of work.  Usually something small, at first, until there is some trust built up.   The sponsor periodically receives status updates and decides whether to continue funding after the contract period is over, and/or whether to hire that company for other tasking as well.  If the company doesn't meet their needs, they go contract with someone else.

---

So in practice, how does this work?  Most importantly, the donors/contributors must be willing to give money up front.  It doesn't have to be one year's salary all at once:  perhaps the developer claims he needs $2k/month to do it and it will take 9 months.  So $6k will be raised to support him for three months.  After that, people will have the opportunity to give him more money if they like what he's doing.  If they don't give it to him, he's likely to stop developing it and work on something else.  This creates a feedback loop where people who originally wanted to see it done, will want to contribute more to see development continue (it would be a waste for all that work already done to be dropped).  Or maybe after three months it will be deemed infeasible (either by the developer himself, or by the donors), and the money will stop.

At the moment there must be trusted third parties to collect and hold the money, but only to the point that funding goals are reached.  The criteria for releasing the money is simple, and creating new bounties/campaigns is also simple.  In the future, assurance contracts can be used, at least for Kickstarter-type (all-or-nothing) funding.  

There are a few quite boring expenses that some developers incur that would be useful to be shared.
Things like monthly server costs and developer licences for Mac and Windows (so that artifacts can be signed for those platforms) all cost money and have a very obvious receipt trail.

Devs should post their goals and project and how much work it would require and how much they think they'd need in terms of funds to be able to dedicate themselves to completing that particular project.

Then an escrow could be used where the condition for the dev getting the funds would be him showing he actually did the work.

A system like that is something I think in the long run could work.

I sense that one of the more valuable things to many developers of open source solutions is to get valuable feedback and testing and such.  I don't sense that those who work on Bitcoin, or at least the important core aspects of it, are much different.  (Parenthetically, this sense...right or wrong...is probably the biggest single factor giving me hope for the solution.)

That would be a great option.  Either on blockchain contracts or a trusted third party acting as a crowdfunding platform.  People looking for specific features can start bounties and entities just looking for broad support could distribute funds widely across multiple bounties. I have a reasonable belief that there is a productivity gap much like any other economy operating at below max efficiency both capital and talent are not fully deployed because there isn't an effective mechanism to connect capital with talent outside of direct for profit ventures.

I've been thinking a bit about crowdfunding development activities, based on some conversations with the BitPay guys.  Rather than simply donating money to the active developers, you start "bounties" on various features.  Ideally it would be done with the Assurance Contracts idea -- one website or service could simply be used as a hub for collecting and making available these bounties.  Users commit non-final funds to the contract which is not valid until enough input BTC has been collected, and then it immediately pays out.  The developers of that project, and whoever else are involved then work on that feature and independently decide how to distribute the bounty.  It requires a bit of trust that the lead devs will guarantee completion of the feature once the bounty is collected, but I think the users contributing are doing so because they trust the core devs of that application to follow through and distribute the bounties fairly.  This leaves the burden of "who gets how much for how much work they did" to the discretion of the leaders, who are best suited to making that judgment, anyway.  If they do not behave themselves, the project will suffer when users dont' want to help out and users stop contributing. 

In the long run, it looks the same:  developers do development and get donations.  And users/companies get to "vote" with their money to drive the direction of development.

(FYI, users are "free" to cancel their contribution any time before the contract has matured, by simply broadcasting a tx that spends 1+ input that was used for the contribution -- the service would simply keep a running list of how many valid txouts are available, and can update it in real time -- so unlike Kickstarter, users can uncommit their funds, but the funding levels can be accurately computed and reported in real time)

But of course, no one has the software available for doing the assurance contracts, yet.  Right now, it only takes a reputable organization to manage this and essentially do the same thing until assurance contracts are accessible.  The important part is contributors see their money going to people for doing work on open-source projects.  And when there's a specific task behind it, the devs get good feedback about their own work and users feel like they are getting something tangible for their money.

At our last investor meeting the owners of Tangible Cryptography decided we would like to make regular donations to various active developers in the Bitcoin "community".  Not just the core development team but also other important projects like cgminer.

Is there any good way to do that?  Developers join, leave, and the amount of contribution changes over time.  Is there a single compiled list of active developers for not just the core team but also other major open source projects (alternative wallets, cgminer, bitcoin libraries, etc)? 

Maybe it is too early for something like this but an optimal solution would be a sort of "give back" bitcoin address run by a trusted third party which took coins donated there and split them in some community agreed upon manner (maybe evenly or maybe weighted).  Sendmany and the power of the blockchain can make the process completely transparent.  If funds are split and disbursed in realtime it reduces the risk of theft or embezzlement and provides an audit trail.  Most people are generous but they want to make sure the funds go to where they will do some good.  People give to the Red Cross because they trust the Red Cross judgement when it comes to distributing resources.

I know the Bitcoin Foundation is an option and some of our company owners are individual members.  We don't have a corporate membership because at this point the size of our company probably doesn't warrant that kind of investment (hey Bitcoin Foundation how about a small biz price point? ).  Also the Foundation providing a salary to Gavin to support full time development is a good thing but something with broader reach and transparency would be nice.