TV viewers and network professionals alike love the idea of faceoffs. What would happen if a hippo fought an alligator, a lion fought a leopard? Hot stuff. On the network side, we’ve already had “Who wins, Ethernet or IP (or maybe ATM)?” and now perhaps we’re looking at the ultimate tech faceoff, which is “Open-Source Versus Consolidation.” We’re seeing vendor consolidation potentially driving down the number of vendors and products. We’re seeing open-source software displace proprietary software, even the stuff embedded in devices. Will one reinforce the other, or somehow change the market dynamic?
Tech is commoditizing, meaning that vendors in the space are losing feature differentiation. That happens for a number of reasons, the most obvious of which is that you run out of useful features. Other reasons include the difficulty in making less-obvious features matter to buyers, lack of insight by vendors into what’s useful to start off with, and difficulty in getting media access for any story that’s not a promise of total revolution. Whatever the reason, or combination of reasons, it’s getting harder for network vendors to promote features they offer as the reasons to buy their stuff. What’s left, obviously, is price.
A parallel truth is making price all-the-more important; networking is itself under benefit pressure. Network operators have been struggling with falling ROI on infrastructure, businesses have been struggling to find new productivity gains that would justify additional network investment. Till these negative pressures are resolved, the lack of benefits to draw on means more pressure on network costs, meaning network equipment prices.
Just as there are parallel factors driving this, there are parallel responses to it. On the vendor side, commoditization tends to force consolidation. A vendor who doesn’t have a nice market share has little to hope for but slow decline. A couple such vendors (like Infinera and Coriant, recently) can combine with the hope that the combination will be more survivable than the individual companies were likely to be. Consolidation weeds out industry inefficiencies like parallel costly operations structures, and so makes the remaining players stronger.
Or that’s the theory. Even if we assumed that regulators wouldn’t balk at the notion of an industry of competitors vanishing into the black hole of a single giant, that giant now has no option but to face the continued pressure another way. If there was one, all that consolidating would likely never have happened.
On the user/buyer side, the related trend is open-source software and open devices. “Open” in the former case means that the software is developed not by a single vendor who then gains a measure of control over it (and its buyers), but by a collective who presumably operate for the good of a much larger group. DT just joined the Linux Foundation Networking open-source group, where things like ONAP live, and they’re an operator not a software developer. Many operators are getting into open-source in the hope it will cut their costs, improving their ROI.
Open devices are a little different and yet the same. Open-source software arguably promotes enhanced capability, but most people believe open devices promote or at least acknowledge commoditization. By developing a technical model for a device that anyone can build to, you increase the number of builders and the competition. Since you can’t compete on a common device model, that means price competition, which again improves the buyers’ ROI.
Open-source also arguably commoditizes devices directly, because most functionality these days is created by software running on fairly generic hardware. If you pull the software features away from hardware platforms by making the software available in open-source form, then the platforms themselves are robbed of feature differentiation, have to compete with the open-source solutions, and end up being only price-differentiated.
Commoditization, of course, is the same whether vendors drive it in the hope of surviving (even as an absorbed part of a larger organism) or it’s driven by creating a non-differentiable product model. The question is not whether you end up with commoditization, but what gets commoditized, and how that impacts the market overall.
Imagine a single giant router vendor, the only one in the universe. Would that vendor be a benign dictator of the market? Cisco, the closest thing we have now to that super-predator, is rarely seen as “benign” even today. The truth is that pure vendor-side commoditization probably has a natural counterforce created by the fact that as a player gets bigger, they tend to be seen as less trustworthy. A bunch of studies have suggested that you end up with three players through this natural force-and-counterforce faceoff.
Imagine a single open-source project addressing any single functional area, whether it’s server OS or routing instance. The project is funded by members, and presumably people don’t continue funding it if their objectives aren’t being met. You end up with other projects with the same goal, and they in turn compete for money/membership. Doesn’t this end up creating those same three competitors, and therefore is our faceoff a draw?
Nope. The difference is that because software creates differentiable features, and does so with an overhead and delay modest in comparison with what hardware would generate, it promotes a series of alternative approaches to the same problem, tuned to slightly different needs. It’s hard to name any single product area where open-source has converged on a single solution. Even Linux (perhaps the most successful open-source thing of all time) or Java have competition. As long as there are differences in mission, in requirements, we can expect different open-source projects providing different solutions.
That doesn’t mean that vendors are safe. What I think we’re seeing is a lot more complicated than hippo versus croc. Open-source software could be sucking the innovation out of proprietary technology. We’ve talked for a decade about an increased role for software in networking, a model for network devices that’s similar to one we have for servers, laptops, and even phones. Network vendors were hardly on board, and now it may be too late.
Buyers have the bit in their teeth. They know that many vendors now embrace the shift to software-centric networking, but they also know that if that shift is based on proprietary software, it only substitutes one kind of lock-in for another. Open-source is their answer, and it’s framing the features of the future for virtually everything, and as it does that it’s creating the functional requirements for the hardware that optimally supports it. There’s an increased interest in making even specialized silicon an option; look at THIS work on FPGA use in Ethernet adapters and the P4 flow control language with plugins for various hardware elements.
Open-source isn’t perfect, though. Most of today’s open-source projects in networking are flawed, some deeply, in their architecture. In fact, we don’t have an overall architecture to describe how a software-centric world would serve both the functional and management needs of network buyers. There is still time for vendors to do something truly insightful and innovative, and address a network challenge the right way, before the broad community driving open-source figures out an approach that can lead to an optimum solution. If they don’t…well, a big enough croc can eat a hippo.