Software Ownership

Overview

Who owns the software you use, the software you write? And why does it matter?

TL;DR: Don't write or use anything but Free Software. Free as in freedom, not as in price.

How can someone own software?

In the beginning of the software programming industry, programs were treated like you would treat Shakespeare poems. They were freely shared and sometimes improved upon. Some people may have had a thought that the software itself was valuable, but since the people who were using it could create it, they didn't think it was a big deal. Hardware manufacturers encourage people to write software for their machines, understanding that if they could become the standard, they could make a lot of money.

It was Bill Gates who had the idea to actually sell software. In order to sell something, you have to first claim ownership. Bill Gates used copyright law to say that since he and his friends wrote the code, they own it as much as an author or a composer owns the product of their work. And so Bill Gates sold software. Or rather, he sold licenses to use his software.

This was quite a different attitude that people were used to at the time. And it wasn't long before Bill Gates was writing articles about software "piracy", equating copying, sharing, and improving on his work as forcefully looting ships on the high seas.

In my moral system, people own what they create. By the fact that they created it, they are entitled to determine what is to be done with it. This is the foundation of copyright law the world over, and the foundation for patent law as well. However, if I create something that people like, at some point, they own it as well, and it is no longer mine. This is reflected in the expiration dates on copyrights and patents. What justification do I have? Simply this: I try to treat others the way I'd like to be treated. AKA, the Golden Rule, a common element in almost every religion. When I write some software, I'd like to have some say in how it can be used and who can use it, so I afford others the same privilege.

It is important to note, at this point, that this is really an issue of morality and rights. The question always comes down to where the rights and morality come from. The conclusion I have drawn for myself is that rights and morality cannot be decided by committee, vote, or legislation. 9 men in black robes cannot tell me what is and is not right and what rights humans deserve. That is something I must discern for myself, and I have got to think really hard about what I decide to choose. Another point is that although it seems like there is some kind of logic behind morality, there really isn't. Morality isn't determined by logic, even though it is sometimes governed by it. So I implore you, dear reader, to make the choice for yourself that you will let no one else tell you what is right and wrong, but you will make your own decision and stick with it for the rest of your life.

TL;DR: Authors and creators own software, at least initially. At some point, it's free to everyone.

Types of Licenses

There are many, many kinds of licenses out there. I'm going to break it out by these axes:

• Whether the software is owned by one person, many people, or everyone.
• Whether the software can be shared.
• Whether the software can be examined and inspected and commented upon.
• Whether the software can be changed and those changes shared.

As I break it out, I am going to provide some of my insight to what the effects are. After this section, I'll cover some broad license types.

Ownership

Whether an individual, a corporation, a committee, or no one (rather everyone) owns software is important.

• Software owned by an individual tends to be under-developed and neglected. Although individuals can provide bursts of creativity, they are not ideal for long-term consistency.
• Software owned by a corporation are either well-maintained or neglected. If well-maintained, then company resources are used to maintain and develop the software. If neglected, it might as well not exist at all.
• Software owned by committees rely on the nature of the committee. You may think that charities are more likely to keep software running well, but you must admit that charities are just another type of business. If the charity is well-funded, then it is no different from a corporation. If not, then you're almost in an area similar to individual ownership. So it's hit or miss, and sometimes worse off.
• Software owned by everyone is a strange class of software. There really aren't many examples of this out there. What tends to happen is someone might make a few changes and then release it. What's more likely to happen is a corporation or an individual will gain control of the software by making a change that is critical to its usefulness and then exerting control over that change.

In short, software needs owners that are more like corporations and less like individuals. Software owned by everyone is in a weird state that will devolve into corporate or individual ownership as time marches on.

Sharing

There are three kinds of classes of sharing I've seen:

• No strings attached: Share it as much as you like, no strings attached. This seems like the most ideal, but what inevitably happens is someone shares a copy *with* strings attached. IE, someone takes some freely shareable software, adds their own things on top of it like adware, and shares that.
• Some strings attached: This sometimes presents itself as the requirement to include a copyright notice, as BSD and MIT are notorious for. It may include strings such as making the software freely shareable like the GPL. Despite the strings, it is rare indeed to see them enforced.
• Lots of strings attached: Proprietary software sometimes allows sharing but under strict conditions. It seems better just to refer people back to the source than share this kind of code. There's too big of a chance to make a mistake, and there is a good chance that any violations will be enforced.
• No sharing: Proprietary Software typically doesn't allow sharing. You have to get your own copy from the source. This obviously hurts the spreading of the software through legal means, but it can be a good way to get money from the software. (But there are problems with this model. See Proprietary Sofware Below).

In short, you can't allow free sharing with no strings attached, otherwise it will end up with strings attached in one way or the other. The GPL is the ideal here: Freely share as long as you allow others to freely share.

Examination

Oracle's database is notorious for disallowing people to run tests on how fast it is and compare it with other databases in public. If you want to test Oracle, you have to do it on your own time.

Programmers often obfuscate the code in an effort to obscure it so that others can't figure out how it works or copy their techniques.

It seems a lot of work is put into keeping people from knowing what's inside the software. The idea, I suppose, is twofold: (1) make more money by keeping secrets, and (2) keep the software more secure.

In both cases, the goal is not what is achieved.

By keeping secrets, your software is less secure. The only way to properly secure software is to have experts examine it for flaws.

And fundamentally, in free market economics, ever exchange is based on the idea that people know what they are getting. If you're selling something that doesn't live up to its promises, your brand will be hurt, the market will hurt, and you'll end up costing people a lot more money than would've been spent had they known exactly what's inside. Not to mention the time lost as people encounter bugs...

And finally, if your software is truly ingenious, you should tell the world about its ingenuity. That way, when someone copies it, everyone will know they were copying you. Instead, what often happens in research is the first to publish is the one who gets credit. The scientist who sat on the idea gets no credit.

In short, closed software is retarded software. Don't make your software closed. It helps no one, not even yourself.

Changing

This part really irks me. As a software developer, I can help software authors make their code better. I *want* to help, and oftentimes, I'll do it for free because making the software better will make my life better.

There are also a thousand people out there like me with their own ideas, and I want to see their ideas so I can pick and choose the best one.

Something amazing happened with Skyrim. See, when Bethesda opened up the game to modding, people went wild and created an unimaginable variety of mods. Now Skyrim is far more valuable as a game because it is really a platform to play ten thousand games on. Skyrim is also being updated for modern hardware by modders, so it will never fall behind even the best games.

The idea behind limiting the changes people can make to the software might stem from paranoia: If they break it, they will blame me! But it cuts both ways: If they *fix* it, they will credit me! See, people think Skyrim is a great game because all the little annoying bugs in it have been fixed by modders. When you play modded Skyrim, it can be a really enjoyable experience.

So don't make it so I can't adapt software to my needs. Don't treat me like I don't know as much as your developers. We're all human!

Conclusion

The best software is:

• Owned by a corporation or corporation-like entity and well-maintained.
• Freely distributed with strings attached to ensure it will always be freely distributed.
• Open to examination.
• Changeable.

Anything less is selling the authors and the users short.

Types of Licenses

Here I examine some broad types of licenses, and what my thoughts are.

Proprietary Software

This is a broad range of software, the typical (as of 1990-2015 at least) license. It says that you can use the software, but it's not guaranteed to work, and you have to pay someone and you can't share it or change it or even look at how it works.

This type of software sucks. Run from it, fast.

If you ever see an ad in a glossy magazine telling you how it is the greatest software, remember that cigarette companies used to advertise in glossy magazines about how healthy cigarettes were. In other words, marketing is a lie!

Just don't use proprietary software. Don't. Don't try to copy it. Don't try to emulate it. Just don't use it and don't give it further reason to exist. Let it die a quiet death.

In the rare case you have to use proprietary software, seriously investigate if that is actually the case. You'll be surprised to know it usually isn't.

"Open Source"

"Open Source" is a broad term that includes "Free Software", but I will talk about Free Software separately.

Open Source software has a history as being a sort of compromise between Free Software and Proprietary Software. There was a lot of animosity from both sides since this is, at the core, a religious debate about what is right and what is wrong.

Open source software shows up in many forms:

• Public domain software, which usually ends up as Proprietary Software. The way this happens is someone will extend the software and then own the extension.
• Freeware: This was popularized by Id Software back in the 90's to distribute Wolfenstein. The authors encouraged you to share the software with your friends. They made money by selling expansion packs. Although you can share freeware, oftentimes there are strings attached so be familiar with that those are before you share it.
• "Open Hood" software: You can look inside, but sometimes you need to sign an NDA (Non-Disclosure Agreement). This is very useful especially when you are building against closed-source software. Knowing what it is doing is critical to properly identifying errors when they occur.
• BSD software: You can do what you want with the software as long as you include the copyright notice.
• Almost Free Software: Very close to being fully Free Software but missing some details. Python, for instances, was not free until it fully adopted the GPL.

As you can see, there is a broad middle-ground between Free and Proprietary Software, and the lines are not at all clear. Be sure to read the licenses carefully and think hard about its implications before devoting yourself to using it.

Free Software

The final category of software license is the least understood. It seems everyone gets how to make money selling software, and everyone understand how open source works, but very few understand what Free Software is and why it is desirable. Even fewer still understand how to make a living writing Free Software.

The freedoms that Free Software guarantees are:

• The Freedom to Use
• The Freedom to Share
• The Freedom to Modify
• The Freedom to Share your Modifications

These are very important, as I discussed above. Let me explain here some of the effects of these freedoms.

Freedom to Use. When you are free to use software however you would like, you are free to think of new ways to use the software that the original authors couldn't anticipate.

Sometimes people object to this, for instance, they might say that they don't want their software used by a military. What they don't understand is that the military could use their software to kill or save lives. Having their software in an airplane, for instance, could save the lives of soldiers and civilians alike, or it could help guide bombs to their target. You really can't anticipate how people will use your software. You can't own the choices others make with your things. At some point, they have to assume moral responsibility for what they do with themselves, and bear the full burden of their good or bad choices.

Having any restriction on how the software could be used is an invitation for complexity and administrative burden. It's better just not to use software that has any restriction. In the complicated world of software dependency, relying on a single component with restrictions on its use jeopardizes the entire system. Just leave that software out for the sake of simplicity and transparency.

Freedom to Share. When people share your software, they are really selling it. Your software gets used by more and more people. As people use it and like it, they become your marketing department, your sales team, your tech support engineers. After all, if I recommend software to someone, and they use it and have problems, they are likely to ask me what they did wrong, not the software authors.

A key component of this freedom to share is that people who share it can't add conditions to the sharing of the software. If they can, then there is the possibility and thus eventual reality that the software will no longer be free.

Freedom to Modify. This is a key freedom that people who don't program computers don't readily understand. What may help them understand is that really, all we ever do is program computers. Your clicking of buttons and typing in of words is really a program that tells another program what to do. The Freedom to Modify is really the Freedom to Use in disguise. But it encourages modification by sharing the source code used to build the software.

When people modify software together, they form relationships based on how the software must interact. This creates a community, where people share their insights and ideas with each other freely. In this environment, everyone benefits more than they would had they isolated themselves. So the Freedom to Modify is also similar to the Freedom to Associate. It builds community where none existed before.

I should also note that if a company built software that became used by literally billions of people, how can you expect them to adapt the software to suit their needs? It would take insane resources to modify the software to fit each individual, and so companies are left to provide a single version or a handful of versions. When it comes translation, minority languages wait a long time for companies to give them the translation. With the Freedom to Modify, the company who wrote the software bears none of these burdens. If someone wants the interface translated to their language, they can hire someone to do it with their own money. If someone wants to adapt the software, they can hire their own engineer to do so.

As an engineer or a translator, this should excite you. No longer are you working in a market dominated by a few software companies, but now there's the potential anyone anywhere might hire you to work on any kind of software.

Freedom to Share your Modifications. The final ingredient is the ability to share your modifications.

There is the problem of software of who's version is authentic. Free Software doesn't solve this problem. However, in the freedoms, there is a solution. See, as long as people share their changes, then all of the changes people make are accessible. Someone, anyone, and indeed, several people, may decide to collect these changes into a single package, saving others the time and hassle of gathering them together. Indeed, that is what we see happening in the mod community: mod packs.

This also solves another problem. Let's say Company X wrote Software X and released it as Free Software. When Company X goes out of business, who owns Software X? Thanks to the freedoms granted by Company X, no one has to. Anyone can pick up the baton and continue working on Software X. Most likely, someone or some company that uses Software X will lead the way.

Now, let's talk about how these freedoms are guaranteed. It is important to note that these freedoms do not include the freedom to take away these freedoms. If it were, then they would not last very long. The way this is done is with a copyright that has been dubbed a "copyleft" --- a sort of inversion of what copyrights typically say. Rather than saying, "You must use this software the way I say so", the copyleft says, "You can do what you wish with this software." Rather than saying, "Don't share this software with anyone", copyleft says, "Share this freely, as long as what you share can also be shared." Thus, Free Software relies on copyrights the same as Proprietary Software does, and just like Proprietary Software, these can be enforced in a court of law.

It is thanks to Richard Stallman (RMS), the Free Software Foundation (FSF), and the Gnu Public License (GPL) that we have Free Software at all. It is thanks to the thousands and maybe millions of people who see the benefit of Free Software that it continues today.

Wait a minute... how do I make money with Free Software?

I think this needs to be explained a bit better.

In the software industry, we are used to crazy rates of return. We justify these by saying that there is a huge amount of risk. That is, we spend $1M to build some software that is likely to make $1,000M but only 0.1% of the time, so it all evens out more or less.

I don't think software should work like that. Software is not gold. It is not stock. It is a tool to get a job done, that's all.

So the question is: Would the economic model that Free Software forces us into provide incentives to write software greater than the cost of writing it? That is, will writing software still be profitable?

The answer is: Of course.

Let me put it to you this way. Let's say you want to get some software written for your business. You hire someone to write it, and they do a good job, so you pay them. The software was worth $1M to your business, and you paid the guy $100k to write it, so you take home $900k in pure profit. Now, this software has already paid for itself. If you released it to the public, you may be giving your competitors a $100k advantage you did not have, but they will likely contribute changes that increase the value of the software. Ask yourself: Is this software the core part of your business, or is it just a tool to get a job done? If it's just a tool, why are you trying to hoard the good tools for yourself? What economic benefit does it have to keep it from being innovated upon?

Another scenario: There are businesses that would like to have software written, but it would only be worth $100k to them while it would cost $1M to write the software. In this scenario, it makes no sense for any one business to hire someone to write it. However, some entrepreneurial minded individuals could figure out that they could write the software and sell copies at $10k. Their $1M investment would be covered by only 100 sales, and they anticipate they could sell 1,000 copies the first year. While this would work in the short run, eventually, businesses will want to modify and use the software in ways the developers could not anticipate. The licensing models will become more of a burden and these hidden costs will begin to come to light. Instead, if the companies could fork over their money to a known reputable developer who would develop the software and then release it as Free Software, they could get their software with only a small initial investment. The best part is that it will be theirs forever, with no restrictions, which is much more than you typically get if you hire someone to write software for you.

It simply makes economic sense for companies to pool their resources in development firms that write Free Software. In today's environment, there are companies like Red Hat which pretty much do that. Instead of charging for people to write software, they provide support contracts. The support contracts are basically promises to adapt the software to the needs of the business. It also assumes some of the risk that there may be a lot more adaptation than was expected. Businesses love pushing risk on to someone else, and so this is the ideal model --- a sort of insurance that you will have the software you need and it will be supported.

It may be hard to get companies to fund development for future software, but there is a way around this too. Simply put, large companies can fund research labs. The research produced by these labs could be released as Free Software. Not only will this open up their labs to collaboration from around the world, it will help them find the top developers and software scientists and recruit them for their organization. That is, developing Free Software can be part of any company's R&D budget.

Well, it may be pie-in-the-sky thinking to get companies to do this, but it isn't hard to imagine universities and colleges, funded by private individuals and companies, to do so. After all, in the academic world, sharing is the core essential component that all agree is important. Perhaps instead we need to focus on getting colleges and universities working on Free Software that can benefit us all, and then getting companies that use software to donate money to them to make better software.

Once you ignore the absurd margins of commercial software and see software as just a tool, it becomes clear that there are plenty of ways to make money. At the very least, carpenters make money fine despite using common tools that anyone has access to.

TL;DR?

Use GPL software and nothing else. Thank me later!