(this topic is also discussed in a podcast episode)
One of the paradoxes in product development is Open Source. How can you personally or as a company benefit from participating in Open Source projects? Why should you share your great ideas and code? How can you build a business or a career by giving things away? How can an open-source project be a reliable supplier without contractual guarantees? Most successful technology companies today participate in open-source projects. Why do they do this?
Open source is difficult to fully understand and much has been said about it. There are many approaches to licensing and funding. Many question the equity and sustainability. Many get bogged down in ethical, moral, and political arguments. There are messy problems that don’t seem to have good answers. But we need to go deeper and examine the core issues of why companies are turning to open-source.
We will consider several product development perspectives:
- Our motivation is to produce something of value that society can use and benefit from.
- Software technology is advancing at a rapid rate of change.
- Technology in modern systems is increasingly complex.
- How can we maintain some level of control over the resources we use to ensure they will meet our needs?
- And how does organizational culture impact our ability to deal with these issues and build modern systems?
The value of software is hard to quantify, and breakthroughs are difficult to predict. New software algorithms, methods, languages, and structures are sometimes much more effective than previous ones. It is these non-linear breakthroughs that we must leverage. Software is an unbounded sphere of opportunity, free from the constraints of physical locality, physical devices, duplication costs, and, in many cases, computing resources. Modern computers, even those we hold in our hands, are capable of running more software than we can write in multiple lifetimes and storing a lot of information. Systems that improve human efficiency and capability potentially add value and wealth to society. The best software can do more with simpler expressions and less effort. The best software can scale to larger problems. The best software is easier to maintain and thus the rate at which value is added over the long term increases. The best software is more reliable and can be easily deployed without worrying about it crashing or malfunctioning.
We should clarify our use of the term complexity — we are talking about inherent and necessary complexity, not artificial, human-created complexity (some call this accidental complexity). The human body is incredibly complex, but this is necessary for it to do all the things it does. Modern microprocessors are complex, but they need to be in order to do the amount of processing they do. The Linux kernel is complex, but only because this is required. In modern systems, software is potentially orders of magnitude more complex than hardware. We might spend X hours designing the hardware and XY hours writing and maintaining the software over the lifecycle of the product. This is hard to comprehend because the hardware can be seen, but the software is largely invisible. Software is increasingly the driver of value in modern systems, whether the systems are products or processes.
The development of hardware versus software requires a different mindset and process. With hardware, the effort is mostly in the initial development as we design, specify, and integrate the components needed. Once designed or qualified, a hardware component can be used for 5 or 10 years with very few changes. Its value is driven by minimizing variance (change), which is how we define hardware quality. Software systems are completely different — the inherent value in software is that it can be changed over a product lifecycle and its value subsequently increases, so the value in software comes from maximizing (instead of minimizing) changes. Software in a product may be updated hundreds or even thousands of times over its life. This is why it is so difficult for a company that is really good at hardware to also be good at software, or vice versa — a different culture and mindset are required.
How can we secure and have some level of control over the critical software components we need to build products? First, we should clarify the scope of the problem. Modern systems are increasingly assembled from hardware and software components we did not create ourselves. In a Linux-based system, there are many millions of lines of source code. The few thousands of lines of custom application code we might write for a product, which may represent many man-years of effort, are only a drop in the bucket compared to the rest of the software running in the system. However, it is easy to ignore the “rest” of the software, as it is largely invisible. How you manage the “rest” is critically important and perhaps the hardest part. And this “rest” is increasingly being supplied by open-source projects. Many engineers are good at creating things from scratch, but fewer are good at understanding, modifying, debugging, and managing software technology that others create. This skill is increasingly valuable.
Ideally, we would create everything we need and not be dependent on anyone else. However, we won’t get very far on our own if we need to create our own microprocessors, operating systems, programming languages, databases, and the myriad of other components needed to build systems. Likewise, these components by themselves are of little value unless they are combined into a larger system to do something useful. No one person, company, or even nation can build and maintain all the technology building blocks required to build modern systems. Human success is largely dependent on the degree to which we are able to work with others. The scope of the Linux kernel is beyond even the largest companies or governments. Even if an organization had the manpower, it would likely not have the culture required to pull off a project like the Linux kernel, the PostgreSQL database, or many other useful OSS projects. For smaller organizations, the capability to build even the most basic building blocks is often beyond our reach.
Thus far we have established that to create value with modern systems, we must be able to build complex systems using software technology, much of which we did not create, and be able to change this software over time to deliver more value. In all this, we must have some level of control over this software. If there are problems, can we fix them? Can improvements be implemented and new features added? Secondly, can we influence development over time if we are not doing it ourselves? When we source software technology, there are many options, but let’s reduce it to two for the purpose of discussion:
- Find a vendor with a proprietary software product. Initially, it fits our requirements — at least during the sales cycle. As changes/fixes are needed in the future, this vendor is hired to provide these updates or we work around them.
- Find an open-source software project. We may purchase support from a company supporting this project or we may make needed changes ourselves.
There are no doubt times when #1 is the best solution, but increasingly #2 is being chosen. Why is this?
Let’s again review the challenges with software development:
- Obtaining the software we need (value), as we only have the resources to write a tiny fraction of it.
- Making changes over the product lifecycle, as this is where value is added.
- Having some level of control and influence over the software we use.
- Managing the extreme complexity of modern systems.
- Providing an environment and finding the people where software innovation can happen (culture).
As we review these challenges, we start to realize that the primary benefits of open-source software are cultural. Software innovation is not created with a manufacturing-type mentality but is more art than science — a process of discovery, experimentation, collaboration, inspiration, and simplification. Developing great algorithms and code is a creative process that cannot be easily planned or scheduled, other than allocating the resources and time to work on it. The development of software innovations is not always predictable and cannot be forced. It requires the rare combination of the right people, the right environment, the right level of collaboration, and the freedom to experiment and innovate. All these conditions rarely exist inside corporations. Companies are realizing they cannot always hire the people needed or provide the environment for the level of innovation required. So the next best thing is to support open source projects where this innovation is happening. There are two ways to do this: time and funding.
Many authors of innovative software projects are driven by the craft itself, not wealth. Funding is necessary, but they are not working on a project to become rich — there are much easier ways to make money. They are driven by the intrinsic challenge, the joy of discovery, and the reward of building something useful. The first step in making sure an open-source project will be maintained and available in the future is to ensure that the authors have the funding they need. There will never be perfect equity in that authors will receive exact compensation proportional to the value they create, but this matters little to most OSS authors, and in reality, this is also the case with most developers employed by companies. Many developers are more than satisfied with earning a good living and having the freedom to work on whatever they choose. Most are generous and glad to see their work being used. However, there are cases where OSS authors do not receive funding comparable to what they could earn working elsewhere, so it would be wise for companies to audit all the OSS components they are dependent on and ensure that these projects are adequately funded. Contributing financially also makes it more likely the authors of the project will respond to the company’s needs, but we need to be careful that this process does not become restrictive to the point where the environment for innovation is destroyed.
Contributing time (code, documentation, support, feedback, etc.) to open-source projects is another way to help ensure a project will be useful and available to companies needing it. Contributing to the community around an open-source project is critical for the project’s health and is part of the flywheel of innovation. If someone is a valuable contributor, then they will also have some influence on the direction and priorities of the project. They will become skilled at understanding and using the project. They will also become better programmers, as they work with some of the best in the world, and are exposed to well-written software. Open source projects provide an environment for innovation that is often not possible inside a company, so having your engineers do some work in OSS projects provides them with an alternative environment to do software development.
Why Open-Source Works
It is somewhat of a puzzle why the open-source environment works so well for software innovation. Transparency is a powerful tool for great work. When you do things in public, you do them better. In OSS projects, there are no barriers to working with the best people in the world. Freedom is likely another ingredient. When there is the latitude to experiment, it is more likely that new and better methods will be discovered. Formal software development methodologies are good at managing more predictable efforts to solve business problems, but they seem to be of less value in OSS projects at driving innovation. Each successful OSS project is different than the previous one and is a unique combination of various factors that cannot be easily replicated.
Many people still stumble at the fact that if my company contributes to an open-source project, we are helping our competitors. This is true. However, if we don’t participate in open-source projects, we likely won’t get to where we need to go. It may no longer be optional. Open source is not like walking into a discount store and picking something off the shelf at a tremendously good deal. It is not a one-time decision where we select something and are done. It is an ongoing process of continual change and improvement. And the better we are integrated into this process, the more we can leverage and use open source. Economic opportunity is not a fixed-sized pie, where we are all competing for the largest slice. With software, the duplication costs are near zero, so this is a perfect opportunity for economic growth or an overall increase in society’s wealth. We can work to grow the size of the pie, so everyone can have a larger slice.
Often in writing, the author learns and understands things he did not know before, and this essay is no exception. The benefits of open source are not primarily in getting stuff for free or pooling resources in a socialist sense for the greater common good, but rather in providing an environment and connecting the right people for innovation to happen. This dynamic has happened occasionally in the past inside companies such as Bell Labs and Lockheed Martin’s Skunk Works. But this environment is obviously difficult to replicate or more companies would do so. Even the largest and most successful technology companies, such as Google and Facebook, aggressively support and promote open source. At the time of this writing, Google employs over 27,000 engineers — why would they need open-source projects? With that number of developers, why can’t they create anything they would ever need? Google’s support for OSS projects is not an altruistic gesture, but rather a calculated business decision — they are supporting the processes and people that will produce the software technology they need. This is a long-term game that requires experience, skill, understanding, and patience. It is an example of humility, which is the source of all true greatness — the realization that there are some things I cannot do, even if I have huge financial resources. It is the realization that there are people out there who are much better at certain tasks than anyone in my company or anyone I can hire. It is the realization that my company organization is not the perfect environment for the development of needed software breakthroughs and highly refined building blocks, so we need to support projects that are. Because it is counterintuitive, many companies will not make this leap, especially those who have been successful in the past without it, or those building products that in the past did not require advanced software systems. Ironically, it is often the smaller companies that need OSS components the most that are resistant to adopting and contributing to OSS projects. However, the opportunity is available for anyone to participate, support, influence, and use the most advanced software innovations available today. And these innovations are largely happening in OSS projects. Your engineers can work with some of the most gifted developers in the world and learn skills that will greatly enhance their careers and benefit your organization. You will be plugged into an engine of innovation that produces value. You will have more control over the needed building blocks. You can be part of the process that produces the valuable software you need, rather than just a consumer.
Open-source projects are far from perfect. They are messy at times, as human efforts tend to be. Their future is not guaranteed, but nothing in this world is guaranteed. The lack of formal business contracts/methods is perplexing to most business people. However, open source appears to be the best model we’ve discovered thus far for software innovation, and the results are amazing. Open source is the only supply chain that can deliver the needed value, innovate and change, manage the increasing complexity, give you some amount of control, and provide the culture necessary for innovation. Will you be a part of it?