03
Dec
Open Source – The Walmart Effect?
There’s been a really negative meme going around in the last week or so about Open Source destroying the ability to make money from selling software. It’s patently nonsense and quite the contrary, Open Source saved the software business. Here’s why.
1. Software development as an act of alchemy
Making software has always been a complicated thing, somewhere between engineering and art. Software developers, while outwardly pretending to be engineers, are much closer to music composers and what they produce is, much like music, rather nebulous and intangible in quality. Steve Jobs famously said that great software was “indistinguishable from magic”, ergo something much akin to alchemy or some other opaque creative venture (like music).
The flip side of this is that most software development sucks, both for the developer and for the user. It’s often late, over budget, only does 30% of what you want and 10% of what you need, and constantly breaks. And, like music, you know crappy software when you see it, but it’s often hard to describe generically why software is crappy.
There are lots of reasons why software development turns out this way, but one of the major factors is lack of transparency in the development process, particularly for users. Open Source software development processes turn all this on it’s head and the result is generally better software, even if it has fewer features. The magic that enables this to happen is the community that is built around the software. The larger it is, the better the software will likely be and the more aligned it will be to it’s users needs.
2. Building blocks vs solutions
When software developers talk about software, they will mention things like Linux, mySQL, Oracle, PHP, etc., but none of these applications are actually relevant to businesses and business problems. They are largely building blocks, bricks if you will. Out of these, one can build solutions to real business problems, but on their own, they are useless.
Misunderstanding this dichotomy is a common mistake made by businesses of all sizes and not just in Open Source. A building block/technology is only a component of a large solution. Sure, you can sell building blocks, but when everyone has similar building blocks, they become commodities, like bricks. And commodity products, whether bricks or software, have low margins. However, even with commodity products it is possible to drive higher margins by creating value-added components that differentiate your commodity from others. Even then, if you are in the commodity business, it would be wise to optimize your business structure for lower margins. Because, in the long run, the high value is in producing solutions to business problems, not building blocks.
This has always been the issue in the software business, since market maturity dictates more vertically focused solutions rather than broad, horizontal solutions. In the end, only a small number of large organizations wind up dominating the commodity space. The same sort of dynamics are beginning to emerge in the Open Source space with a few large projects dominating various broad horizontals (Linux, Apache, for example), even if they do not revolve around commercial organizations.
3. Commoditization as run to the bottom
One of the points that is often made about Open Source is that it drives the price point to zero. This is essentially the same argument that people make about Walmart and its constant drive to lower prices. In Open Source, this is only partially true, as the ‘free’ nature of the software is deceiving. Someone has ‘paid’, in some fashion, for any Open Source software development, often by providing a resource to do something (coding, testing, community participation, etc). The net effect is a software product that, while free, represents the shared interests, needs and contributions of a community.
This shared development results in a lower overall software costs for certain key building block pieces, enabling organizations to spend more money on software which solves actual business problems. For software developers, it means no longer replicating generic infrastructure in each project, but having access to a wide set of building blocks and being able to tap into the collective knowledge of global communities. Cheaper, faster, more focused software solutions with lots of code reuse. Isn’t that what everyone has been after for decades?
The other interesting dynamic is that once products have reached the ‘bottom’ of the commodity curve, then there is generally a flight to quality. Even the CEO of Walmart, Lee Scott, has acknowledged this dynamic by suggesting that Walmart’s future strategy would be to focus on higher quality goods with a longer lifetime. In this dynamic, the best software will win and Open Source will be highly competitive. Not because of cost, but because of user involvement in the development process, it is the closest aligned with user needs.
So, what has Open Source done for the software business?
Well, it’s created whole new communities of energized users & developers and pushed them to collaborate on better and better building blocks. Those building blocks, because of their low cost, focus and quality, have enabled a whole new series of business models, from Google to SaaS to better professional services margins. And let’s not forget that it’s on Open Source that most of the internet is built. The net effect has been nothing short of the a revolution in software, and, finally, the hope that software will cease to be a black box and will actually meet the needs of it’s users.
Certainly, being successful in this highly competitive environment is not easy or simple. But it is possible, and for those who can think beyond the traditional software licensing models, there is wealth of opportunity. For business leaders in the Open Source space, I would highly suggest reading Mike Masnick (of TechDirt) treatise on the Economics of Free. While his focus has largely been around the entertainment industry, there are interesting ideas in his thinking that could be applied to Open Source as well.