Is the GPL the licence of digital abundance?

Projects Digital Abundance Network
,
1

I’ve finished reading the book Producing Open Source Software by Karl Fogel. It made it clearer to me how to proceed with the Digital Abundance Network and Quantified Prestige. When reading about the various different open source licenses, the GNU GPL is mentioned prominently.

I find it intriguing that the GPL is so popular. It prevents people from re-licensing GPL-licensed software in a proprietary package. So, what is free under the GPL, basically stays free forever, even if it is heavily modified and enhanced. That’s cool, because it encourages a culture of digital abundance. People can get free stuff in order to make more free stuff with it. In the end, a great digital commons is created that isn’t diminished, but enhanced, by intense use! Thus we get something like an anti-tragedy of the GPL-protected digital commons.

ethereal-snowflake.png1000×1000 1.44 MB

The only problem with that, is that it may still seem easier to get funding for proprietary software, even though a lot of open source software is made by software developers who are being paid for working on it. WordPress is a famous example of an open source project that took of quite dramatically. The following was supposed to become a collection of examples for business models for companies focusing on open source software:

Perhaps unsurprisingly, this forum runs on the GPL-licensed Discourse software. The company responsible for the core development of Discourse gets paid for premium hosting (too expensive for my budget, the F3 currently runs on my own virtual private server). So, it’s quite possible to earn money with open source software, but that usually works by offering services around the software.

Since everyone can get a copy of some piece of open source software, service marketplaces around popular open source software develop naturally. These marketplaces somewhat limit the price of the offered service. So, a company can’t rely on making enough money through offering services around the open source software that it develops, even (or especially if) it becomes rather popular.

That’s why many companies opt for open source licenses which allows them to create proprietary software on top of free software. Then they offer a “freemium” model: They develop an open source core software for everyone, and a proprietary premium version of that software for paying customers. However, that business model creates artificial scarcity, because most people are artificially restricted from getting access to a program, and its code, that could have been free.

I think that software developers should be paid to create open source software, because that kind of software benefits everyone, and rises the level of prosperity globally, thus having an equalizing effect on the economy: Everyone is better of, because everyone can use the best (software) tools. Proprietary software creates artificial scarcity. Still, are permissive open source licenses that allow the creation of proprietary software on the basis of open source software a net good thing? After all, one could argue that the proprietary software requires the creation of a free core in the first place, which is better than having no open source version at all.

Can permissive open source licenses facilitate the creation of more open source software than copyleft licenses like the GPL alone? Or does it slow down the road towards digital abundance? I am not sure about that. Perhaps some of you might know more about this issue @Darklight, @AlonzoTG, @Deku_shrub, @Elriel, @HoverHell, @losthobbit, @Macius_Szczur, @Nuzz, @TR_Amat, @technologiclee, @TheDoctor, @ZeUs.

Ideally, people would self-organize so that their efforts and money could enable the existence of an abundant open source software ecosystem that made proprietary software obsolete. This doesn’t seem to work too well in all areas in which software is produced. While Linux has become really popular for internet servers, for example, private users still mostly use proprietary operating systems. If open source software was inherently economically superior to proprietary software, we should see a steady rise of the fraction of open source software in all areas. Why isn’t that really happening? Because end users are locked into a proprietary software ecosystem? Perhaps in the same manner that keyboards are locked into the dominance of the QWERTY layout?

Anyway, what could be done to help open source software win against proprietary software?

2

I think open source winning is inevitable. The disadvantages in proprietary software are just too large to ignore. Proprietary software’s only advantage is that it’s easier to get resources allocated in our current economic model for it. However, it might still take quite some time before we see the end of proprietary software. If we can create a model that allows private investors to profit from funding open source software that ends up widely used, that’d probably signal the end of proprietary software.

The main problem in funding open source software is that there’s very little direct benefit for an individual to pay for it’s development, even if there’d be a lot of sense to fund it, collectively. Also, it tends to be pretty much work to individually pay a small amount to every project that’d deserve your money. I suspect some kind of a system is needed that allows you to just pay the system and let the system figure out how to best distribute your money based on what you actually use. I suspect cryptocurrencies (and whatever currencyless value transfer systems that crop up) will be instrumental in making this happen.

Of course, to really beat proprietary model in every possible way, we should probably also aim to make supporting open source projects a status symbol, socially. That is, respect people more if they do that.

1 Like
3

That’s a very good point. It can actually be split up into two separate points:

  1. How can the monetary profit from funding open source software be increased? This points is related to open source business models.
  2. How can the “reputation profit” from funding open source software be increased? This ties in with your closing comment:

As for the first point:

That sums the problem up pretty nicely, I think. To me, it feels like a kind of market failure. While individuals may see the advantage of having some kind of open source software, there doesn’t seem to be a good mechanism to let such individuals coordinate to collectively fund it. Donation based development doesn’t require such coordination, but it doesn’t seem to work that well in general. What seems to be missing is information about the preferences of other potential users: Like “what software do all the individuals in the world want to have?” Or it could even be more specific for one piece of software: “What features do the users of one software want to have?” Luckily, the latter problem can be solved relatively well by web forums for software users. Could the first problem be solved by a suitable online forum that collected the individual wishes of potential software users in an easy and scalable way? I think this ties in nicely with the OpenBUMP idea by @Ken_Carroll:

What if there was some kind of public fund that allocated money to open source projects in proportion to the Facebook likes they got? I’m sure, many people would dislike that scheme, because it involves Facebook. But the general idea seems to be not so bad. In fact, there’s some kind of implementation of that idea that’s called Flattr. People can choose how much they want to pay for open source stuff per month and then click on Flattr buttons. The Flattr system then allocates the monthly payments according to the Flattr clicks. Flattr has existed for quite some time. I wonder why it hasn’t become more popular.

Anyway, Quantified Prestige could be used in a way similar to Flattr. But the difference in QP is that people wouldn’t have to pay conventional money. Instead, the distribution of Prestige simply determines the incomes of users in Fluido, a new (theoretical) currency. That would avoid the problem that people don’t like to pay for “free stuff” directly. Instead, who ends up paying are those who buy Fluido. Why should anyone do that? Basically because Fluido is an awesome currency. Of course, I have written a post about Fluido, in order to make that claim plausible:

As a closing thought, Quantified Prestige can tie together reputation profits and monetary profits: By funding open source projects investors can increase their reputation, and through reputation incomes also get money back over time, especially if the software becomes really popular.

4

It’s not a complete failure. An open source software to replace any piece of proprietary software that proves to be succesful seems to be an inevitability. The process is just horribly slow and inefficient compared to the shortest imaginable route to the destination. It’s also worth noting that some important software started out as open source, rather than proprietary.

One option to accelerate this process could be an user funded non-profit that made acquisitions of proprietary companies with useful software and open sourced them. But starting such an organization suffers from the very same problem as open source generally. It’d start out too insignificant to be seen worth donating to. Something like this would probably require some richer people to get together to get it started with enough capital to start with a flash. Once it’s running, it might be able to generate some income from the companies it bought to use in further acquisitions as well.

What I like about this non-profit idea is that if it works, it kind of combines the strengths of open source and proprietary. Of course, it might be even better if the organization itself effectively identified what is worth developing and funded them directly as open source from the start, that would possibly work even better, but this is something that tends to work better when it’s decentralized and profit motive fueled.

… having written all that I realized that The FSF actually resembles what I described somewhat. Unfortunately, it’s a heavily ideologically indoctrinated organization, which tends to scare people off from donating unless they’re ideologically compatible. They’ve made a lot of good software and I suspect the software world would be a much different place without them. However, the extreme ideology probably conflicts with doing what would be most effective in practice though.

Yes, profit can be used to describe both. Just, point 2. tends to be more effective with regular people and point 1. for the people who have the most influence in how the world progresses. Monetarily influential people tend to want to increase or at least keep their influence, so they seek monetary profit from their investments. Even if the main point in the investments is to improve the world somehow.

That will work to some degree. However, this is something that really should be built into operating systems. There’s an interesting project brewing that might make for a paradigm change in many ways. It’s still somewhat difficult to understand what it’s about, exactly, without deep insight about the subject, though. http://urbit.org/

Most people don’t want to stop to think about the software they use for long enough to produce useful information about how to proceed. However, if the OS itself had instrumentation that did the work for them, they would be much more likely to allow it to happen than to do it by themselves. For example, this urbit thing I linked to, would be simple to build instrumentation for that keeps track of the code that users run. This instrumentation could in turn be turned into a system that allows you to easily donate to the developers whose code you actually run. It could make it individually profitable for developers to write code that ends up widely used.

Better than nothing. However, it’d give Facebook the power to decide where the funding goes, in practice. That I’m not very happy about. It’d also restrict the measurement to the project level, which would make the system simple enough for users but would also give control of the funding to inter-project politics. Which is, again, better than nothing but is almost guaranteed to misallocate the funds to some degree. Direct instrumentation could direct the money towards those whose code ends up being most useful in practise.

It’s the lack of obvious direct benefit for using it combined with a general lack of knowledge about the service existing as well as the resulting lack of trust in the service combined with a general ignorance about open source.

Please do.

Sounds great, if it works. Unfortunately, that’s all I can say at this point since I don’t understand the motive people would have for valuing the currency. If you do make a writeup about it, please follow the steps of induction proof. That is, first explain how to get the thing started and then how it’ll keep going as well as why.

5

Yeah, it seems that the heavy ideology of the FSF has turned of businesses from open source software. That was the reason for the emergence of the Open Source Initiative, which actually coined the term “open source”, which I personally prefer to “free software” (mostly because the word “free” is ambiguous).

I’ve tried to do that here, although I probably would have needed to go into more detail:

6

I think this is an order-of-operations problem.

Free Software developers hoping to receive compensation tend to:

  1. Do the work.
  2. Release the results.
  3. Advertise why this is a good idea (maybe by announcing on a forum).
  4. Ask for payment.

We can change this to:

  1. Advertise why this is good idea (maybe by announcing on a forum).
  2. Ask for payment.
  3. Do the work if payment is committed.
  4. Release the results.

Crowd Funding seems to fit this approach.

One of the ‘perks’ offered could be having priority when receiving the initial release and updates.

Note, the GNU GPL does not require any sort of ‘global’ distribution of the finished product, it only requires the Sources accompany any release and requires further distribution be allowed.

So it is legal to release the software only to those who paid, while allowing them to distribute if and when they like.

Many people like to be “first in line”, so this might be quite effective, even for ongoing maintenance.

For example, say there is a bug in Free Software you wish someone would fix. If there were an easy way (as alluded by urbit I believe) for the User to easily find or create a work-order and then commit some small amount - say 99cents - toward a fix, then developers could look at this list of work-orders occasionally, and if enough money is committed for the work they guess it might take, then they could get paid for doing that work.

1 Like
7

Crowdfunding is indeed a very quickly growing phenomenon, and I believe that it will help us create a better future. So, I really like your approach. My initial reservation about it was that

  1. Do the work.
  1. Release the results.
  2. Advertise why this is a good idea (maybe by announcing on a forum).
  3. Ask for payment.

[Let’s call this model “post-payment” and the other one “pre-payment”] Is better for demonstrating the ability of a person to be able to actually create useful products. But the only thing it really takes is having a public track record / portfolio of the creative abilities of an individual.

The pre-payment approach seems to be better at creating an actual interactive creation service market around digital goods. It may be better at allocating funds in a productive way.

Would that be enough to beat proprietary software? Who knows. Perhaps it’s only necessary to shift the odds a little bit.

Also, it would be possible to combine this pre-payment approach with an advanced post-payment approach like Quantified Prestige + GeoFlux.