About  Sitemap 

 Home  My  Articles   Links  Search  Resume  Contact  Website
 Contents  Status  Latest  Guestbook  Printable  Edit  Search  Bookmark  RSS

Open Source Myths

Thoughts on some frequently-stated dogma promoted by the Open Source community

Topic: Neil Gunton  
Categories: Open Source Software, Software development


Copyright © 2004-2014 By Neil Gunton

Last update: Friday August 14, 2009 23:01 (US/Pacific)

Table of Contents

"If you're not willing to help fix it then you shouldn't complain about it"
"Open Source software allows you to get under the hood and fix problems"
"All software should be free"
"Open Source software is always better than closed, proprietary software"
"Scratching the personal itch"
"More choice is always better"
Conclusion: It's Not So Simple


This document collects some of my thoughts regarding some of the "conventional wisdom" that people seem to take as Gospel Truth about Open Source software (OSS) and software development in general. This is NOT intended to be "anti-OSS", but rather to generate real thought and discussion as opposed to the constant mindless re-iteration of the same old tired dogma. I fully realize that this will be controversial to many and will probably generate much vociferous condemnation of my opinions, but I just think that it needs to be said. This is a bit of a rant, sorry if it's longer than it should be.

Note: Since the slashdot article I have had quite a lot of feedback, and I just want to thank everyone who took the time to comment privately via email and publicly on slashdot. Here's a funny thing I've noticed before with slashdot: It seems like people who agree with the article tend to give feedback via email, whereas people who disagree do it on the public board. Interesting. Anyway, the main criticism I have seen has been point 3, "All software should be free", people say that I've misunderstood or misrepresented the concept of "free" (free as in beer or free as in speech etc). Sorry if it seems that way, I do think I "get" the difference between the two. The "free" I am referring to here is mainly the aspect which results in the software being available for free (i.e. no money). If that is the case, then very simply (in my opinion and experience) you will have a hard time getting people to pay for it. Companies might pay for support, but I cover that in the article. Just to be clear: I am not disagreeing with the concept of free software, just making an observation on the consequences when something is made available, source and all, without requiring payment. Thanks again for all the comments! The article was intended to provoke discussion, and it seemed to do that.

"If you're not willing to help fix it then you shouldn't complain about it"

In any discussion about an Open Source project, someone will pipe up with a complaint about it, and someone else will reply that you shouldn't gripe unless you're willing to help pitch in and fix the thing. This is somehow supposed to be the ultimate word, the riposte that has no riposte... but it's just plain silly in real life. Even if we are developers, most of us have real jobs, or at least other projects that we are working on full time. We don't have time to "get under the hood" (see next section) and find out how the Linux kernel works, or work up a patch for Apache, or fix a problem with Perl. However, that doesn't preclude having the right to criticize (politely and tactfully, of course) how something is designed or works. Constructive criticism is and should be a valid part of the community process, and telling people that they don't have any right to gripe unless they contribute code fixes themselves is just unrealistic.

"Open Source software allows you to get under the hood and fix problems"

The idea seems to be that Open Source is better than closed source because you can "tinker" with the code. But how many people actually do this? Hardly anybody in real life. In reality, it's generally very, very difficult to fix real bugs in anything but the most trivial Open Source software. I know that I have rarely done it, and I am an experienced developer. Most of the time, what really happens is that you tell the actual programmer about the problem and wait and see if he/she fixes it. Most people do not participate in the development - even for Linux itself, most of the development is done by a very small number of people (in the tens at the most). Maybe you'll poke around a bit in the code, and if it's trivial then you can fix it - but again, this really isn't something your average user is going to do.

"All software should be free"

One of the central tenets of the Open Source philosophy (as it seems to be understood by the average person, at any rate) is that all software should be free. This seems a little unrealistic to me, for one glaringly simple reason: Development takes time and effort, and the rest of the world that we all live in is most certainly NOT free. We have to pay for everything else - a place to live, food, clothing, services, you name it. Even artists have a socially-accepted way to make money, and art is possibly one of the closest things to programming. So I fail to see the reasoning behind the suggestion that I should be expected to provide the fruits of my labor to the world for no financial reward. How did that happen? Well, it's easy to see the foundations for it, which are perfectly noble and valid - this all started because some people (RMS et al, for whom I have nothing but respect) wanted to share code with fellow developers, which also has its basis in the longstanding scientific traditions of sharing knowledge. Be assured that I am not making an argument against sharing code or doing anything else that you feel like doing. But what I do object to is the concept that all code can somehow be developed for "free", without there being a price to be paid somewhere. So, what is that price in this case?

I know that I, for one, having over 20 years experience writing software, find myself in the odd position of realizing that if I write something independently, then there is basically not a chance in hell of being able to sell it or make money directly from it. Sure, I can sell "support", but to be honest the idea of answering phones and emails all day really isn't my idea of a fun time. I grew up in the 1980's assuming that I would one day be able to write some really cool software, then *SELL IT*, and make some real money for my trouble. But if I were to do that today, then in all likelihood someone would write an Open Source version of the thing, which sort of takes the wind out of any commercial startup. It's a bittersweet situation, because on the one hand, I am able to build some wonderful software as a result of Open Source, but on the other hand, this comes back to bite me in the butt when I want to write something to be sold for real money. I can understand why the larger software companies are getting very twitchy about Open Source - after all, Linux, Apache, MySQL, PostgreSQL and so on are rapidly becoming mature enough to be real competitors to the major software vendors.

But where is all this going? Ah yes, the famous Commoditization of Software. So all software will be free in the future, simply because it will be dominated by Open Source and free software. But who is going to pay for it all? You can't develop in a vacuum, *somebody* has to pay the developers. It seems to me that the only way to do it is for all the Open Source developers to be working at large companies, with the large companies paying a salary for the developer to work on the Open Source project for some portion of their time. That's fine, I have no problem with that concept, but it's *not* "free". The software is effectively being supported by the charity of corporations. You trade your independence for the security and safety umbrella of The Big Company. Given the behavior of large companies (the bigger they get, the more amoral they seem to get), is this a very solid foundation? And is it very satisfying for the developers? It basically says that software itself cannot itself directly make money independently, but can rather only be a supporting player in some other business. The only way to make money is to give away the software, and charge for support services.

As a developer myself, this prospect is profoundly depressing - as I said earlier, I develop applications just like a carpenter makes tables or an author writes books. But we don't have a situation where we say that all authors have to be employed by large companies in order to be able to make money directly from their literature. Sure, they may go with a large publisher, but the author is basically able to sell books, this is an accepted and normal part of everyday life. People don't expect to get a book for free. And we have many small businesses run by carpenters who charge directly for their work. Why should software be any different? I mean sure, we are all allowed to write "free" software for no money and release it out into the world purely for the feel-good factor and ego boost - but to make this the dominant way of developing anything worthwhile just seems like shooting ourselves in the collective foot.

Some argue that there will always be a market for vertical market software (customized, very specific to a particular business), and this is true, but why can't I write a wonderful new *general* tool and make money from it? Yeah, I know, some will say "Go ahead and try, it's a free world". But you know as well as I do that if I am successful then inevitably some kid in his parents' basement will write his own Open Source version of the thing, for free. We seem determined as a culture to ensure that the only "worthy" software is that developed for free. This may be an understandable reaction to the overarching monopolistic behavior of companies like Microsoft, but perhaps we are overreacting?

Here's the thing: Nothing is ever really, totally "free". There is always a price to be paid, even if that price is simply the breakdown of the marketplace and the ability to make money from your own software, that you developed with your own time and effort. If the culture doesn't support the idea of paying for software (and music, and movies, etc) in some way, then we are basically just denying artists and programmers the right to make money from what they do. There needs to be a balance somewhere between the draconian and restrictive DRM policies being pursued by the RIAA, MPAA and other "intellectual property" syndicates, and the "everything should be free" crowd. We should be able to make money from our labors, without screwing over the user in the process.

"Open Source software is always better than closed, proprietary software"

People rant on and on about how much MS Windows sucks, and it's true, it does in many respects. But it's also true that in many respects, Windows kicks Linux's ass in terms of usability and GUI refinements. It's widely recognized that the Linux desktop is still a work in progress playing catch-up to Microsoft, and people continually wage religious wars on each other's OSS projects.

I think it's true to say that while many Open Source projects are superior to their close-source counterparts (Apache being a prime example), it's also true to say that a closed-source approach to a problem can have some benefits. Some of these benefits include having a more focused direction for the team, given the fact that there is (usually) just one manager and team leader, firmer schedules and deadlines, tighter management, profit incentives, salaries and bonus motivations. While this can also be true for open source projects, the "design by committee" that goes on with community projects often results in a more bloated and less focused product that tries to be all things to all people. Also, sometimes a simple lack of funds on the part of the developer can hamper the development.

"Scratching the personal itch"

This is one of the oft-repeated explanations for why programmers develop Open Source software, and it's perfectly true that most of these projects get started because they address a personal need of the developer. But is this a good way in general to do things? For example, this implies that most of the things that get implemented will have direct relevance to developers and programmers. In other words, it's no coincidence that most of the Open Source tools out there are developer tools - compilers and other server utilities. There are Open Source end-user oriented tools, but they have mostly failed to make the same impact as the server-side stuff. The Gimp is surely a fine piece of software, but it has failed to make a dent in PhotoShop's market, even though it's free. The Gnome and KDE projects remain a bit of a mess, and while they are making great strides they remain far behind MS Windows in terms of real usability for the kind of "my grandma" users that Windows caters to. This is to say nothing about all the glaring security vulnerabilities on MS Windows - that's not the point here, and is really a distraction from the real issue, which is that if Open Source mostly scratches a personal itch, then you're going to get mostly software that scratches the itches of programmers, not end-users (unless the end-users happen to be programmers).

A commercial company, on the other hand, can afford to scratch the personal itches of its end-users, because the end-users are the ones paying the bills.

"More choice is always better"

One thing that Open Source does is to, well, open up the process of what gets included in the final product. So we have fifteen different editors, several different web browsers, several different desktops, and so on. While this might seem like a Good Thing at first (biodiversity), it could also be argued that eventually trying to reduce the choice somewhat for the end-user would also be beneficial. For example, a new Linux user has to choose between all these different packages (e.g. which desktop) without knowing anything about either choice, or else just admit defeat and click "All", which results in a bloated system. Reducing the choices would reduce the bloat and clutter that seems to be in danger of overtaking the Linux of today - how many CD's are there now in the average distribution?

Choice is good, but a reasonable pre-selection of options is better for people who don't have the time or inclination to make their computer be their life. Most people, after all, would really like their computer to be more like their toaster. It's there, you use it, you're done - move on with the other, more important things in life.

Conclusion: It's Not So Simple

Some people will inevitably condemn me for putting down Open Source, disparaging the community process and otherwise encouraging the proprietary, close-source model. I am really doing nothing of the sort. This is just a collection of thoughts reflecting on the process and its consequences, trying to give a little balance and generate more thought. It's just an observation that things aren't so simple as they might appear - the Open Source model has its own pitfalls, and it's just as well to consider them rather than stick our heads in the sand and pretend that we know all the answers.

  • Criticism is a valid way of participating in the process; we don't all have time to "fix it ourselves".
  • Tinkering with the code is something that hardly anyone actually does, except for the core developers.
  • Saying that all software should be free ignores the hidden price - including your own ability to make a living from writing software.
  • Closed source software can be just as good, sometimes even better, than Open Source.
  • Having a lot of programmers "scratching their personal itch" just ensures that a lot of programmer tools get written.
  • Sometimes restricting the choices might not be a bad idea.

Thanks for reading.

-Neil Gunton
July 25th 2004

"Open Source Myths" Copyright © 2004-2014 By Neil Gunton. All rights reserved.
Website Copyright © 2000-2014 by Neil Gunton Fri 24 Oct 2014 14:18 (US/Pacific) (0.055s)      Top    Link    Report    Terms of Service