Open Source Commentary from Navica's CEO,
Bernard Golden
July 2007
In This Issue
-
Commercial Open Source: Crossing the
Second Chasm
-
Follow up to last month's newsletter:
The Washington Post: Illustrating the Power of the New
Economics of IT
Commercial Open Source: Crossing the Second Chasm
If you’ve spent any time at all in the technology industry,
you’ve heard the phrase “crossing the chasm.”
This phrase, made famous in Geoffrey Moore’s book of
the same name, refers to a phenomenon of technology markets.
His theory breaks technology customers into a number of categories:
early adopter, laggard, and so on. You can see a chart representing
customer types and the location of the chasm in Figure 1.
If you examine the Figure, you’ll note that the chasm
separates early stage customers from mainstream customers,
with the former representing around 15% of a market, with
the latter representing around 85%, thereby illustrating why
crossing the chasm is so vital; most of the growth potential
and profits lies on the far side of the chasm. Moore’s
primary message is that there is a discontinuity between early
stage customers and mainstream customers: what worked for
early customers isn’t sufficient for later stage customers,
and satisfying the latter isn’t just a matter of doing
a bit more incrementally; in fact, there’s a chasm of
expectations between early stage and later stage customers.
Figure 1
Later stage customers expect far more than early stage customers,
and they expect a different type of offering from their providers.
While early customers are willing to live with incomplete
and non-fully featured products, across the chasm customers
demand fully functional products – but that’s
just the beginning; beyond the product itself, these customers
need great support, wide professional services availability,
easy integration with other products, and so on. In other
words, across the chasm customers need products easy to consume.
Moore calls them “whole products,” because they
have all the characteristics to succeed with mainstream customers.
Moore posits that getting a technology ready to address these
customer requirements is an enormous challenge – as
one might expect, given that a chasm must be crossed. The
crux of his argument is adding all these additional product
characteristics is a huge amount of work for small vendors
and requires different abilities than what got those vendors
to the chasm jumping-off point. While quick responses and
immediate customer satisfaction may have been enough to get
going, building out a professional services network and the
myriad of other tasks is a job of a different order. Not every
company successfully jumps the chasm.
Moore’s theory is extremely influential in the technology
industry. “Crossing the chasm” is as widely-bandied
about a phrase as there is. In fact, I used it in the Open
Source Maturity Model, noting that, for open source, finding
and evaluating the different resources that comprise a whole
product (which I called a mature product) is a different type
of task, given that many open source products emanate from
non-commercial communities or from tiny startups without the
resources to create whole products.
As you might expect, Moore’s theory is widely applied
to open source software markets. You often hear people asking
“has open source crossed the chasm?” I have heard
the question answered in the affirmative each of the past
four years, thereby indicating that open source has had the
most protracted crossing in history!
However, in presenting this notion, the people asserting
so confidently that open source has crossed the chasm have
overlooked a critical thing: it isn’t enough for commercial
open source companies that their products be adopted by mainstream
users; they have a second chasm to cross – and that
chasm is a lot tougher to get across.
That chasm is the chasm of payment; in other words, getting
a user to become a customer. If you look at Figure 2, you’ll
see that the location of this second chasm is far to the right
of the first one. Depending upon the individual product, most
open source companies estimate that approximately one in 1,000
users become customers; that is, the paying customer base
is only those companies lying beyond three standard deviations
from the mean.
Figure 2
Seen from the perspective of the traditional “crossing
the chasm” model, this situation is unheard of. The
traditional model has mainstream companies unwilling to buy
a technology until it’s a whole product; once the additional
characteristics are available, mainstream companies, according
to the model, turn into very willing buyers.
The situation with commercial open source appears to be vastly
different. In fact, it directly contradicts the traditional
model. In an upending of Moore’s formulation, it seems
that mainstream companies are adopting open source without
relying on a vendor - or, at least, without needing to purchase
the full range of capabilities from a vendor. Instead, it
appears that the leopards have changed their spots, and mainstream
companies are downloading open source software, putting it
into production, yet fleeing a financial relationship with
the provider.
What can account for this puzzling change in the behavior
of mainstream companies? Why are they confounding us with
their inconsistent comportment, their contradictory willingness
to overturn the time-honored truths of Geoffrey Moore? How
can we understand the reality of commercial open source and
better predict the future of open source software?
Definitive answers are not possible, but here are some thoughts
about what the second chasm might mean:
Reason #1: Open source hasn’t actually crossed
the first chasm
The prediction of Crossing the Chasm is that once a product
has all the secondary elements of a whole product, mainstream
customers will line up to purchase. Yet, despite the efforts
of commercial open source companies to provide all those elements,
very few companies actually buy.
Maybe it’s because open source really hasn’t
crossed the chasm and mainstream companies are not actually
using open source; that is, maybe open source is still the
province of early adopters, few of whom feel compelled to
buy because they are, generally speaking, self-reliant.
While this reason would account for why only 1 in 1,000 users
would buy, I’m not sure I buy this reason. After all,
some of the announced customers of commercial open source
companies don’t seem like risk-seeking early adopters.
MySQL claims the US Census Bureau, Avery Dennison, and Macy’s
as customers, which doesn’t sound like a risk-seeking
group to me.
Therefore, it seems that open source has crossed Moore’s
chasm. It’s just that those companies lying on the far
side of it aren’t behaving the way the model predicts.
It’s awful when reality doesn’t conform to hypothesis!
Reason #2: We’re using the wrong denominator
In this view, maybe that 1,000, of which only 1 becomes a
buyer, is a wrong number. Perhaps a large percentage of that
1,000 is not really made up of real product users, so we’ve
been using the wrong number as the denominator of the fraction
of users to buyers. Maybe most of that 1,000 is really irrelevant,
nothing more than students, experimenters, and idle riff-raff.
If you get rid of these, maybe you’re down to a one
in 100 or one in 50 ratio.
There’s obviously some truth in this reason. Everyone
acknowledges that downloads are not a very accurate measurement
of true interest in an open source product. Of course, that
hasn’t stopped anyone from using downloads as the metric
of open source success. Venture capitalists, in particular,
seem wedded to downloads as a key factor in funding decisions.
Even if the denominator is changed significantly, however,
this reason seems insufficient. Taking it to one in 100 or
one in 50 still seems radically inconsistent with how companies
should behave when a product crosses the chasm.
Reason #3: Maybe we’re in a transitional period
of customer behavior
It might be that we’re in an interregnum, partway between
the old order of proprietary software and the new order of
open source. While resting in this purgatory, the long-term
behavior of mainstream companies is masked due to confusion
or temporary giddiness at the new state of affairs in which
the formerly forbidden fruit of free software is now brazenly
on offer. Once free software is no longer novel and tempting,
mainstream customers will come to their senses and start behaving
like they used to; their conservative instincts will reassert
themselves in the future, and they’ll all become paying
customers.
While it’s emotionally tempting to view the one in
1,000 (or one in 100, if you accept the rationale advanced
in Reason #2) situation as a brief bacchanal, a temporary
loosening of quotidian morality, shortly to be superseded
by a return to stolid mainstream customer behavior, it’s
hard to see today’s perplexing refusal to buy as a short-lived
phenomenon.
It’s a cliché of the self-help movement (and
its IT counterpart, re-engineering) that people resist change.
If that’s the case, why would the mere business model
change represented by open source software be sufficient to
overturn long-established expectations and processes?
Frankly, it’s hard to see. Whatever the reason so few
mainstream companies buy from commercial open source providers,
it’s hard to imagine that it’s short-term. It
seems more likely that the current ratio will be consistent
into the future, and that some other reason must account for
it.
Reason #4: Non-buyers are free riders looking at
signals
It might be that the elements that pragmatic buyers traditionally
demand accompany new technologies are really necessary. Unless
and until the technology’s owner creates viable support,
training, professional services, etc., pragmatists may indeed
refuse to adopt the technology. And, once those elements are
available, pragmatists will eagerly embrace the technology.
However, nothing in the preceding paragraph implies that
pragmatists will buy the technology, just that pragmatists
will adopt the technology once those necessary elements are
in place – and adopting is different than buying!
It may be that, in the absence of paid license coercion,
pragmatists interpret the availability of the whole product
elements as sufficient for adoption; put another way, as soon
as those elements exist and someone is paying for them, pragmatists
will be satisfied about the product’s maturity. In evaluating
a product’s suitability, pragmatists look for signals
in others’ paying decisions; once someone else has taken
the (financial) plunge, the cheapskates reap free software.
In this view, the vast majority of pragmatists are free riders,
taking advantage of the company creating the whole (in Moore’s
sense of whole) open source product. In essence, these non-paying
pragmatists are gaming the system, allowing others to absorb
all the costs of crossing the chasm and siphoning off 99.9%
of the benefits.
There’s quite a lot to recommend this view, as it aligns
with the observed behavior of non-paying pragmatists that,
at first glance, seems so puzzling. On the other hand, opting
out of a paying relationship means that these pragmatists
have no “throat to choke,” no support source providing
the alleged all-important SLA. If one accepts that pragmatists
are risk-avoiding organizations, taking advantage of others’
efforts and payments seems out of character. After all, one
would hardly expect to see a pragmatist drive without insurance,
despite a lack of mandatory purchase.
Reason #5: The behavior of pragmatists really has
changed
Eliminate the impossible, said Sherlock Holmes, and whatever
is left, however, improbable, is the truth.
Having discarded all the other reasons for the quizzical
refusal by pragmatists to pay for open source software, we
must conclude that, for whatever reason, their behavior with
respect to open source truly is different than might be expected
from Moore’s theory.
It may be that the signaling reason advanced above does hold
– that pragmatists wait for someone to take the actions
that indicate product wholeness and then they feel comfortable
enough to adopt the product.
However, the assumption that the nature of pragmatists is
such that they would be impelled to purchase from the technology
supplier is wrong. Instead, they see the whole product as
indicating sufficient maturity but are individually willing
to rely on community support.
This is a troubling state of affairs – and not just
because these trustworthy pragmatists are showing an unexpected
willingness to drive sans insurance.
What’s more troubling is the question of how one segments
the pragmatist bloc to identify that portion of it that will
adhere to the traditional expectations about the bloc: demanding
of a whole product and willing to pay for it, too. In other
words, how do you identify users who will cross over the second
chasm and become customers? That will be the subject of next
month’s newsletter.
Follow up to last month's newsletter:
The Washington Post: Illustrating the Power of the New Economics
of IT
You may remember that I wrote about how Rob Curley's group
at The Washington Post is using open source software to power
offerings designed to make the paper more relevant to readers
and stave off the competition of the Internet. Just yesterday
it launched Loudounextra.com,
a site devoted to hyper-local news. You can read Rob's blog
posting about it here.
We'll see more of open source being used to break away from
the traditional role of IT in an effort to make companies
more competitive and innovative.
Navica News
You can hear me speak at these upcoming events:
I participated in a podcast regarding GPL3 with several other
people involved in open source. Our conclusion: meet the new
boss, same as the old boss; however, not all was unanimity.
Listen to the podcast here.
July 24, 8:00 a.m. PDT: "Succeeding with Open Source:
Implementing a Winning Governance Strategy", webinar
sponsored by Black Duck Software and presented by Carahsoft.
Register here.
If you are interested in having me speak at your
organization:
Contact me directly via email.
You might be interested in my blog postings on CIO.com:
GPL3
Sees the Light of Day
The
Dark Side of Web 2.0
The
Race to the Bottom -- of the Software Stack
|
