Ian Murdock
It is said that the only things certain in life are death and taxes. For those of us in the IT industry, we can add one more to the list: commoditization. The question is, how do we deal with it, particularly if we are IT vendors and not simply IT consumers, for whom commoditization is an unquestionably positive event?
Commoditization is something that happens to every successful industry eventually—success attracts attention, and there are always competitors willing to offer lower prices to compensate for lesser-known brands or "good enough" quality, as well as customers to whom price means more than brand, quality, or anything else the high-end providers have to offer.
Often, to remain competitive at lower price points, the low-end provider employs a strategy of imitation—for example, investing less in research and development than its high-end peers, and instead relying on the high-end providers to "fight it out" and establish standards and best practices it can then imitate in its own products.
This strategy works because success also breeds interoperability. Unless a company monopolizes a market (a temporary condition, given today's antitrust laws), an industry eventually coalesces around a series of de facto standards that govern how competing products work with each other, or how consumers interact with like products from different vendors. In other words, given time and a large enough market, every industry naturally develops its own lingua franca.
This kind of natural standardization is good for consumers and for the world as a whole. Few people, for example, would know how to type if every typewriter used a different layout for its keys, and the telephone wouldn't be in widespread use today if each carrier's network couldn't talk to any of its competitors' networks. And where would we be today without the descendants of typewriters and telephones—namely, computer keyboards and telecommunications?
Of course, from any incumbent's point of view, an ideal world would allow, say, the market leader in typewriters to own the layout of its product's keys, so anyone who learned to type using its product would face huge barriers to switching to a competitor's product. Fortunately, the layout of a typewriter's keys and similar interoperability features are very difficult proprietary positions to enforce, so once a standard way of interoperating emerges, all vendors are free to imitate that standard in their own products.
The moral of the story is that standardization, and thus commoditization, are both natural market forces as well as key events in human history. When an industry matures and competing products become more or less interchangeable commodities, this allows new industries to build atop them to create new and innovative products that would not have otherwise been possible if the industries they built upon had not standardized. In the case of typewriters and telephones, it is clear that the industries they enabled—the computer industry, e-commerce, etc.—greatly exceed the size of the industries that enabled them, both economically and in their contribution to human progress.
So, how do incumbent firms fight commoditization? Another moral of the story is that they shouldn't. The forces of commoditization, being natural market forces, cannot be beaten. Yet time and time again, incumbent firms fight them. First, the challengers are ignored or dismissed as cheap knockoffs, unsuitable for any but the least-demanding customer. Then they are ridiculed for lacking imagination and innovation. Then, invariably, they are imitated—but by this point, it is too late, as the market has fundamentally changed, and the incumbent finds itself unable to compete because the challengers were built for a commodity market and the incumbent was not. In very simple terms, this is Clayton Christensen's Innovator's Dilemma at work.
This chapter argues that the open source movement is just another commoditization event and that, like other commoditization events, it represents a disruptive shift in the software industry as well as an opportunity for entrant firms to unseat the established firms against seemingly overwhelming odds. That being said, commoditization does not equate to certain death to the established firms if they have the vision to see beyond the disruptive events that may befall them in the short term and can adapt themselves to the new commodity environment. Above all, this chapter aims to convey that commoditization is a natural and unstoppable force that is good for everyone involved—if that force is allowed to develop on its natural course.
The computer industry managed to escape the forces of commoditization for the first 20 years or so of its life—a natural occurrence given the industry was young enough and small enough that standards had not yet had the opportunity to emerge. In the first two decades of the industry, computer manufacturers delivered an end-to-end solution to the customer, from the hardware on up through the operating system software that ran the hardware to the applications that ran on top of the operating system. Every layer of the stack—and, most importantly, the interfaces between them—was proprietary to the computer vendor. As a result, every computer spoke a different "language," and it was difficult to get different types of computers to "talk to each other" and interoperate.
Because of these incompatibilities, the initial choice of hardware implicitly tied the buyer to an operating system; in turn, the operating system dictated what applications the buyer would be able to use. Over time, the high cost of computing technology made it financially impractical for the buyer to move away from the incumbent vendor because previous investments in that vendor's technology would have to be discarded. The combination caused users to become "locked in" to a single vendor.
However, as the industry matured, the dynamic changed. Entrant firms such as Apple, Apollo, and Sun saw the opportunity to create products that targeted an entirely new class of computing consumer—the individual user—that could not afford the mainframes and minicomputers sold by established firms such as IBM, DEC, and Data General.
By focusing on "good-enough" quality and lower prices, and by tapping into years of consumer frustration caused by batch processing, timesharing, and incompatibility between proprietary stacks, the new "personal computing" products were received enthusiastically and began to appear in offices and dens everywhere.
The strategies employed by one entrant firm in particular and one established firm in particular would forever change the computer industry. The latter, ironically, would lead directly to the commoditization of the hardware industry, and the former would lead directly to the ongoing commoditization of the software industry.
On the hardware side, IBM sought to stem the rising tide of Apple by introducing its own personal computing product, the IBM PC. Because of internal cost structures designed around multimillion-dollar mainframe products as well as an aggressive product launch timeline, IBM decided to use off-the-shelf parts for the IBM PC instead of following its traditional approach of developing proprietary components in house.
On the software side, Sun sought to attain a competitive advantage against the proprietary stacks of the mainframe and minicomputer vendors by basing its workstation products on the Unix operating system. Unix was already hugely popular in academia and corporate research labs, so this approach gave Sun instant access to a large portfolio of compatible applications as well as an enormous user base already familiar with the operating system that shipped on its products.
In other words, Unix was an open system—that is, a system based on open standards. Unix variants from different groups (for example, AT&T Unix and BSD Unix, the two variants in widespread use in the early 1980s) were largely based on the same APIs. Because of this, applications could be easily ported from one version of Unix to another, and users familiar with one version of Unix could easily learn to operate a different version.