Slashdot Mirror

One consideration to think about is that the people who are recommending you release as open source may, in reality, simply be advocating for the ability to make customizations and build on top of the framework you're developing.

That's the most important benefit users get out of open software: the ability to tinker and to break away. And because it catalyses an ecosystem, the developer also benefits from making it easy for their software and its documentation to be extended.

If one's willing to break away from a pure FOSS licence, it's possible to retain these freedoms while making it feasible to charge for the software. All you need to do is to adopt a licence that (a), requires users pay a licence fee to run the software in a non-test system, and (b), requires those distributing a forked version pay that same per-copy licence fee back to you, keeping any premium their enhancements or marketing nous can attract. You not only get an army of developers riding your ecosystem, but an army of vendors trying to maximize awareness and sales. Not to mention happy users without that locked-in feeling.

If it's serious software put to serious use by entities with reputations to protect, you won't get too many dodging the licence fee, especially if you include a simple licence check/reminder facility that though easy to bypass (it's open source after all) still needs to be done as a conscious decision.

So I think the way to go is a licence that makes non-gratis libre software feasible, and which can support IOSVs (Indepenent Open Software Vendors). Here's one example.

1.-You are allowed to have the code, 2.-You are free to modify that code for personal use in any way you desire, 3.-If you distribute that code YOU MUST PAY for a license, which must be offered.

I'm not clear exactly how this would work. Is it similar to my Rails Wheels Licence?

Under a Rails Wheels licence, although a software package's source and build system must be made available, the software's owner has the option to only allow people who have paid for the software to run it in other than a test system.

Second, other developers can freely fork the software, but if they re-distribute it they must pay the original developer their normal asking price for each copy they distribute, meaning that they'll usually have to charge at least as much, keeping any premium their enhanced package can charge.

This makes the licence differ from a FOSS licence in two respects: The freedom to run (FSF Freedom 0) restricted to paying customers; and redistribution can require a per-copy fee to be paid to the original developer (though is otherwise unfettered).

Such a system can percolate money up fork trees so that each fork only gets paid for the value they add. All the FOSS benefits of being able to tinker with the software are unchanged.

I think an app marketplace centred around this licence would be a way to make commercial 100% open source software a reality, where by commercial I mean charging for the software itself rather than back door methods like product placement (Mozilla), support, donations, or proprietary extensions.

Free software types are not opposed to for-pay software, at all. The two concepts are not related.

This distinction was somewhat valid when one had to order software on tapes and disks. But in an era when the cost of distribution is just about zero, it's very difficult to charge for copyleft software.

What are the options to earn income from software that's entirely copyleft?

• Panhandling: But most won't pay if the only new thing they're getting is a warm feeling. It turns programmers into beggars and servants.
• Selling support: But many users don't need it, or can't afford it, and they need it less the higher the quality of the software.
• Embedded Advertisng: Users find this very valuable.
• Sell Documentation: Now we're introducing a proprietary component again, preventing open community involvement in its development.

Access to the source and build systems, and the ability to distribute modified versions, are the real strengths of open software. By removing the freedom-to-run requirement it becomes easier to charge for software that still gives users all the freedoms that motivated Richard Stallman to start GNU and the FSF.

It's a strategy that makes open source profitable. Either you sell support, or you sell a value added proprietary version.

...or you actually sell the software.

Sure, standard FOSS licences like GPL and BSD make this hard, but there are others that make it feasible to charge for software that is entirely source-available, freely-re-distributable, and freely-forkable.

This is quite close to my first thought about this: why does it have to be free? Just because it is for Linux or Open Source? Open Source does not necessarily mean free-of-charge, not even free-as-in-speech. That one can look at the source and modify it doesn't necessarily mean you have the right to redistribute it, or that you can obtain it for free.

You're quite right that there's no reason for open software to always be gratis. But unrestricted redistribution is one of FOSS's strengths.

It's quite possible to charge for software that is both source-available and redistributable. Rails Wheels does this.

Now if only they can come with a simple way to pay small amounts (and that is a big issue - without having to buy "credits" in advance or whatever) I think it can give a great boost to open-source developers. If an application is good, well yes I'd happily donate a small amount (though much rather after obtaining it; not beforehand - try before you buy). Not US$50 or so - more like a dollar or two. Let a couple hundred people do so and the developer can buy himself a nice upgrade for his computer. Always nice when your hobby gives you something real in return.

You can make small payments feasible by having a store that allows you to aggregate your purchases for various pieces of software at quarterly intervals, as Rails Wheels does.

Also, we shouldn't be stuck on panhandling as a way to get paid for open software. You can charge a compulsory one-off or quarterly fee when the software is being used (rather than just evaluated). In return you give the purchaser ticket-based support and a "licenced user" web-badge.

Licence fees should also vary with the type of user, and the benefit being gained. Say, making it free for non-commercial users, cheap for small commercial operations, and more expensive (but still great value) for large users.

Yeah, rather than a percentage of the gross there should be a fixed price per use that varies according to the user's ability to pay.

Rails Wheels does this by allowing the price of a software package to vary according to both the user's type (non-profit, government, personal-promotional, or for-profit) and the user's size (as measured by the number of employees).

Have a look at the Rails Wheels licence system, used by some Ruby on Rails plugins.

It allows customization and redistribution, but ensures that the original author gets paid when any derivative work is in live use on a website.

Plugin authors can allocate income shares to others, giving authors of significant patches an incentive to contribute back to the original (commercial) package.

The GPL doesn't allow a software author to demand that persons who receive and use his software pay him a fee, because this effectively limits GPL's freedom-to-run condition.

However such a requirement to pay the original author can be made compatible with licences that also permit unfettered source redistribution (which is where most of the benefit of Open Source Software lies).

I use such a system at Rails Wheels, along with methods to make payments easy, affordable, and honourable for all who receive a copy of a software package.

Perhaps a solution for some projects lies in the middle, with a commercial source tiered licence system, where the source code is provided with all licences, the developers are receptive to improvements from customers, and the cost of software is set according to the ability of the customer to pay, a hobbyist who is using the software for fun would pay far less than someone using it in a high revenue business. This assures that the software does have a high degree of openness and accessibility to all, but also assures revenue can be raised to develop the software.

That's exactly what I've done at Rails Wheels.