The Open Road

(Credit: Doigy Media)

For those who have yet to grok the Open Core business model, Trent Reznor of Nine Inch Nails fame will sing it to you. In a series of forum entries, Reznor explains exactly how to build a music business on the Web and, in the process, classically defines Open Core, the primary business model for open-source software, too.

Reznor writes:

Forget thinking you are going to make any real money from record sales. Make your record cheaply (but great) and GIVE IT AWAY. As an artist you want as many people as possible to hear your work. Word of mouth is the only true marketing that matters. To clarify:

Parter with a TopSpin or similar or build your own Web site, but what you NEED to do is this--give your music away as high-quality DRM-free MP3s. Collect people's e-mail info in exchange (which means having the infrastructure to do so) and start building your database of potential customers.

Then, offer a variety of premium packages for sale and make them limited editions/scarce goods. Base the price and amount available on what you think you can sell. Make the packages special--make them by hand, sign them, make them unique, make them something YOU would want to have as a fan. Make a premium download available that includes high-resolution versions (for sale at a reasonable price) and include the download as something immediately available with any physical purchase. Sell T-shirts. Sell buttons, posters...whatever.

Having trouble following that? Well, the excellent TechDirt simplifies it:

Connect with Fans (CwF) + Reason to Buy (RtB) = The Business Model

In the software world, "Connect with Fans" is the community download. It's the software made freely available for anyone to download, tinker with, and share (if they wish). As noted in a recent MindTouch post, word of mouth is an open-source project's best friend, and word of mouth depends upon giving people something to talk about.

Unfettered discussion. Highly usable code. These are the key ingredients to driving word of mouth.

As for Reznor's "Reason to Buy," that is the enterprise version. Importantly, it's not really about lock-in so much as it is about (temporary) lock-out: Open Core, just as with Red Hat's licensing model, isn't about forcing customers to stay so much as giving a convenient, compelling reason to buy. Once the customer is in the door, every open-source company I know makes it easy to leave and depends upon a subscription offering that forces the vendor to deliver continuous value to earn the customer's loyalty.

Community is for the geeks: it's all about code, code that average consumers could not possibly care any less about ("I thought that obsessing about an OS in 1993 was depressing; why are we still doing it in 2009?").

Enterprise is for users who just want to get on with their day, and want software to be part of that day without consuming the day.

You need both but, as Reznor accurately describes, you must have a compelling reason to buy. Charitable urges don't count.

Over the past 10 years that I've been involved in open source, one thing has become strikingly clear to me: there are no real predictors of open-source success. There are, of course, general principles that contribute to the creation of successful open-source projects, but serendipitous "right project, right time" circumstances often matter most.

Apache Software License 2.0.

(Credit: Apache Software Foundation)

I was therefore intrigued to read two articles that crystallized my own thinking around critical components of successful open-source projects.

The first is from BusinessWeek and details the mechanics of Mozilla's Firefox community. Mike Beltzner, Mozilla's director of Firefox, reveals that while 40 percent of Firefox is contributed by outside developers, what and where they contribute may not be what many would expect:

There's structure in (how Firefox is developed). But at the same time you allow people to innovate and to explore and (give them) the freedom to do what they want along those edges--that's where innovation tends to happen in startling and unexpected ways (emphasis mine).

This may be easier for the Mozilla Foundation, given its nonprofit status, as you'd expect developers to more willingly build around a product if they trust the foundation (pun intended) upon which they're building.

But the general principle holds: most open-source development and, for that matter, most development around proprietary software, happens at the edges. Whether it's Microsoft Windows or Mozilla's Firefox, developers generally don't touch the core: they create add-ons, complementary products, and so forth.

So, principle No. 1: Open-source projects that create a strong, valuable, easily extensible core that developers have the ability to build upon, as well as the pecuniary or reputational interest in extending, are more likely to succeed. No one works for "free."

The second principle is related to the first, and deals with ownership of add-ons. While some people are motivated by peace, love, and open source, others (rightly, in my view) see open source as a means to an end, and not the end itself.

As such, the license used for an open-source project matters a great deal. I've long been a proponent of the GNU General Public License (GPL) because it enables vendors to bless customers (free code!) while cursing competitors (we just open-sourced your entire value proposition and you won't dare touch our code!).

But lately I've been seeing the role Apache-style licensing can play in fostering vibrant open-source communities. Daniel Jalkut, founder of Red Sweater Software, describes this well:

As the developer evaluates communities to participate in, they must evaluate the legal impact such participation will have on their own project. The closed-source communities are, by definition, uninviting to outsiders. GPL communities are open and embracing of other GPL developers, but generally off-putting to liberal-license and closed-license developers. Only the liberal-license communities are attractive to developers from all three camps.

It's your party, and you're entitled to write the guest list. But take a look around the room: not as many folks as you'd hoped for? Liberally licensed projects are booming. Speaking for myself, a developer who has been to all the parties, I'm much more likely to pass through the door that doesn't read "GPL Only."

If you want maximum participation whatever the cost, Apache/BSD is probably the right way to go. Most companies and project owners, however, have to make a living, so it's reasonable that they measure the costs of going Apache, which likely means they'll trade a liberal license to some of their code for a proprietary license of the rest of their code.

IBM is an example of this strategy on a big scale, but so are Day Software, Microsoft, SpringSource, and others.

Principle No. 2, broadly stated, is this: Your odds of encouraging adoption of your product go up if you use a liberal license like Apache, but your ability to directly monetize Apache-licensed code vaporizes.

This isn't a bad thing. It just means you have to separate community creation from customer creation, as Funambol's Fabrizio Capobianco has stated. The two aren't necessarily the same, and are sometimes inimical to each other.

As noted above, however, you don't have to license your software as open source to encourage community around it. Microsoft, with its vibrant partner ecosystem, demonstrates this, as does Apple with its amazing iPhone ecosystem.

Developers will flock to the platforms that offer them the most return, whether financial or in reputation (which eventually translates into money). Liberally licensing of your code might tip the scales in your favor if you lack the largess of Apple or Microsoft. But no guarantees.

Follow me on Twitter @mjasay.

Walk the halls of any open-source conference and you'll see a large percentage of attendees with ironically un-open-source Apple laptops and iPhones. I've commented on the reasons for this before, but a new thought sprung to mind while reading Matthew Thomas' excellent (and old) "Why free software usability tends to suck."

Open-source advocates like good design as much as anyone, but the open-source development process is often not the best way to achieve it.

Thomas now works for Canonical, the company behind Ubuntu, which arguably offers the industry's best Linux experience for personal computers. I got a sneak peek at a future Ubuntu release while at dinner with Canonical founder Mark Shuttleworth Wednesday night, and it was gorgeous. Mac freak I may be, but the day Canonical releases that version of Ubuntu is the day my devotion to Apple will be severely tested.

Yes, it's that good.

But it's "that good" because there's a company behind it, a company dedicated to making Linux usable for average consumers. As Thomas writes,

Every contributor to the [open-source] project tries to take part in the interface design, regardless of how little they know about the subject. And once you have more than one designer, you get inconsistency, both in vision and in detail. The quality of an interface design is inversely proportional to the number of designers.

This, coupled with the fact that experienced interface designers tend to be rare in open-source projects and, even when present, "they are not heeded as much as they would be in professional projects precisely because they're dedicated designers and don't have patches to implement their suggestions," as Thomas writes, means that many open-source projects are technically brilliant...and abysmal to look at.

In the short term, proprietary products are generally going to win because they can more tightly control inputs and output and, intriguingly, it is likely that the most proprietary products will win. Why? Because in new markets, control is crucial to delivering a complete experience. Clayton Christensen, the Harvard Business School professor and author, notes:

Companies must be integrated across whatever interface drives performance along the dimension that customers value. In an industry's early days, integration typically needs to occur across interfaces that drive raw performance--for example, design and assembly. Once a product's basic performance is more than good enough, competition forces firms to compete on convenience or customization. In these situations, specialist firms emerge and the necessary locus of integration typically shifts to the interface with the customer.

Hence, Apple reigns in smartphones because it's a comparatively new market and Apple can control the complete design of the product. Microsoft and Google, on the other hand, will struggle to compete because they are only delivering software, and depend heavily on the device manufacturer. (It's likely that Apple is also exercising significant influence over AT&T and the other wireless carriers, influence that Apple's competitors likely lack.)

Against this backdrop, I wouldn't expect open source to win in new markets unless a company or other committed organization (e.g., Mozilla with Firefox) is dedicated to making it succeed. But in the long run, it's fair to expect open systems to win. As Mozilla CEO John Lilly articulated to me in response to my post "Is Apple 'open enough' to rule the next decade of mobile?":

In the long term (10 years +), I think that open systems will almost always win, because the systems will be better understood from end to end, there will be more places for individual innovations to happen, more commoditization, and [more need for] the diversity and variety of an open ecosystem.

I agree. The key, however, is learning to tweak open systems in the short term to be competitive, too, and that, I believe, requires a "cathedral+bazaar" approach to open source. It's great, for example, that Red Hat has successfully helped to commoditize the Unix operating system market, but many of us don't want to have to sit around for decades waiting for an industry to tire out, thus ripening for open-source commoditization.

We want to innovate. We want to compete. And we want it now.

For that, you need a little more than open source, it seems, to make products usable. You need control, and control doesn't always jibe well with open-source development. This is one reason that we're seeing the emergence of the Open Core licensing model for open source.

It's why I think we need a lot more such activity if we want open source to dominate new markets, and not merely clean up the scraps of old markets.

Follow me on Twitter @mjasay.

As the Internet dismantles one business after another, it's surprising how fungible the responses to the Web have become.

Reading a recent Economist description of the changing newspaper business, for example, I was surprised by how much its transformation mirrors the software business. The Economist suggests a change to the economics of news businesses:

(T)he plight of the news business does not presage the end of news. As large branches of the industry wither, new shoots are rising. The result is a business that is smaller and less profitable, but also more efficient and innovative.

This is almost certainly what open-source software is doing to the traditional develop-a-product-and-license-a-million-copies proprietary software business. Open source is not a monastic pledge to poverty; instead, it's an alternative way to wring profits from a bloated industry that has gotten away with monopoly rents for far too long.

Intriguingly, though, even the business models that appear to be working for News 2.0 are the very same models being deployed by budding open-source software companies. The Wall Street Journal's bifurcated content model sounds suspiciously like open-source software's Open Core model and our attempts to create hybrid-source business models:

The Wall Street Journal takes a shrewd route to a similar destination. Rather than charging certain types of user, it charges for certain types of news. Earlier this week, it offered for nothing a story about swine flu, a review of the new "Star Trek" film and a report on looming cuts at car dealerships. It charged for pieces on Cigna Corporation's pension plan, Lockheed Martin's quarterly lobbying expenditures and a lawsuit against a bottling company which alleges that a board meeting was held improperly. In short, the fun articles are free. The dry, obscure stuff costs money.

The open-source analog is Zimbra giving away its standard e-mail software but charging for the "boring" (but necessary to enterprise roll-outs) bits like multi-domain support and Outlook/MAPI sync.

This is why I often talk about the entertainment industry, newspapers, etc. in the midst of an open-source software column.

The solution to the music industry's P2P woes should provide significant insight into the business models that will fuel open-source software for the decades to come. The best models for open-source software will almost certainly suggest clues for monetizing Twitter, online video, and more.

Indeed, Twitter's founders on Tuesday told CNET that they're focused on building a great product first, and fixating on profits second, which sounds a lot like Red Hat's model over the past few years of growing revenue slowly, but customer value quickly.

We're all in this Internet thing together.

Follow me on Twitter @mjasay.

John Roberts on Wednesday resigned from his post as CEO of open-source CRM vendor SugarCRM, leaving board member Larry Augustin to assume the role of interim CEO while the company conducts a formal search for his replacement.

John Roberts

(Credit: SugarCRM)

Roberts, whose grounds for leaving the company and future plans remain undisclosed, has made a huge impact on the open-source world, innovating the "Open Core" business model and helping drive open-source applications into the enterprise.

SugarCRM, despite losing Roberts, will be in good hands with Larry Augustin, who, as founder and former CEO of VA Linux, sits on a number of open-source company boards, including Pentaho, Compiere, Appcelerator, and Medsphere. He understands how to run an open-source business and, importantly, what to look for in leadership. Augustin should be able to find a strong CEO to lead SugarCRM.

Augustin's near-term task is clear, as he outlines in his blog announcing the change in leadership:

Yesterday, I stepped into the role of interim CEO at the company. I have an immense amount of respect for the founding CEO, John Roberts...My goals for the next 30 days at SugarCRM are fairly simple: get to know the team, customers, and partners. I am looking forward to helping them to continue to execute and (taking) the company to the next level.

In other words, continue the solid work that Roberts started.

I first met Roberts at an SDForum event in 2004, at which time I thought that he was crazy for believing open source could succeed in applications. He and his SugarCRM team persisted in their Quixotic dream, building SugarCRM into a thriving company that brought in tens of millions of dollars in sales last year and has an eye on an IPO.

I couldn't reach Roberts for comment but hope that he spends a little of his downtime on cycling, one of his passions, before he leaps back into the open-source world. As Augustin notes of Roberts, "Few people have taken a company from concept to major growth the way John did at Sugar."

I agree. Roberts will be missed. Fortunately, his legacy should live on at SugarCRM, one of the pioneers of commercial open source.

Disclosure: I am an adviser to SugarCRM.

Follow me on Twitter @mjasay.

Sometimes our best intentions give way to our worst, for a wide variety of reasons. This is as true of corporate amalgamations of individuals as it is of those individuals on their own, and it's as true for open-source companies as it is for proprietary companies.

Community is the tonic that keeps corporate aspirations in line, just as community helps to keep individuals walking the straight and narrow of societal norms. As The Economist recently highlighted, new research suggests that "having a crowd around often makes things better."

In other words, while we normally point to crowds as motivations for mob violence and such, it may be that crowds more often have a pacifying than an inflammatory effect on explosive situations.

For open-source companies increasingly experimenting with models that flavor open-source code with proprietary complements, it's imperative that we guard against backsliding into the lock-in of the past proprietary decades. The way to ensure this is to spend as much time cultivating community as we do devising commercial add-ons to our otherwise open-source products.

There's safety in community. Safety from the company's best intentions getting clouded by its worst. Safety for customers.

I've written before that I think a transparent distinction and delivery of an open-source core and proprietary add-ons can be beneficial to one's community. Most open-source businesses will find it hard to scale on a support-only revenue diet and given that big customers want their vendors to scale to reduce their investment risk, a conflict erupts that is much easier to manage with a hybrid approach.

But community is critical to ensuring the company doesn't devote so much of its development resources to the proprietary bits that the core gets forgotten or, that if it does, the community can thrive in the company's absence. A crowd can help avert violence. In open source, it can also help prevent good intentions going bad.

Follow me on Twitter at mjasay.

Reading through the latest copy of BusinessWeek last night, I particularly enjoyed this comment from Jack and Suzy Welch on political "flip-flopping," otherwise known as "changing one's mind in the face of new information":

It's hard to know exactly when flip-flopping first became a dirty word in the leadership lexicon. But in recent years, it has been the epithet of choice against political candidates on both sides of the fence...In those cases, critics made it sound as if revising a stance is some kind of a moral failing.

What nonsense. It is the essence of leadership to have the self-confidence to admit that a strategy has gone off course or a position has become outdated. And it is the responsibility of all leaders in such a "predicament" to revise their direction swiftly, widely communicate it, and move on without undue pandering or emotionality.

We have the same pride in open source--the same fear to change our business models to reflect customer and market realities--and it can be debilitating. Just ask MySQL, which was repeatedly stymied in its efforts to tweak its model to enable a revenue stream more consistent with its massive popularity.

Not that MySQL is alone. Luke Kanies, founder of the successful Puppet project, describes his own reasons for running this purity gauntlet in an excellent post describing his company's "Open Core" business model. Kanies waxes pragmatic, not philosophical, and that's why I think Puppet, as well as the company (Reductive Labs) behind it, will succeed.

For years, open source divided itself into purists (of which I was part) and the hybrids (or "mutts," as one friend called it while I was at Novell, a hybrid open-source company). What nonsense, to use the Welches' phrasing.

We make open source entirely too ideological, too political. As I discovered at the New York CTO Club, the open-source vendor community, enterprise IT buyers care far more about whether software works (and is sold at a compelling price) than they do about its ideological wrappings. On that day, I became a flip-flopper. I've been much happier ever since and, I feel, much more community and customer-focused.

It's time for the open-source community to become far more pragmatic and, when necessary, to flip-flop. This isn't to suggest that we should forget our ideals, such as transparency and reduced vendor lock-in. But it is to declare that we need to spend less time fetishizing open-source politics and more time focusing on customer pragmatism. We should be a lot less like Richard Stallman of the Free Software Foundation, in other words, and much more like Eric Raymond of the Open Source Initiative.

And lest we flip-flop alone, here's a suggestion for Microsoft: be more like Ray Ozzie and less like Steve Ballmer. Flip-flop on open source. You'll like it.

Follow me on Twitter at mjasay.