neilgunton 
About  Sitemap 

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

Open Source Pros and Cons


Some thoughts on the benefits and problems associated with Open Source Software (OSS)

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

Permalink: http://www.neilgunton.com/doc/open_source_pros_cons

Copyright © 2006-2014 By Neil Gunton

Last update: Saturday August 16, 2008 17:21 (US/Pacific)


Table of Contents

Introduction

Pros

      Free as in Speech
      Free as in Beer (Usually)
      Big Selection
      Can talk to the developer
      Community Support
      Reliable, Robust and Secure
      Hackable
      Makes companies try harder
      Anybody can participate
      Security through many eyes
      Developers can build reputation among peers
      Keeps knowledge free and open

Cons

      Commoditizes developers
      Sabotages revenue models
      Obnoxious community members
      Scratching programmers' itches
      Cool stuff gets done, boring stuff doesn't
      Community image as pirates and outlaws
      Constant rewriting, because it's fun
      Often at the mercy of one person
      Bugs don't always get fixed
      Bloated, slower software
      Many different versions of the same app
      Lack of hardware support
      Documentation written by hackers, for hackers
      Often driven by commercial version (i.e. Ripped off)
      Viral license not business-friendly
      Hard to make any money
      Easier for hackers to get into code and make exploits
      Religious culture
      Community unwillingness to face up to problems

Conclusions


Introduction

        
This article summarizes some of my thoughts on Open Source Software (OSS). It is presented in a "Pros and Cons" format. My hope is that it will spur discussion and perhaps make people think about things that are perhaps a little uncomfortable or even unpleasant. I know that many of these are simply viewpoints, and can be argued endlessly; in this kind of discussion there is no "right" and "wrong", simply opinions. Hopefully people will find it interesting. Some overlap between points is inevitable, but each point is trying to emphasize something different.

Pros

        
        

Free as in Speech

                
For some OSS proponents, this is the most important advantage. Software cannot be witheld by some company just because it decides you shouldn't be using the software any more; they can't "take their ball and go home". Open software is free as in speech - nobody can stop you from using it down the line.
        
        

Free as in Beer (Usually)

                
Of course, the "free as in speech" thing is all very noble, but what what most people realize in practice is "hey... it's free!". In almost all cases, Open Source means you can get it for no money, if you want. Sometimes the company or author may try to get you to upgrade or pay for a service such as maintenance or support, or special features, but mostly the software will be freely available. With the advent of broadband internet access, this aspect has exploded, since it means that you don't even have the cost of media to worry about. When you're able to download an entire CD in a couple of minutes, why buy it? This makes it possible for software to gain a much larger audience, much more quickly than previously. This is obviously good for the user, but also good for the software author, in that your code can be in people's hands that much sooner.
        
        

Big Selection

                
Nowadays, if you're looking for a software application in just about any major field, there's probably one or more Open Source versions out there. We are reaching the point where the entire operating system along with all the major apps (word processing, spreadsheets, graphics, multimedia, networking etc) are available in one easily installed distribution. Having a big selection is good, because biodiversity says that the more versions there are competing, the better this competition is for making the individual apps better. So, if there are multiple versions of text editors, word processors etc, then the competition between them will inevitably end up in better software for the user.
        
        

Can talk to the developer

                
In many cases, an OSS project is developed by one person, who is frequently very accessible to users. Generally there will be a home page for the project, with an email address. I know that I have contacted authors on many occasions with questions and problems, and often get a reply within the day. Having such access is extremely valuable, especially if it means bypassing the "user support" droid in Bangalore who knows less than I do about the product and is reading from a script.
        
        

Community Support

                
Even if you can't talk directly to the developer (which is the case in some of the larger projects), there will usually be some kind of mailing list or web forums for the project, where other users will help you out. This kind of support can be most valuable when combined with Google, because many times you don't even have to ask the question yourself - someone else already did, and if you word your query correctly then Google can find it for you.
        
        

Reliable, Robust and Secure

                
Open Source software has a reputation for being very high quality, after it has been through the wringer of user testing and real-world bashing. This is especially true for server-side tools, such as Apache (at least, the 1.x series). Desktop utilities can be a bit more flaky, but in general this is because writing solid, stable UI apps is much harder than writing backend stuff. It's always going to be more tricky writing something that has to deal with real time user inputs, rather than well defined character streams. In any case, it's generally true that over time, OSS gets better and better.
        
        

Hackable

                
You can get "under the hood" in OSS. This means you can hack the code to fix problems or add tweaks according to your needs. This is obviously a huge win over Close Source software, where you are basically at the mercy of the company who owns the code.
        
        

Makes companies try harder

                
OSS spurs commercial companies to try harder to make their own offerings more attractive. It raises the bar, effectively, saying that "this set of functionality is what you can get for free - so if you're gonna charge money, you better be offering something more". This means companies are always being hounded by the OSS community - they can't rest on their laurels, they have to improve. Otherwise, an OSS project will come along that eats their lunch.
        
        

Anybody can participate

                
Another nice thing about OSS is that it's a meritocracy. Anybody can join and write something, nobody is "running the show" and nobody can tell you what you can or can't do. If you're a kid who can program, then you can take on the big boys. And, in many cases, you can beat them at their own game, because an individual can afford to be more agile and innovative. The barriers to entry are low, all you need is a computer and internet access, and both these things are rapidly becoming cheaper and cheaper.
        
        

Security through many eyes

                
As Eric Raymond said, "With many eyes, all bugs become shallow". So, the theory is that this applies to security too - a corollary might be "With many eyes, security vulnerabilities become much more visible". Whereas closed source companies depend on "security through obscurity", OSS assumes that having people look at the code will result in better code. Peer review is an ingrained scientific philosophy, and with OSS it means that the white hats are able to keep ahead of the black hats - or, at least, the black hats no longer have an unfair advantage.
        
        

Developers can build reputation among peers

                
One of the big problems with any job is that in order to get the job, you have to have experience. But how do you get the job experience in the first place? It's a vicious circle of chicken and egg. With Open Source, you can break the circle by developing software and releasing it to the community, thus gaining reputation among your peers. This can be very beneficial in helping make your resume look good. Companies have hired OSS programmers because of their contributions to the OSS world - if you write a major tool that is used by a lot of people, then someone will hire you, for sure.
        
        

Keeps knowledge free and open

                
Finally, there is the simple "it's just right" aspect of OSS: It is just right somehow to share knowledge. Since code is really just an expression of ideas, surely sharing these freely will accelerate the whole process. Through human history everybody has benefited from what everybody else did before. It's an interative process, nobody develops their ideas in a vaccuum. So, by releasing our code as OSS, we are really helping ourselves too.

Cons

        
        

Commoditizes developers

                
When you have so much software being made available for free, then this tends to devalue what programmers do. The arguments about "free as in speech, not as in beer" don't really hold water in reality, because although the sentiment is noble and worthwhile, in reality OSS means that stuff is made available for no money. There are few, if any, OSS projects out there which are not also available for free. So, however you want to argue about the philosophical aspects of "free", at the end of the day, it means "available without requiring payment". This doesn't obviate the other benefits, but what it does do is to make it appear that what programmers do isn't worth so much. If you can download a whole bunch of software off the internet for free, then what is that going to do with your attitude to paying programmers money to do the same thing? Many people make the argument that OSS mostly applies to tools, whereas most programmers out there make custom applications for companies. Such apps cannot be made Open Source, because they are so specific to a certain business area. This may be true, but such an argument is sidestepping the real issue: Where is the line between "custom software" and "general tools"? What would have required custom software 10 years ago might be available as an OSS toolkit today. In any case, it seems that devaluing the process is, in the end, harmful to the developers, because it means that you can't write some really cool application and expect to sell it. People expect such things to be free these days. Right or wrong, OSS does tend to commoditize software developers, because so much OSS is out there, available for no money. Whatever you want to say about "free speech vs free beer", in the real world, the two go hand in hand.
        
        

Sabotages revenue models

                
This leads on from the previous point, and it relates to the fact that companies with existing applications that were previously sold for money cannot compete with a product that is available for free. In the commercial world, this would be called "dumping", i.e. dumping a whole bunch of product on the market in an effort to drive prices down, thus forcing your competitor out of business. Whether OSS proponents want to admit it or not, this is effectively what they are doing - dumping software into the world, for no fee (almost always). So, you might reply, these companies have to adapt or go out of business. But how to adapt to someone else offering an alternative to your main product for no money? Basically, when the market goes away, the business goes away. When Microsoft did this to Netscape, people said it was bad. But when OSS does it to other companies, it's papered over with platitudes about "adapting" and "freedom". Well, people are free to do this if they want, they can dump software out there for no fee and watch as existing companies go under. But don't pretend that you're not getting something out of this - OSS developers get peer respect (very valuable in that community) and an ego boost, and often a job. So it's not all about selfless altruism. Everybody does these things out of self interest, ultimately - even if it's simply about "feeling good about the world". Regardless, it puts companies out of business. Not that I'm saying that OSS shouldn't exist, remember that this is simply a list of the pros and cons. Sabotaging revenue streams would definitely seem to be a con, especially if you're on that side of the aisle which depends on the revenue stream.
        
        

Obnoxious community members

                
The Open Source community is largely composed of self-described "geeks", many of whom are quite obnoxious in their dealings with "lusers" who ask dumb questions. Aspergers syndrome aside, such people don't really help much. On the one hand, OSS proponents want to see all OSS products adopted widely by "normal" people. A big thread at the moment is how much "we" want "people" to use Firefox rather than Internet Explorer. But then, when a "normal" person asks for help, they often get slammed with an RTFA or "just fucking google it" sort of reply. Not always, but it seems everybody has encountered this at some point. So, the problem is that on the one hand we have geeks who truly desire that their stuff get used by millions of people, but on the other hand they truly are not emotionally equipped to deal with the human aspects of dealing with "customer support". You can't have it both ways; either you have to target geeks as your target audience, and then accept the fact that only a relatively small subset of the population will use your product, or else target the larger public and then brace yourself to deal with the clueless questions.
        
        

Scratching programmers' itches

                
Eric Raymond famously said that Open Source frequently gets started because of a programmer "scratching an itch". Well, that's great, and a fine motivation for writing software, but there is a hidden gotcha in there: When you have a lot of programmers scratching their own personal itches, this means that a lot of programmer tools get written. Where are the Open Source accounting and book keeping packages? I don't know, maybe there is a project out there, but apparently not a lot of OSS geeks are into running businesses, so I guess they just don't get written. This leads into the next point...
        
        

Cool stuff gets done, boring stuff doesn't

                
This applies to both new apps, and fixing bugs. Often, cool new features take precedence over old, boring bugs. For example, I am always seeing stories about some fantastic new whiz-bang feature in Firefox/Mozilla, but I still see the same tired old HTML rendering bugs, which have been there literally for years. One of the most visible and annoying examples is the following - this should be a simple <UL> list of three <LI> items, each of which has a link. Mozilla shows the first line with a spurious newline before the link (Note: As of 2008, this appears to have finally been fixed in the latest versions of Mozilla):

Bookmark | Edit | | Report | Link
File: mozilla_bug.html
Type: ASCII text
Size: 215 bytes

IE shows it correctly, as does every other browser out there. It's actually caused by the unclosed <A NAME="label"> tag, which used to be the way to put a label into your pages. Sometimes these label tags don't get a matching </A> tag. Browsers in general should be forgiving of harmless stuff like this, but Mozilla breaks on it. Another (possibly related) bug also appears in DL/DD lists, with the first line lacking any indent. Again, it's beeen there literally for years. So why don't I fix this myself? Well, I am quite busy enough developing my own projects, and I simply don't have time to get to grips with the huge amount of code that comprises Mozilla (or any other major OSS app) at this point. Anyway, the point is that developers who are working on something because they "feel like it" are inevitably going to be more drawn to the exciting stuff, rather than polishing off that documentation, finishing up that UI or making sure that those stupid obscure bugs get taken care of. So, do we see basic HTML rendering problems get fixed? No, we get more and more fancy features (such as mouse gestures) that make geeks drool and give the developers a great feeling of being cool, whereas in reality their browser is broken when trying to display some really basic HTML. Oh well.

        
        

Community image as pirates and outlaws

                
Open Source often seems to go hand-in-hand with software that attempts to circumvent encryption of one kind or another, or else enabling the free transfer of data over the internet without the encumbrance of copyrights or payments. It's all about freedom! That's fine for the people downloading the music and movies, but not so hot for the artists and movie makers who thought they were making something to be *sold*. Is it really "stealing"? Maybe not, because the concept of stealing inherently involves the concept of depriving the owner of something. When you copy a file, you deprive nobody of anything, from a simplistic viewpoint. Copying electrons is so much easier than moving atoms. But maybe we need to redefine the concept of stealing, to include promotion of an environment where stuff that should be paid for, isn't. It's not really up to you or me whether this song or that movie "should" be available to everyone for free - sure, we'd love it if it was, but hey, here's a newsflash - all these songs and movies are only available because a whole bunch of people PAID MONEY to access other such content in the past. Saying that "they're all rich and don't deserve it" sidesteps the issue, which is that by cutting off the money supply to an entire industry you will be strangling the very source of the things you desire. It costs money to cut a record, and even more money to make a large movie. Sure, a lot of music sucks these days, and most big-studio movies suck even more - but I'm not trying to make an argument supporting the movie studios here. There's a lot wrong with the industry as it is, for sure. But if you think that everything should be available for free, then you are delusional, because the rest of the world doesn't work that way. All the people making movies, songs etc have to pay rent, food and so on. They pay employees, and that money comes from us, the consumers. Hopefully they can work out some fairer ways to make the internet pay (e.g. reasonably priced legal downloads), but in the meantime we only hurt ourselves if we promote the "everything should be free" mantra. This only strengthens the hand of the corporations, who can go to governments and get laws passed that are the exact opposite of what we would like to see.
        
        

Constant rewriting, because it's fun

                
Programmers love writing new stuff. They hate fixing other people's code, or even going back over their own code and fixing stuff... that's boring. New code is exciting, innovative and so much more satisfying. Code always gets more messy the longer it's around - all the new features, bug fixes etc build up over time until the whole thing just looks bad. And most geeks have the kind of mind that loves order, so ... they rewrite. And then, in the process, they figure out the way it *should* have been done... and then, they break the previous version by changing the API or data formats. So then you, the user, are stuck between an old version that is reliable but no longer supported, and a new version that is "current" but buggy and incompatible with your existing setup... see my previous article on Rewrites Considered Harmful for more on this.
        
        

Often at the mercy of one person

                
OSS projects are often run by a single developer, usually the guy who originally made the thing. That can be a very good thing, since decisions don't get bogged down by committee. However, sometimes personalities can get in the way, and in the case of very popular and widely used tools, it can end up suffocating progress. If a person is hung up on one way of doing things, then if he decides not to add some feature that you think is very important, then it simply doesn't happen. And although one of the supposed advantages of Open Source is that you have the code and can fork the project, in reality this doesn't happen very much. The more popular the project, the less likely it will happen, in fact. This is particularly true for cases where the project leader *mostly* gets it right, but refuses to see the light for some lesser-known and not-so-popular issues. So then the not-so-popular stuff may be ignored, but nobody will fork the project because most people are ok with the way things are. This is of course true for any situation, even closed software, but the point is that in the case of Open Source, these things are often based on an individual's personality defects, rather than cold-eyed business decisions.
        
        

Bugs don't always get fixed

                
This one relates back to the cool stuff getting done, and the boring stuff not. I make it a separate point because one of the supposed big advantages of OSS is that "bugs get fixed". I just wanted to counter that this isn't always so. As I said before, there are bugs in Mozilla that have been there for a long time. I don't have time to fix them myself, but the point here is that nobody else who is *supposed* to be fixing the bugs is fixing them either. So when people go on about how great OSS is because all the bugs get fixed quickly... sure, high-profile security stuff might get fixed, but boring stuff gets left quite often. A company would probably have more of a disciplined approach to getting rid of bugs, because the developers would be driven by managers trying to get the bug count down to zero, rather than the developers being able to work on whatever they felt was cool today (e.g. browser tabs or mouse gestures)... which leads me on to:
        
        

Bloated, slower software

                
As time goes on, software seems to get bigger and slower. Somehow this seems wrong to me, but it is understandable - after all, computers are getting faster, and programmers' time is more important than getting the last ounce of speed out of some loop. However, I am seeing this taken to absurd levels - I take Mozilla as a good example, because they apparently went away to write a new browser, but came back with something called XUL (eXtensible User interface Language). This sounds great in theory, because it allows you to have platform independence for the user interface definition. However, the result was that every single goddamn thing in the user interface is now interpreted via this language, and so every goddamn thing takes forever to do, unless you have a fast computer. On my old 450 MHz workstation, it takes a few seconds to bring up a new Mozilla mail window, and there is a noticable lag between selecting a menu and the menu actually coming up. Now you may say that 450 MHz, I mean, *come on dude*, get with the times and just upgrade your computer. Well I did, and things are better now, but I am left wondering something: Why was every other program on that old box just fine in terms of performance? It was running RedHat 7.3 for a long time, and I thought that maybe there was just something in 7.3 that made Mozilla run slow. But then I recently upgraded the box to Slackware 10.1, and out of curiosity I checked out Mozilla... nope, still slow. I really think that the thing is just slow, sorry Mozilla! Also, the whole dynamic-interface thing turns out to have all kinds of security implications. Well, yeah, I guess if you make the entire interface dynamic then there might be some danger that somebody would work out how to do all kinds of stuff they shouldn't. And don't talk to me about Open Office or Java. The point is, I am noticing more and more software is getting bloated, slow and taking up huge amounts of memory. Since when did anything need 100MB to run??? I guess a lot of it is because of libraries, but part of me still recoils at the prospect of having all that code doing what I was pretty much doing 10 years ago with 100th of the memory and 1/10th the speed.

Ok, here's the point: Open Source software developers need to be aware that by making all these wonderful modules, libraries and toolkits, every time they make a new one they increase the dependencies between applications. Every time another person decides to write their own font handler or printing module, they increase the bloat again. One of the downsides to OSS is that there are so many people doing their own thing, that the end result is a whole bunch of software that duplicates basic functionality. One of the good things about Windows (in the old days) was that there was just one clipboard, one printing method, one font source...

        
        

Many different versions of the same app

                
How many text editors do we need? How many office applications? When a new user is installing a new Linux distribution, just about all they can do is throw up their hands in defeat and click "Install everything" because it's just impossible to tell what might be good and what is an incomplete, buggy piece of crap. So, more bloat. Sure biodiversity is great and all, but it's also not good to make people feel overwhelmed with options.
        
        

Lack of hardware support

                
The biggest thing that bugs me these days about Linux is that I can't just plug stuff in and go. And, the hardware support for Window is just sooo much sweeter... just looking at the special apps and drivers available for my Thinkpad under Windows makes me want to cry. Sure, it gets better over time, CUPS has made printing easier and USB is almost working for many devices. But if you get some new bleeding edge hardware, then nine times out of ten the CD only has Windows drivers, and it takes days to hunt down the right Google query to find the post on some obscure message board that tells you what kernel module to compile or disable to get the damn thing working. Also, I don't really like having to hunt down my monitor's horizontal and vertical sync specs in order to configure X windows... I just don't care about that stuff - Windows can detect it automatically, why after 10 years of Linux, can't we? This goes back again to the "geek syndrome", on the one hand geeks want everybody to use Linux, but on the other hand we turn around and sneer at people who aren't technically savvy. Sure, maybe there are distributions that do some hardware detection automatically, but I'm saying that it's been a LONG time, and we are still not really there yet. We as a community need to get the hardware vendors on board, and get them to be putting their Linux drivers on the CD alongside the Windows ones. I personally don't care if the drivers are open source or not - they are hardware drivers for crying out loud, you install them and they make the hardware work. You have to pay for the hardware, and as long as this is true, then it makes no sense to insist that the only Good driver is an OSS driver. Just make the damn hardware work!
        
        

Documentation written by hackers, for hackers

                
If I see one more man page which has page after page of description of obscure options I will never use, before coming to some simple examples of regular use right at the end... I will scream. I have seen documentation so bad that it describes in fantastic detail just how to do some really complex, advanced configuration task, but nothing whatsoever on how to actually start the goddamn daemon. For example, I remember trying to figure out how to get NTP working on my old RedHat box - all I wanted to do was keep the right time, but all I could seem to find was page after page on the protocol works and how to set up your own servers. Yikes. Come on guys - you'll never know how many people just quietly turned away from using your software, simply because the documentation SUCKED. Put some of that prodigeous brain power into trying to figure out what the average person will be wanting to do first. Not all the options, just the most common ones. Do this and I will forever worship your software. Make the simple things easy and the complicated things possible. This applies to server stuff as much as it does to UI.
        
        

Often driven by commercial version (i.e. Ripped off)

                
A lot of times (not always) OSS is simply a ripoff of some commercial package. This isn't good, because it goes back to the gripe about killing companies. How is a company supposed to compete with a free, reverse-engineered ripoff? I don't care if people make the case that the company "has to learn to deal with competition", it's not competition when it's free. And, once again, that free speech you keep talking about is almost always free beer too. What does it mean when we take a product that was developed by a company for the purpose of making money for their employees, and feed off it like a parasite to generate our own version, which we then make available for free? The people who work at the company put a lot of time and energy into developing the thing. Perhaps there was a long time during which they experimented with the best way to do it. Perhaps there were years of someone's life put into the product to get it to the point we see currently. Then we come along and skip to the head of the line, so to speak, and just skim off the final result to generate our version. Sure - maybe it's legal, and possible, and nobody's stopping you. But I don't think it's very ethical, that's just my opinion. Taking commercial products and trying to reverse engineer them to circumvent having to pay for using the product, while still benefitting from all the work that the company put into making the product popular in the first place... well, you have to make up your own mind.
        
        

Viral license not business-friendly

                
A lot of companies shy away from the GPL because it is seen as viral. In other words, if you write something using Open Source software, then whatever you wrote might be required to be OSS too. This scares a lot of companies, because they don't really want to reveal their techniques and code to competitors. Truth is, in many cases the fear is unfounded - you don't have to make your code Open Source unless you are changing the OSS or deriving from it in a special way... even I'm not too sure of the subtleties, to be honest. But when you can be said to be infringing the GPL simply by linking to some OSS libraries... well, that gets scary for companies. And, to be honest, I don't blame them. While it's fine in theory to have a license that requires people to release back into the community whatever changes they make to OSS, in reality you will find it increasingly difficult to enforce this, in my view. We are starting to see it now - companies are being called to task for including modified versions of e.g. Linux in their hardware, but not releasing the source code. The simple truth is that they will continue to do this whether we like it or not - people will get away with whatever they can. Just like the file downloaders will.
        
        

Hard to make any money

                
When something is available for free ("beer", "speech", yeah, I get it) then it's kinda hard to make money from it. This is a big downer for someone who expects to develop OSS and then make a living from it. About the only way to do it seems to be to do the OSS thing for no money, and make your money doing custom apps for companies. But that's not making money from OSS (though you might be using OSS to do the custom apps). Let's face it, it would be nice to be able to write some cool toolkit, and then get paid for it. No matter what people say about computer code being like legal briefs (i.e. in the open domain) or free speech, at the end of the day we write stuff, and in every other profession you can get paid for your efforts. We are indeed a strange lot, arguing fervently for the destruction of the marketplace for the very things that we make.
        
        

Easier for hackers to get into code and make exploits

                
There is an argument to be made for the fact that Open Source code is more easily perused by hackers who wish to cause harm. Of course there's the other side of the coin, which is that the white hats can also see the code, but truth is that it isn't always true that thousands of different people are all diligently scanning the Open Source CVS for potential vulnerabilities. On the other hand, it's perfectly possible for black hats to do this, and when they do find a vulnerability, do you think they tell anyone about it? No, they use it. And they only tell their trusted black hat friends. Being able to see the innards of the code enables people much more easily to be able to see if there are exploitable buffer overflows, or other stupid mistakes that reveal an exploit.
        
        

Religious culture

                
Religious zealots are annoying, because they endlessly promote their particular set of dogma without really acknowledging that there may be other sides to the story, or that their viewpoint is just one of many potentially valid ones. The Open Source community seems to be overflowing with people who appear to believe that Microsoft is evil, everything they put out is crap, and Windows is just a big steaming pile of feces. Well, as someone who uses both, I can say that when it came time to put together my laptop for going on the road, guess what I put on there as the major boot? Windows 2000. Why? Because it "just worked". Yes I am a geek, but no, I didn't want to mess around finding the right drivers (when they exist at all) or configuring wireless or finding out how to get the damn battery monitoring working correctly. Windows does, mostly, "just work". As does IE. But, to hear the religious zealots tell it, this just cannot be so. And yet, it is. Hmmm. I wonder what this says about all the other religions.
        
        

Community unwillingness to face up to problems

                
This leads on from the previous point about religions. The OSS community cannot simply sit around bitching and moaning about Microsoft or Sun or Apple or whoever, without also taking a regular check on their own mental health. If a community becomes too inward looking and there isn't a conscious effort to be balanced and take other viewpoints into account, then it becomes a toxic environment.

Conclusions

        
Something that is being rapidly lost in today's world is the art of constructive debate and disagreement. Seeing things in black and white, right or wrong, seems to be on the ascendant. Such an absolutist view of the world is, in my view, overly simplistic and not helpful. There are many situations where there is no "right" and "wrong", but simply viewpoints. It often depends on where you are standing - for example, someone who works at a small company that sells software which is being undercut by an Open Source version will probably see things a little differently from a college student who has never tried starting a software company, but loves the "freedom" of Open Source. Likewise, a musician or movie maker who sees his work being pirated over the P2P networks on a large scale will probably see copyright law a little differently than the person who downloads such things, thinking that it's no big deal because, well, I'm not a bad person and it's just one movie anyway. Many people will, in most areas of their life, make all kinds of subconscious decisions based on self interest. Whether we like to admit it or not, most of us are governed by self interest. We see the world in terms that make sense to us, and we resent other people who see it differently (especially when the difference results in a clash where one party is deprived of something important to them, e.g. money). So, there is rarely a "right" and "wrong" (except in cases of scientific fact, and even that can change), but, more correctly, a constantly morphing sea of shades of gray. What was "wrong" decades ago (e.g. being gay, dating someone of different race, wearing certain clothing in public) is today seen as being a total non-issue by most people. Things that were seen as X rated in the movies of the 1950s are now shown on children's television on Saturday morning.

The point is, there is no right answer here (though I could be wrong about this ;-). So, I think the only reasonable thing to do is to try and get your mind around as many of the viewpoints as possible, so that you can appreciate other people's point of view and see why they are coming from where they are. If we can remember that everybody is generally operating from a position of self interest, whether they know it or not, then it becomes easier to understand the seemingly bizarre reactions to Open Source and other manifestations of the "free as in speech" mindset.

I think we have to accept that Open Source is not harmless. It threatens people's ability to make a living, and that is a fundamental, massive clash with the way our world has been developing for the last few thousand years. Commerce has been the way we support ourselves, and yet now we have a technology that seemingly makes information in all of its forms into a commodity that can be endlessly copied with negligable expense. We have a huge disconnect between the fact that all of this data took work to construct, and yet it is so easy to copy that people have an intuitive resistance to paying for it. Additionally, the very community that drives the digital revolution (i.e. geeks) has an inherent resistance to the concept of being restricted or told what they can and cannot do. Geeks are thinkers, and thinkers want freedom to be able to think up new ideas. Ideas are the currency of thought, and if we start patenting ideas then we risk destroying our most valuable asset - our ability to innovate. Innovation doesn't happen in a vaccuum, it always builds on what we see around us. Look at music from any particular era - you'll always see a lot of similarities in style between the different artists. In Mozart's time, people wrote music classically, not like the Beatles. Movie makers have been influenced by the Matrix, and so on and so forth. Everybody is a product of their environment. So when you start saying "Well, if you want to do *this* then you have to pay me", it obviously slams the brakes on innovation. And yet, and yet... surely inventors should be allowed to make money from their inventions, right? There's no easy answer here. You can make rules, and the rules will inevitably miss some crucial loophole which will then be mercilessly exploited. Humans are good at finding loopholes, we're good monkeys.

So, the big clashes of culture here are mostly the result of Open Source threatening someone's ability to make money. I don't think anybody would have the slightest problem with it otherwise. What could possibly be bad about people writing stuff and sharing it freely?

The other thing we have to contend with here is the religious mindset. This links into the tribal mindset, because we as people tend to want other people to believe what we believe. So when we have "faith" in something (which basically means not really thinking about it any more), we naturally a) want others to have faith too and b) lambast anybody who dares say anything different. This attitude naturally impedes useful debate, which is why religion is such a mess. Many of the world's religions are trying to integrate large, heavily modified texts from thousands of years ago into today's modern world. Many of the ideas just don't fit any more, and yet the very dogma that ensured the religion's survival through all these generations is now a huge impediment to any kind of useful dialog. If you have two sides, both saying that they have the One True Word and the other side is wrong, then how do you resolve this? You can't. We need to be careful not to become so entrenched in our thinking that we fail to appreciate the other side of the story. Open Source *is* a religious issue, because it involves faith - one of its central tenets is that knowledge and software should be open and shared, that this is fundamentally (I use the word consciously here) and self-evidently a Good Thing. But, it's not that simple! Other people get hurt by this approach. Simply saying that what you do has only the effect on the rest of the world that you are willing to see, and then ignoring the other effects, is being religious; it's ignoring the reality that everything has an effect.

So, what's the conclusion to all this? The story is still being written, but if we can be as self-aware as possible and tolerant of other viewpoints, then perhaps we might come out of it with a better world, more freedom and some semblance of a civilization worth supporting. Otherwise, if we are shrill and obstinate in our hatred of the people who would get in the way of the OSS juggernaut, then we might find ourselves on the wrong end of a backlash that includes public distrust, increasingly draconian government regulations and laws, and ultimately a poorer world, both economically and spiritually.

Thanks for reading.

-Neil Gunton
June 1st 2005


"Open Source Pros and Cons" Copyright © 2006-2014 By Neil Gunton. All rights reserved.
Website Copyright © 2000-2014 by Neil Gunton Wed 22 Oct 2014 20:45 (US/Pacific) (0.117s)      Top    Link    Report    Terms of Service