By any measure, the rise of open source software as an alternative to the old proprietary ways has been remarkable. Today, there are tens of millions of libraries hosted at GitHub alone, and the number of major projects is growing rapidly. As of this writing the Apache Software Foundationhosts over 300 projects, while the Linux Foundation supports over 60.  Meanwhile, the more narrowly-focused OpenStack Foundation boasts 60,000 members living in more than 180 countries.

So what could possibly be wrong with this picture?

What’s missing is enough awareness that while open source software can meet the great majority of user demands, it can’t, standing alone, meet all of them. Worse yet, too many members of the open source community (business leads as well as developers) have no interest in making use of the most appropriate tools available to close the gap.

Let’s start by identifying the problem that needs to be solved, and then see how that problem used to be solved in the past.

The problem is that there are often many projects trying to solve the same small piece of a larger problem. Customers want to be able to have a choice among competing products, and be able to easily switch among products if they’re not satisfied. That’s not possible right now, and until this problem is solved, it will hold back open source adoption.

It’s also not a new problem, or a problem without traditional solutions. Over the course of a century and a half, user expectations of broad choice and freedom to switch vendors were satisfied through the development of standards. In the physical world, you can choose between myriad vendors of screws, lightbulbs, tires, extension cords, and even of the proper shape wine glass for the your pour of choice because standards provide the physical specifications for each of these goods. In the world of health and safety, our wellbeing relies on thousands of private-sector developed standards that ensure proper results while maximizing competition.

When information and communications technology (ICT) came along, the same approach was taken with the formation of major organizations such as the International Telecommunication Union (ITU), International Electrotechnical Commission (IEC), and the Standards Association of the Institute of Electrical and Electronics Engineers (IEEE-SA). Close to 1,000 consortia followed thereafter to develop, promote or test compliance with ICT standards.

While not all ITC standards resulted in seamless interoperability, the technology world we live in today exists courtesy of the tens of thousands of essential standards that do fulfill that promise, as implemented in computers, mobile devices, Wi-Fi routers, and indeed everything else that runs on electricity.

The point here is that over a very long time a system evolved that could meet customer desires to have broad product offerings, avoid vendor lock in, and enjoy services on a global basis.

Now let’s look at how open software is evolving.

The good news is that great software is being created. The bad news is that in many key areas, like cloud computing and network virtualization, no single foundation is developing the entire stack. Instead, discrete projects develop individual layers, or parts of layers, and then rely on real-time, goodwill-based collaboration up and down the stack among peer projects. When this process works well, the results are good, but have the potential to result in lock in the same way that traditional proprietary products could. When the process works badly, it has the potential to result in much wasted time and effort for vendors and community members, as well as disappointment of customer expectations.

The clear way to provide a solution is to create standards that allow customers to avoid lock in, and to encourage the availability of multiple solutions competing through the addition of value-added features and services. But with rare exceptions, that’s not what’s happening in the world of open source.

A main reason behind this is that the prevailing opinion in the open source community is that standards are limiting, irrelevant and unnecessary. Within a single, well integrated stack, that may be the case. But for customers that want freedom of choice, and ongoing, robust competition, the result could be a return to the bad old days of lock in to a technology, albeit with multiple vendors offering similar integrated stacks.

A good description of the problem at hand can be found in a June 14, 2017 article written by Yaron Haviv, titled We’ll Be Enslaved to Proprietary Clouds Unless We Collaborate: 

Cross project integration is not exactly prevalent in today’s open source ecosystem, and it’s a problem. Open source projects that enable large scale collaboration and are built on a layered and modular architecture – such as Linux – have proven their success time and again. But the Linux ideology stands in stark contrast to the general state of much of today’s open source community.  

Case in point: big data ecosystems, where numerous overlapping implementations rarely share components or use common APIs and layers. They also tend to lack standard wire protocols and each processing framework (think Spark, Presto and Flink) has its own data source API.  

This lack of collaboration is causing angst. Without it, projects are not interchangeable, resulting in negative repercussions for customers by essentially locking them in, and slowing down, the evolution of projects because each one has to start from scratch and re-invent the wheel.

Haviv proposes two ways to resolve the situation:

• Closer collaboration among projects, leading to consolidation, the elimination of overlaps between multiple projects, and tighter integration within a stack;
• The development of APIs to make switching easier.

Both of these approaches make sense. But unless something changes, we’ll see only the first and not the second, and that’s where the prospect for lock in can be found. The result would be where the industry found itself in the WinTel world of the past, or Apple throughout its history, where competing product choice is sacrificed in exchange for tight integration.

The same thing can, and likely will, happen in the new open source world if open source projects continue to ignore the need for standards so that competition can exist within layers, and even between stacks. Where things stand today, there’s almost no chance of that happening.

The reason is that while some projects pay lip service to developing software first and standards later, there is no real interest in following through with the standards. The main reason for that is that most business people and developers don’t know much about standards. Unfortunately, that’s all too understandable, and likely to get worse. The reasons are several:

• Universities dedicate almost no training time to standards;
• Companies that used to have staffs of standards professionals have disbanded those departments and now deploy engineers with far less training to participate in standards organizations;
• There is little career value in establishing expertise in representing an employer in standards work;
• Engineers participating in standards activities may be required to further the strategic interests of their employer at the cost of what they believe to be the best technical solution;
• There is little to no communication between open source developers and standards professionals within many companies;
• Many software engineers view standards as being in direct conflict with the “four freedoms” underlying the FOSS definition.

Now let’s look at what’s going on in the world of open source:

• It would be difficult for any software engineer today not to know about open source;
• It’s a tool engineers are comfortable with and often use on a daily basis;
• Much of the sexiest, most cutting edge work is being done in open source projects;
• Developers with expertise in hot open source areas are much sought after and command substantial compensation premiums;
• Developers enjoy unprecedented autonomy in developing software within well-respected projects;
• Virtually all of the major ICT companies participate in multiple open source projects, often with a combined dues plus dedicated employee cost of over $1 million per year per company at the highest membership level.

When viewed in a vacuum, this comparison would seem to indicate that standards are headed for the ash heap of history in ICT. But the reality is more nuanced. It also ignores the reality that open source development can be a more delicate flower than many might assume. The reasons include the following:

• Major supporters of projects can, and in the past sometimes have, decommited, leading to the failure of a project;
• Personality and cultural conflicts within communities can lead to disruptions;
• The ability of key projects to more tightly integrate remains to be seen;
• Proprietary game playing has sometimes undercut, and in some cases caused the failure, of highly funded open source projects;
• Over time, individual companies may decide that their open source strategies have failed to bring the rewards they anticipated;
• A few well-publicized failures of key open source projects could lead vendors to back off from investing in new projects, and persuade customers to be wary of committing to open source solutions.

Curiously enough, the collaborative entities that are addressing these issues most aggressively are standards organizations, in part because they feel (rightly) threatened by the rise of open source collaboration. Their responses include upgrading their intellectual property rights policies to allow all types of collaboration to occur under the same umbrella, including development of open source tools, inclusion of open source code in standards, and development of open source reference implementations of standards, among other types of work project.

The result is that standards organizations are re-tooling themselves to provide an approach-neutral venue for the development of complete solutions. Those solutions can incorporate whatever type of collaborative work product, or hybrid work product, the marketplace may need. As this process continues, it is likely that vendors will begin to pursue some initiatives within standards organizations that might otherwise have made their way to open source foundations.

For all these reasons, it’s crucial that open source projects get serious about including standards in their deliverables, or in the alternative partner with appropriate standards developers to jointly provide complete solutions. The result will be not only greater product choice and less customer lock in, but far greater confidence by customers in open source solutions, and therefore far greater demand for and use of open source products and services.

If that doesn’t happen it will be a great shame, because the open source cause has the most to lose. It’s up to the projects now to decide whether to give the market what it wants and needs, or reconcile themselves to a future of decreasing influence rather than continuing success.