Free as in Speech, Fair as in Trade



Update 2015-01-02: Fairware has been phased out for a while now so a couple of references made in this article don't make much sense anymore... But the plan was still a sound one :)

Last year, I made the source code of my proprietary applications publicly available in a similar way than what was done for e text editor [dead link] a couple of months before. The primary goal was to reduce the consequences of the bus factor for my customers, while still earning money from developing software. In this primary goal, I was successful (yay!) as my income was not negatively affected by this move. I also had a secondary goal, which was to actually increase the bus factor for my projects by bringing more developers to them. In reaching that goal, I utterly failed. Today, I'm stepping things up a notch by making these applications fully open source (BSD licensed), but with a twist which, I hope, might open a new way for developers working on "generic" (shareware-like) OSS to earn money while doing so.

The fallacy of intellectual property

NOTE: In this article, I refer to all generic, widely used applications as "shareware", whether they're closed source or open source. Although the use of this term is slightly incorrect (shareware is by definition proprietary), it greatly simplifies the text.

First, I'd like to re-iterate what I said last year, which is that intellectual property, at least when software is concerned, doesn't make sense. If one person pays me to do custom work and then I give back something which has restrictions as to how it can be used, this would be seen as an attempt to keep my customer captive. Why should it be any different when it's actually 5,000 people who pay me to do that same work?

The answer is that in principle, there's no difference, but since we can't think of a practical way for 5,000 people to fairly pay a developer after he did the work, we invent a new concept, intellectual property, to compensate. This results in 5,000 customers being kept captive. In practice, most people don't care and will never actually be hurt by that (in the same way that a single customer who receives only binaries wouldn't necessarily be hurt by it). However, I believe that it hurts the shareware industry in general. In the proprietary world, as far as shareware is concerned, there's really a needless duplication of effort, which means that, due to that wasted effort, applications are not as good as they should be.

What is going wrong?

In principle, open source should thrive in the shareware world, dwarfing all individual (closed source) efforts with the sheer power of worldwide collaboration, but in practice, it does not. Why? Because shareware developers in the open source world are usually doing this as a hobby, in their free time, when proprietary developers do this full time. But if customers of proprietary software sent their money to open source developers, their applications would be, in general, better. Why again? Because in the open source world, for the same amount of time invested globally in software development, there's less effort duplication than in the closed source world, which makes open source more efficient. There's a discrepancy between what ought to be and what is, and we need to fill the gap. I think that the key to do that is to start a virtuous circle where more and more developers get paid to work on open source projects.

It seemed to me like I had a winning plan last year. It was a kind of "delayed" open source where the source was always open, but for two years, you couldn't touch the code that did demo limitations (and thus that encouraged users to buy licenses). After two years, the code would become entirely open (BSD licensed). My guess was that developers would take notice and would start being interested in working on my codebases. And then, since I had money coming in, I could offer them money for their work. Seeing that it works, they would devote more and more time to this, maybe start their own app, and fuel the virtuous circle.

It didn't work. At all. There was no interest whatsoever for working on my codebases. To my defense, I start with a handicap since my applications are not targeted at developers and the code uses a set of technologies (Python, Objective-C and Qt all at once) that a minority of developers know about.

But I also didn't think the whole thing through. I was aware that any developer deciding to work on one of my codebases was investing a significant amount of time to first understand that code, but I figured that their investment was safe from any arbitrary decision from me since they could fork the code (either from the two years old code base, or by keeping the demo code around and thus send me a slice of their own sales for two years). But none of these possibilities are practical: nobody want to work on a 2 years old fork when they know improvements have been made since, and no fork has a chance of being commercially viable if the developer has to send a big slice of his revenue to the original developer. And there's also the fact that I didn't do a good job of publicizing my wish for new developers.

Moreover, even in cases where a developer, having the right skills, would trust me, there would have been a weird dynamic when I'd assign work to him, since all work I sent his way would mean I'd have to send away a part of my income, making myself and the hypothetical developer in competition, and this, even if there's more than enough work for two developers to do. Sure, more work being done would mean a better application, which would probably lead to better sales, but I would have had to constantly keep that in mind when assigning tickets.

But I have a new plan!

So, what's the plan?

Last year, I ruled out voluntary contributions (donations) as a viable revenue source for open source developers, but now I'm thinking I did it a little too fast. Let's examine a fact here: The source for my applications is publicly available, the demo limitations are trivial to circumvent, yet, I still sell reasonably. Is it really just because users don't want to break the law? I really much doubt so. Everyone knows, I think, that I'm never going to sue them for cracking my applications. If there was a message when the application starts that said "It's 100% legal to crack that app, just google for it (but I would still appreciate that you buy the application)", I don't think that my sales would be negatively affected.

The reason why I sell licenses to my applications is, I think, a mix of good will and laziness. Good will because users recognize the work that have been invested in those applications and want to contribute, and laziness because buying the applications is easier than looking for a crack.

In the typical "donation button" scenario, users have the same good will (if not more), but also the same laziness. I can't know for sure why most open source projects don't get enough donations to afford full time developers, but if I examine my own reasons not to donate to open source project, I think I can begin to have a clue. The reason why I generally don't donate to open source projects is because figuring out a fair amount to donate is hard. You usually don't know how much has been given already and if your donation is really needed. Then, you also have to figure out who that money goes to, so that your donation is fairly distributed. On my part, the fear of donating to what turns out to be a marketing guy just freeloading on other people's work and just collecting donations is something that keeps my mouse cursor away from that "Donate" button. Sure, if you take the time to check your facts, you'll discover that the project you like so much is maintained by just one guy, who receives absolutely nothing for his work, but figuring those facts takes time, and we're all lazy...

C'mon, get to the point!

What I decided to do, from now on, is to re-license my code as BSD, and at the same time make it very easy for users to determine the fair amount they should donate (if any). From now on, I don't sell licenses anymore, I sell my time. I log the time spent on all applications and I publish them on this page (as you can probably notice from the logs from before today, I've been running "as if I was open source" for a little while now). I also publish contributions I receive in real time, so users can very easily determine how many hours are still unpaid. There is also a clear indication of how much a single user is expected to pay, even though they can contribute any amount. In addition to all that, I make it very clear, in the applications themselves, that contributions are expected from users. I do so through this dialog:

Fairware Reminder

By removing demo limitations, it makes it easier not to pay for the application than paying for it, which will probably lead to decreased sales, but with enough good will from users, that decrease shouldn't be too steep.

On the bright side, this system, I think, greatly increases the chances for other developers to become interested in working on those applications. Because all contributions are publicly displayed, seeing positive numbers like that (if they're indeed positive...) should be a good incentive for a developer to decide to invest some time in the enterprise. Moreover, since what is sold now is time instead of licenses, I'm not in competition with hypothetical other developers anymore (actually, in the case where it's not all hours that end up being paid by contributors, there is some competition going on since distribution of money is prorated based on total unpaid hours, but this competition is less direct). The more hours being poured in, the better.

All of this, I hope, will catch the attention of other developers who, seeing that my time invested in this type of software actually gets paid, want to do something similar. They'll start doing it on the side, and then leave their day job (if boring) for it. The shareware world would be filled with quality open source software for which developers get fairly compensated, and the world would get a little better. Yay!

I even dared coining a new term (although it's already taken in the non-software world): Free as in speech, fair as in trade... Fairware?

I realize that this scheme has a high probability of failure, but I feel like taking the leap, since it would be so awesome if it worked. Moreover, my business is in a state where such a move makes sense (read on).

The moneyGuru situation

I'm in a weird situation where my main selling application, dupeGuru, is mature, which means that there's not much more work to invest in it. The sales are still good after all these years, but I think they're bound to go downwards. I also feel like I got enough money for the work I invested into it so far, so it's only fair that I make it open source.

On the other side, the application in which I invest the most time, moneyGuru is a commercial failure (which is really sad because that codebase rocks). The logical course of action for me to take is to start working on a new application. I have ideas, but I don't really feel like starting a new application, considering how silly this whole effort duplication thing mentioned above is. I'd rather work on one of the open source applications I use, but I'd like to be paid for it. Before I can do that, I have to know if this system works!

So the rationale is that while I still sell dupeGuru, this move is a good way to figure out if this method is viable. I already know that there's a lot of people who are ready to pay for it, so whether I succeed or not, I'll retrieve valuable information from the experience.

Developers wanted

Are you a developer? Are you interested by this idea? All feedback, questions, involvement of any kind are very much welcome. Please send me an e-mail at hsoft@hardcoded.net.