Thursday, February 16, 2012

Software Clearing Houses

I love the idea behind open source. If I’m building something that uses someone else’s work, being able to drop into their code, investigate, curse, and then work around their problem is a huge time-saver. Nothing is worse then wasting hours guessing at what weirdness lies beneath.

The problem is that this idea of ‘open’ mutated into the idea of ‘free’, and ‘free’ is not a good idea in a society that revolves around money. If you write some fabulous piece of code and give it away for free, not only do you not make money yourself, but you’ve also prevented other programmers from making money by writing something similar. Not all of us are lucky enough to get funded by other means, some of us need to pay mortgages and bills and such. We do this by getting paid to work. By writing code for a paycheck. If everything is free, we’re going to have to find some other (less agreeable) way to pay the bills.

A slightly worse problem is that as more and more stuff becomes free, more and more of the low hanging fruit disappears. What that means in reality is that it becomes harder and harder for programmers to go out on their own; to start their own companies. Instead the control of the industry shifts to the big players, who have little incentive to innovate. If you can write something small and profitable, then you get the freedom to experiment. If you can’t, then you’re stuck for life in a big sweatshop writing broken code for people who don’t get computers. I’ve definitely seen this trend in the industry over the last few decades. The really innovative works have nearly vanished and been replaced by more and more sloppy re-works of existing wheels. Not only that, but the profits come from the upper levels of software, so the lower ones get stagnant as the bugs get permanently frozen into the code-base. Thus our software looks prettier, but because of the complexity increase, is dropping in sophistication and quality. And it’s not in a big companies’ interest to change this trend. They seem to make more money with lessor quality code.

So what can we do? My first suggestion is that we should push to get more and more software into openSource. That is an easy win, transparency promotes quality and ease-of-use. But at the same time, we need to attach a price to every single piece of code out there. I don’t think home users and developers should pay, I like that they ride for free, but for big companies -- making profits from our labors --  money should definitely return to our community. Money that we can use to innovate with.

The problem is that programmers aren’t business people and few of them really want to deal with business. What they want is to build really cool stuff and leave the hassles of collecting money to other people who enjoy it. To allow this, I think we need to set up ‘software clearing houses’. Programmers would deposit their code into these organizations, and the staff there would deal with the issues of wheeling and dealing in the business arena. The clearing house could deal with licenses, accounts receivable and accounts payable. They would be the repository of the running code and of the source code. They could collect bug reports, then deal with farming them back out to the communities that built the code. Basically they’d act as a middleman between a large number of developers on one side, and a large number of companies on the other.

Many of our current licenses ask for funds when the code goes into a commercial product, but not if it is being used in-house. One reason for letting the in-house users ride for free is that not doing so would result in a huge number of little payments that would all have to be coordinated. That would be messy for an individual developer, but if a clearing house represented a significant number of projects, libraries, utilities, etc. most big companies wouldn’t have a problem paying a single reasonable yearly lump sum amount. They’re a huge number of ways of structuring this type of arrangement -- fine verses course payments, etc. -- but what is really important is that it isn’t a burden to the companies, and the money is flowing to the developers.

A significant problem with relying on many of the newer openSource libraries is support, both for bugs and for on-going rust prevention. A clearing house could provide some assurances that they will contact the developers and try to get the issues sorted out. If that is unfeasible they could also contact other unrelated developers and get the code fixed or updated that way. Once deposited in the clearing house, the code could live on well past the author’s interest. It would also be less subject to dramatic shifts in design or licensing. If enough people were interested in the preservation of a fork, the fork would find an easy means to continue.

One problem for commercial developers is the proliferation of various licenses for libraries. There might be a great library to use, but the license may be vague or destructive. Often approaching the developers directly, results in outrageous financial demands thus making it impossible to utilize the work. Commercial developers are keen to make profits, and aren’t against sharing them fairly, but the commodification of software has dramatically lowered the margins. It’s getting harder and harder to make a profit directly on software, the monies come more often from the services and support side, particularly for software categories like niche enterprise software (5-20 clients). Thus payments to the authors of dependencies would be fairly small, and constitute a considerable overhead if there were a lot of them. This again would be fixed by clearing houses. Lump sum payments, or per-sale payments that were sent to a single clearing house that then disperses them to a large group of developers would allow the money to flow. If all of the works were under the same license and the terms were reasonable, then that would easily drop out another big problem for the commercial developers.

Another important point is that there should be many clearing houses. Competition is a good thing, but also some of the houses may specialized in providing access to particular types of code. Some industries are highly regulated and a house that could provide certified libraries would be hugely appreciated. Also license and support features could differ significantly, as well the underlying quality of the code. A house that only provided vetted high-quality libraries for instance, would be a very useful entity and save lots of development time currently used to evaluate the existing options.

I should point out that to some degree this idea already exists. Both Apple and Google have markets for apps that act as middlemen between the developers and the consumers. This seems to be working quite well (although it does also seem to have reduced the price of software). What I think we should do is expand that basic mechanism out to all code, all of the time. Pretty much everything would go through clearing houses, and for everything that is usable there should be some cost to it.

There are lots of other benefits as well, but my readers seem to really hate it when I go on and on :-) My key point for most people is: why kill yourself in the evenings and weekends to do great work that may end up making other people money for decades, if you are not going to get some share of the pie? Write something, deposit it into a couple of different houses, and if in a few years that provides the means to retire early then you are free to focus on the code you’ve always wanted to write, wouldn’t that be a great thing? You’re happy, the other coders are happy, the business’s are happy and the industry is happy. Everybody wins.