Open Source Benefits for UsersEric Wilhelm
Let's just say that you're going to pay the same price for your software. Would you rather have open source or not? If everyone is using open source software only because it is free, innovation will only ever be sustainable in the world of proprietary software.
Freedom. Not Free Beer
The desire for freedom, which started the open source movement, stems from a desire to be free to share ideas. By coincidence, software is a special kind of idea which can be rendered into an executable form. Thus, the freedoms which are required to facilitate the sharing of ideas also happen to enable freeloading.
Unfortunately, some proponents of open-source software argue that money is saved because the software is no-cost. This leads to pointlessly generalized discussions of "total cost of ownership", because such analyses are only valid for specific, quantifiable situations. Discussing the TCO of Open Source software in general terms is like saying that apples cost more than oranges without the geographic context of whether you are in Washington or Florida.
By assuming that you are going to pay the same price for open source software as an alternative to the proprietary offering, I have implied that this software is being developed not by a group of volunteers who are happy to give away their work, but by a group of professionals. The question here is whether software with available and modifiable source code would be of more value than a binary executable.
To hear a lot of economists talk, customers are a group of incredibly selfish people and companies that would cease to pay you at all if your code were open source. This might be a sad fact of human nature, but that is a subject for another article. Because this discussion is focussed on who gets what benefits from open source development, I will assume that we are talking about paying customers and examine what they get for their money.
If you pay for open source software, you are not going to have to compile the program yourself or write any code to use it. When volunteer developers openly publish their code, they do not gain much benefit by making it easier for the average user to install it, so they will often only distribute the source in an assembly-required fashion. In this discussion, the assumption is that you paid a professional vendor for open source software which they created. Given the price that you've paid, you should expect professional service and a professional product. Thus, for the purposes of this discussion, open source starts on equal footing with proprietary software with the exception of the rights that have been granted to you under the license.
An open source development process yields a higher quality ceiling and a lower bug floor than anything possible in a proprietary model. If nothing else, this comes from the ability to massively scale quality-control efforts beyond the walls of a single company. Because of the transparency of source code, users are able to file better bug reports and the vendor can never get away with claiming "not my problem" if the guilty code is clearly visible.
In the case of networked software, security audits can be performed by multiple third parties which are either hired by customers or operating under their own volition. Similar processes become possible for verifying the correctness of the software in mission-critical situations.
Additionally, code which is publicly visible is bound to be cleaner because each programmer knows that the entire world could be watching. The pressure of deadlines can often lead to less-than-beautiful code getting written into a proprietary product, with little incentive to go back and reconsider it. The self-censorship that results from working in a fishbowl leads to better software because you simply cannot build something beautiful out of ugly parts.
When you possess the source code to your application, there is no technical, economic, or political event which could completely render the software unusable and leave your data stranded in an inaccessible format. When you have seen even large companies come and go, you become more concerned about the long-term survivability of your investments.
Proprietary software companies have a rather unlikable tendency to build lock-in strategies into their software. This is often done via opaque file-formats or protocols. If you have the source code and the right to modify it, your vendor cannot use these strategies to create artificial barriers to migration and competition.
Additionally, in core-business applications, you may be investing a great deal of time and money in training your staff, data conversion, etc. This effectively locks you to a particular package even in a healthy, competitive market of alternatives. If you have to make a decision to change vendors, the cost of changing can be significant even if it is only due to retraining.
With open source software, a lazy or dishonest vendor has to compete on an even playing field. The first-mover may have seniority, but still has to retain their customer's respect or they can be outdone by any company that understands the software well enough to change or modify it.
Large contracts have commonly contained code escrow clauses to provide future-proofness, but only an open source process guarantees that "the customer is always right" and brings this benefit to mass-market customers.
When your in-house developers or IT staff can see the source code to an application, they are able to collaborate with the vendor in ways that are hindered by legalities with proprietary software. Additionally, you are able to assume some ownership of the software because of all the rights granted to you by a liberal source code license.
Furthermore, if you know that what you invest in the software cannot be taken away, you are able to act as a partner with your vendor. The opportunity to shape software to your needs is something that justifies as much or more investment as the per-seat licensing that many customers have been paying for proprietary software.
Creative Misuse of Software
It is important for a vendor to use their own software, but as with bug reports, they cannot possibly have as many people using their software inside their company as outside. Some users are bound to have good ideas and find ways to use the software that the developer never intended. Some of these ideas will turn into features that attract more customers, creating a healthier product with a thriving community of users.
Many users have difficulty sharing data between programs because each program uses its own proprietary file format or the programs do not support a common standard format. With open source software, there is no such thing as a proprietary format because the code used to create it is in plain view for all to see.
Not only does open source enable the possibility of easily exchanged files, it also makes it possible for software from different vendors and even disciplines to communicate on a higher level. If a vendor were to invest the effort to establish and implement a communication protocol with a proprietary third-party program, they would have to simply trust that that the other vendor would play nice and not change anything to break the protocol. If the third-party product is open source, the developer can clearly see how to connect to it, and they also get future-proofness.
With such a low barrier-to-entry, open source software makes an ideal vehicle for research projects. Many topics in software require a great deal of infrastructure before any interesting code can be written. Students which previously could only theorize about a particular idea can implement it within the context of an existing open source project.
Open source software also solves the problem of who should benefit from government research grants. If the results of the research are developed into open source software, taxpayers do not have to be upset about paying once to fund the development and again to purchase a software license.
Standards bodies are often committees composed of members with opposing interests. Such gatherings are notorious for never producing anything good. When too many people are pushing their own agenda in the same room, the result is often quite useless.
The Internet Engineering Task Force (IETF) requires a reference implementation for every proposed standard before it can become official. The idea behind this requirement is that it is much harder to do something than it is to talk about it. The "show me the code" approach to standards that happens in the open source development model eliminates haggling in favor of working solutions.
Transparency Tames Complexity
The complexity of a single program or a system of programs grows exponentially as more parts are connected to all of the other parts. New components are constantly introduced to our software system by adding features to existing programs or installing new programs. If each new component has the potential to interact with each other component, the number of potential new bugs is equal to the number of current components. With a black-box, it is difficult to determine why an error happens or who is responsible for it.
Open Source software is transparent because any qualified programmer can look into the inner workings and see all the way through to where the error occurs. You may find that the problem is actually in another program, but with open source software, you or any of your support personnel can find the answer much faster than you would otherwise.
Software is complicated, and secrets do not help. We have reached the point where freedom and transparency are worth paying for.
We've already seen volunteer projects build amazing open source software. But in the most successful cases, the developers have been users and the users have been developers. If consumers want the benefits of open-source software, they are going to have to either pay for it or wait a very, very long time. Most software that is usable to mainstream consumers and businesses requires intimate knowledge of the problem domain and at least some part of building it is no fun.
With all of the benefits that have been outlined above, professionally developed and supported open source software is easily the best choice for the user. Ultimately, such software may cost less than it would otherwise, but a purchase cost of zero absolutely cannot sustain innovation or allow a vendor to offer professional support and services.