MYTHS OF OPEN SOURCE
( Neil Gunton)
…from page
113 of DeveloperIQ( December-2005)
-------------------------------------------------------------------------------
This is not meant to be an
anti-FOSS article, but something that is intended to be an open discussion on
FOSS related issues. There are several
myths and facts, which you need to be aware of. Here, we discuss some of the
points.
1.”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, yet
someone else will reply that you shouldn’t gripe unless you are willing to help
pitch in and fix the thing. This is somehow supposed to be the ultimate word,
the 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.
2. “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.
3.”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 - a place to live, food, clothing, services
- you name it. Even artists have a sociallly 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 foundation
s for this attitude, 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. 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 in 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 does all this
lead? 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 Open Source developers to be working at large companies, with the
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.
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 parent’s 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.
4.”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 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 people. Also, sometimes a simple lack of funds of
the part of the developer can hamper development.
5.“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 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. TThere 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.
A commercial company, on the
other hand, can afford to scratch the personal itches of its end users, because
they are the ones paying the bills.
6.”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.
7. 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, closed - source model. I am really doing
nothing of that 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 w3e know all the
answers.
Criticism is a valid way of
participating in the process; we don’t have all the time to “fix it ourselves”.
Tinkering with the code is
something that hardly anyone actually does, except for the code 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 as, sometimes even better than, the 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.
************************************************
