Before you write me off as just another Open-Source Zealot, hear me out. 2009 will be recognized as the year when Open-Source Software (OSS), and Cloud Computing (CC) for that matter, became mainstream concepts. Within 5 years both will also be the mainstream deployment models for Enterprise Software. Enterprise software includes: both row and columnar databases, Enterprise Resource Planning (ERP) systems, Data Quality (DQ)/Extraction, Transformation, Load (ETL)/Master Data Mangement (MDM) software, Business Intelligence and Reporting (BI/R) solutions, Portal, Collaboration and Social Networking platforms, Customer Relationship Management (CRM) and Campaign Management applications as well as any other number of operational and infrastructural applications.
I can make this prediction with certainty thanks to the paradigm-shifting work of Clayton Christensen and his model of disruptive innovation. In a nutshell, disruptive innovation occurs when disruptive technology (generally cheaper and easier to use solutions to existing consumer needs) is coupled with business model innovation (usually in the form of new value networks) to provide products which are simpler and more affordable than their more functional and more complicated competition. The net effect is to open up whole new markets where economies of scale compensate for reduced profit margins. One of Clayton Christensen’s canonical examples of disruptive innovation is the PC’s disruption of the minicomputer (for all the details, pick up a copy of “The Innovator’s Dilemma”). Suffice to say, OSS sits in the same relation to the Enterprise Software Model as PCs did to minicomputers. I’ll happily take up the debate in the comments section with those who disagree, the rest of you will have to take me at my word.
Before I go further, let me give some quick definitions. When I say the Enterprise Software Model (ESM), I am referring to the proprietary, license- and/or subscription-based models by which software has been sold for the last 40 or so years. In this model a software company develops, patents and copyrights code that is further legally protected from reverse engineering by stern prohibitions in the clickwrap and software end-user license agreements (EULA). The software company then sends salespeople out into the marketplace, supported by a barrage of marketing materials to convince prospective clients to buy said software at exorbitant margins (anywhere from 30-95%, with most around 80%) on the basis of assertions, flimsy comparative assessments (also known as Proof-of-Concepts) and almost always quite a bit of FUD. Such sales are fundamentally based on expectations – expectations of performance, functionality, stability, scalability, extensibility, and so on. When said software is implemented at the client site and one or more features fail to meet expectations, the door to litigation is opened. For this reason most of the language in a EULA revolves around issues of indemnification and the responsibilities of the EULA signatories.
In COSS some form of EULA is wrapped around portions of the software and/or support, development, or maintenance services associated with the software. The COSS model also often provides some level of indemnification, that is a single, legal “throat-to-choke” should something go awry at any point after the EULA is executed. Key to the COSS model is that invariably some portion of the software is still proprietary.
In HOSS, the best of FOSS and COSS are brought together. The entire code base and development community remains free and open while service level agreements (SLA) are wrapped solely around services such as support, implementation, training and/or development. The SLA will often address indemnification, but only in the context of the services provided as the code base itself is transparent and free.
You might be asking, why do I care? And why have I read this far? Well you’ve read this far because now we get to the good stuff. Consider the standard ESM deal: it takes 9 – 18 months to complete, involving dedicated time, attention and resources from all levels of IT, the business, management, as well as the legal and procurement teams before a EULA is executed in the range of $250,000 to $2,500,000 or more, for license fees alone – I’m not even going to bring maintenance and consulting services into this estimate. Sounds pretty expensive, right? Now consider that most companies use less than 50% of the functionality present in a mature Enterprise Software package and that shelfware rates as high as 70% are possible.
Contrast this with FOSS. There is no sales cycle, only a technical and functional evaluation cycle; there is no EULA and thus no legal wrangling or procurement issues; and the degree of functionality used or the rate of shelfware is largely moot as the direct and indirect costs of acquisition are very low (essentially the cost of evaluation and implementation).
HOSS is very similar, albeit with the added costs of a much more straightforward services sales cycle and the requisite SLA negotiations.
COSS on the other hand very closely resembles the ESM, the principal difference being that a COSS EULA costs about one-tenth as much as an ESM EULA.
Seems like FOSS, or at least HOSS, is a no brainer. Why has the Enterprise Software Model dominated for the last 50+ years?
Depending on the strictness of one’s definition, OSS has been around since either the 1950’s or 1998. What hasn’t been around until recently has been a critical mass of individuals with sophisticated programming skills in robust cross-platform languages; truly global, near-real time communication, collaboration and archival capabilities; and a mature Enterprise Software market where the offerings of the different Enterprise Software vendors more closely resemble commodities than they do distinct and highly differentiated products.
This last point is critical. Once a product becomes a commodity it means that the job (or jobs) for which consumers are hiring that product are jobs that are well-defined, clearly specified and generally well-understood. OSS for non-commodity software is chaotic, architectureless and likely to fail (without the herculean efforts of a handful of gifted and altruistic developers and organizers). OSS for commodity software is self-organizing (around the jobs to be done), rationally architected (in response to existing solution architectures) and likely to succeed (as each developer, in meeting their own needs, simultaneously contributes to the benefit of the whole).
The eventual mainstream deployment of Enterprise Software delivered via the FOSS or HOSS model is a certainty. The economics, supported by a value network that is reaching critical mass, enabled by a mature Enterprise Software market, demand that it be so. Enterprise Software is at a tipping point. Most OSS versions of Enterprise Software have reached the good-enough threshold, and for those that have not, the good-enough threshold is not far away. ESM vendors will be around for a while yet, but their days are numbered.
Disclaimer: The opinions expressed herein are my own personal opinions and do not represent my employer's view in any way.
