A few weeks ago I posted a rant about how companies keep way more code to themselves than makes any rational sense, under the pretense of protecting their competitive advantage. I asserted that in a large number of cases, what they’re keeping to themselves is actually exactly what everyone else is also developing internally, and also keeping to themselves in the hope that it’s worth something. Result - a ton of duplicated effort that is worth very little. Open source of course frees people from developing the same thing over and over again via open collaboration, and allows them to concentrate on the 10-20% that really makes their application unique from their peers (assuming here that you have to sell a commercial product rather than being able to live off services, which despite the hype isn’t feasible in every sector).
I was therefore glad to see a Register article today quoting others that were saying basically exactly the same thing:
“The irony is that organizations increase their maintenance costs when they take open source code from projects like Mule in-house and add their own code. In all but a few areas companies are duplicating efforts made elsewhere, and wasting time and effort in repeating boring infrastructure programming, under the illusion they are adding competitive advantage. “There’s so much duplicate effort,” Zorro said, echoing Red Hat’s Whitehurst, who claimed last month that “billions” of dollars are wasted each year in internal, non-commercial software development that re-invents the wheel.”
Amen. I still think that the primary reason that so many businesses don’t ‘get’ this is that the decision making is too far removed from the people at the coalface who can see (and lament about) this wasted effort, and that the accepted wisdom that has been built up over the past couple of decades (fueled by the success of huge proprietary corporates like Microsoft) is that keeping everything to yourself is the only way to make money. Lawyers, vice presidents etc don’t generally have a clue how to differentiate between IP that’s genuinely valuable enough to invent yourself and protect like rabid wolf, and that which is a totally derivative reinvention of something that’s already out there and just a big waste of time and effort, both from the point of view of original creation and ongoing maintenance. Thus, if you have no way to measure one set of IP against another, just clutch all of it to your chest, knuckles white and teeth bared at anyone who would dare to want to look at it.
Such attitudes are woefully outdated and as open source continues to penetrate into corporate environments, such prehistoric attitudes are going to have to change. Ironically what these companies consider to be competitive advantage is in many cases precisely the opposite - all these largely worthless internal reimplementations of common functionality are in fact unnecessary baggage that’s slowing them down, and making them less competitive. Knowing how to separate the wheat from the chaff - the IP that is truly unique and differentiating you from others versus that which is common and functionary - is something that most experienced developers who know their field can do instinctively in very little time - if they are allowed to. More companies should allow their development leads to make this kind of call, in their own best interests.