Here, I’m coining a new term for the software development world. Similar to open source software, royalty-source code would be widely available for download via a system like github. Unlike open source, however, royalty-source includes a mechanism so that each coder gets paid as programs get downloaded. This new mechanism should fairly distribute royalties based upon some sort of weighted system for each of the dependencies.
The following tree shows a typical collection of dependencies pulled into a new Node.js program named MyNodeProgram, as an example, with the single command
npm install mongoose:
- benchmark + 22 other dependent libraries
Doing a directory listing of your program’s
node-modules subdirectory should then reveal just how much code got pulled from github with that single
npm install command earlier.
Unlike open source coding projects, royalty-source coding projects add a new concept to the business model. Royalty debt is the added virtual cost to your project with each
npm install command you invoke.
If you envisioned charging $1.00 for each download of your own program and it now contains that mongoose dependency from before, you’ve greatly diluted your own code with the inclusion of this large collection of code that somebody else created. If you created a typical Hello World program that uses a MongoDB database and assuming that you only add a few lines of your own code, then you might only get $0.01 of that $1.00 download royalty and everybody else would get the remaining $0.99 of that sale. Without that mongoose inclusion, it would be unlikely that anyone would want to pay you $0.01 for your code, at least in theory. You might then accept this 1% ratio as what it takes to make money.
Instead, you might start to rethink your entire program from the ground up. If you could remove the mongoose dependency and store your data in a simple BSON object instead you possibly could drop that dependency completely and the royalty debt it incurs. Assuming that you no longer had any other dependencies and people are still happy to pay the $1.00 price tag, 100% of that is now yours to keep.
One big benefit to this concept of royalty debt is that it should incentivize coders to review that stack of dependencies to look for anything that’s been included and yet which doesn’t add much value to the overall project. The coder then should remove any unwarranted code to lower the bloat effect we often see in open source projects. Smaller code is often better code.
Pay the House
Obviously, whoever is the new github provider will charge a commission of some kind for each download. The download price minus the commission equals the total royalty to be split up.
Hopefully this system would include balances which would allow someone with existing credits to then use them to download other code.
Presumably, a value system would be in place which weighs each dependency against the parent program’s code with some kind of fair distribution model. As in the above Node.js example, the
benchmark code appears at least three times as a dependency and should then get a bigger piece of the pie, so to speak.
Given that we’d now have royalty debt to think about before adding a new dependency to our project, we should have some tools to quantify that cost. In theory, you’d run the
npm install command with an extra argument which quantifies that module’s
package.json dependency list. Let’s say that you might run the following command from your
npm install mongoose --cost
At this point, npm might indicate…
mongoose @4.3.5: Cost=$0.99/$1.00
Note that this is assumed to be a guesstimate at this time since your own program’s few lines of code were compared to the collective code and dependent modules of mongoose to return this ratio.
As a coder, you now have a build-versus-buy decision: 1) build your own database code instead or 2) expect to pay for mongoose (and dependent code) with each sale/download of your own code.
Pay the Piper
Obviously, it wouldn’t be fair to the coders of your own dependencies if you under-valued your own program. If you decided to charge only one cent for your Hello World example above with all those dependencies, you’re distributing someone else’s code for a small fraction of what it would be worth otherwise. In this system each module author should be able to define a minimum cost for their library. As this code gets included into parent projects they should honor this requirement.
The benefit of this minimum cost feature is that it will gradually increase the cost of increasingly-larger code. If the total minimum cost for the mongoose module is $0.33 then the next author must charge a minimum amount which factors this into the total download price.
So why should we bother with a royalty-source code system when open source seems to be working fine?
- We’re not getting paid to create software
- Everybody expects us to be responsive to their own needs (fixing bugs/issues) without considering that we normally expect to pay for services rendered
- Corporations are using open source code as a means of not paying software developers
- Other than a virtual tip jar, there doesn’t appear to be anywhere within the open source system where the coder gets anything for their efforts
- It costs a lot of money to pay rent, to eat and to otherwise afford a working computer and Internet connection as a developer