Open Source: What It Is and Why It Works

Rebekah Yoder

Open source has dramatically changed the landscape of how software is created and how software is treated. There are thousands of open-source programs available for use, learning, and as a basis for other programs, many of them free of cost. Yet most people don’t know what open-source is, let alone about the massive library of code available to make their lives easier and their businesses run more effectively.

What Is Open Source?

An open-source program is a program for which the source code–actual human-readable instructions to the computer, written in a programming language–is available for anyone to see, modify, and redistribute. There are some more formal requirements beyond that for a program to be considered open source, but they’re fairly general and easy to follow: things like lack of discrimination against users and no restrictions against the ways you can distribute or use the program. Pretty simple stuff.

There are different open-source licenses with different permissions. The popular open-source hosting platform GitHub has carefully put together a simple explanation of the different licenses.

Why Does It Help Me?

Using open-source software has many benefits. For the average home user, it often means an inexpensive or free piece of software as a replacement (quite often an improved replacement) for some more expensive proprietary program. Common replacements might be using a Linux distribution such as Mint or Ubuntu instead of Microsoft Windows, or using GIMP (the GNU Image Manipulation Program) instead of Photoshop.

Beyond the benefits of price, the user support for open-source programs tends to be superior over proprietary options. Popular open-source programs may have a very large and dedicated developer base. The Linux kernel lists over 5,500 contributors as of this writing, and even smaller programs such as GIMP (185) and gedit (251) may list several hundred developers adding features and fixing bugs. Keep in mind that gedit is simply a text editor, but if you find a bug in it or have thought of a feature a lot of people would find handy, there are 251 developers ready to hear what you have to say.

Furthermore, if you happen to be a developer yourself and you find a bug, you can change the code yourself to fix it, and then share your changes with everyone else by issuing a pull request on GitHub, which lets the person maintaining the code incorporate your fix. This is in opposition to waiting for your proprietary source to fix things themselves, at the expense of your time. (And, if you’re Dilbert’s company, money. Lots and lots of money.)

Dilbert comic strip by Scott Adams

[Dilbert comic strip by Scott Adams, used under Fair Use for commentary in this essay]

The developers are just a slice of the help you can receive if you have trouble with a program, however. Large projects, such as the different Linux distributions or Mozilla Firefox, often have a dedicated forum or two full of the program’s users, who often cheerfully answer questions posed by any newbie to the software on installations, how to use certain features, and how to solve problems. Tech support lines provided by corporations, on the other hand, are notorious for their automated phone systems and ultimately not very helpful “assistance.”

Freedom In Software and the term “Open Source”

Open source started with the Free Software Foundation, which has a philosophy on the essential freedoms of software users: to run the program, to study and change its code, and to redistribute the original and/or the user’s own modified version. The Free Software Foundation is responsible for the GPL (GNU Public License), among several other popular open-source licenses, as well as a large chunk of the software used on Linux.

Open-software grew from the FSF’s free software, for two reasons. One was that not all developers agreed with the philosophical views of the FSF, even if they wanted to encourage collaboration; the other was that some people were getting confused as to what “free software” meant. Eric S. Raymond, a prominent developer in the open-source community, explains it very well in an introductory document to open-source developer culture:

What is now called “open source” goes back as far as the hacker community does, but until 1985 it was an unnamed folk practice rather than a conscious movement with theories and manifestos attached to it. This prehistory ended when, in 1985, arch-hacker Richard Stallman (“RMS”) tried to give it a name — “free software”. But his act of naming was also an act of claiming; he attached ideological baggage to the “free software” label which much of the existing hacker community never accepted. As a result, the “free software” label was loudly rejected by a substantial minority of the hacker community (especially among those associated with BSD Unix), and used with serious but silent reservations by a majority of the remainder (including myself).

Thus, the term “open source” was coined, allowing a distinction from the ideology of the FSF. (Quote is a continuation from the last source.)

The term “open source”, however, had not yet emerged; it would not do so until early 1998. When it did, most of the hacker community adopted it within the following six months; the exceptions were a minority ideologically attached to the term “free software”. Since 1998, and especially after about 2003, the identification of ‘hacking’ with ‘open-source (and free software) development’ has become extremely close. Today there is little point in attempting to distinguish between these categories, and it seems unlikely that will change in the future.

The FSF and GNU Project, however, still distinguish between the two terms.

Are They Really Better? Why?

Open-source advocates are often heard making a case for the superior quality of open-source programs.

Bugs are fixed quickly

“Given enough eyeballs, all bugs are shallow.” -ESR

The idea is that with enough programmers looking at the same buggy code and trying to fix it, the best fix can be found. This is usually the simplest fix, which is implemented the fastest and pulled into the main code branch the fastest. If the simplest fix is not the best, a later programmer can always offer a second pull request and explain why he thinks his solution is better. Depending on the judgment of the project’s main developer, this may be incorporated or not.

Multiple options

The judgment of whoever is in charge of the code base is typically respected and let be–however, there are some cases where the differences of opinion are large enough that the dissenting programmer may copy in the rest of the code base and start his own version of the project. To the proprietary world, this often receives a knee-jerk reaction similar to that when someone mentions an act of plagiarism, but it’s completely normal in the open-source world. It also allows users to choose which version of a program they prefer. In theory this might mean that a single program could have dozens of versions, but due to the effort involved in maintaining an open-source project, forking projects into entirely separate entities tends not to happen unless there are serious design differences that might be important to users.

Indeed, there is a single open-source program with dozens of different versions: Linux itself. (No, I’m not talking about the actual kernel; I won’t get into semantics here.) There’s a reason there are so many distributions; each is a little different, because there are many types of users and they want different things from their computers. Ubuntu and Mint are tailored for desktop users, Red Hat for enterprise use, Kali for security testing, and Debian for servers. Of course, they aren’t limited to those roles–I personally am very fond of Debian for programming and desktop use–but they do have different interfaces, different programs installed by default, and in some cases slightly different software available. Linux is a very good example of a forked project which morphed and evolved into something where users would care about choosing a version.

Finally, a developer has the last and ultimate option of changing the program herself.

Users are listened to more

With less time spent on bugs, programmers are freed up to work on feature requests.

“The next best thing to having good ideas is recognizing good ideas from your users. Sometimes the latter is better.” -ESR

Users who are also co-developers have an advantage over corporate developers who may or may not have actually used the product they’re working on from a user’s perspective. The latter will have opened the program for testing, but have they tried to use it for its intended purpose? Maybe, but depending on the product, probably not. The developer-users of the open-source world therefore have an advantage in how well they can relate to comments and feature requests, even from users who are not fellow programmers.

Developers are self-selected for interest in the project

“To solve an interesting problem, start by finding a problem that is interesting to you.” -ESR

Really, this is a huge advantage over corporate programmers who have merely been assigned to tasks without mind to whether they enjoy a particular project. The average software company’s level of priority given to “Are the employees having fun?” might be a pool table in the break room. They usually don’t consider that the personal preferences of a dev do have an effect, for better or for worse, on the quality of their work.

Programming is a highly creative pursuit, so the mindset and emotional state of the programmer matters a lot. Developers don’t like to be bored. They work best on things they’re interested in. It’s a natural human reaction, not just laziness; they can’t help it. Imagine how productive you’d be sorting rocks–unless you’re a geologist, in which case you might like sorting rocks and be very quick and accurate doing it.

The video below (around 5:30) makes an example of one Australian software company named Atlassian. They gave their programmers one day per quarter–24 hours–to work on whatever they wanted with whoever they wanted, without interference, and they got to show it to the rest of the company at the end of the day. The result, as stated in the video, was that the programmers quashed a plethora of bugs and made a lot of great new stuff too.

In the open-source world, no one is forcing you to make something you don’t want to make.* For instance, if you don’t like making database software (and a lot of programmers don’t), then the only time you’ll be working on it in the open-source world is if it’s a crucial part of something you do like working on, which makes the drudgery easier to take. Or you may be able to foist off work you don’t like onto co-developers who like it better (and will therefore do a better job with it).

This self-selection means that programmers who will be most effective at a job are the ones who gravitate towards completing it, improving the overall quality of the software.

*Excluding those instances in which you’re getting paid by your company to work on a specific open-source project. That happens! But people who are skilled enough to get those jobs can probably take their pick of positions anyway; there’s no shortage of options for them.

Effects on the economy

Naturally, when open source first took hold of the software community, many feared that software development job openings would take a hit. Not so–we’re finding that it’s creating them. More and more companies are using open-source software and need developers and system administrators to support their projects.

Now, it’s common for software job applications to ask for a GitHub account. There’s been some controversy over whether it’s ethical to require workers to produce work without paying them and allow anyone to see it (if you want private repositories on GitHub, you have to pay to upgrade your account). However, judging candidates on the merits of their personal coding projects is arguably more effective and less discriminatory than requiring certifications or a college degree, as the latter requires money which would rule out candidates living below the poverty level and prevent them from finding low-risk, high-paying jobs in technology; the former merely requires a computer with an Internet connection and free time. (Admittedly, this is a large privilege in itself, but the barrier to entry is much lower than when formal education is required.)

In the late nineties, however, big software companies weren’t sure if they were going to survive the open-source revolution. Microsoft in particular panicked, especially when the infamous Halloween Documents were leaked, revealing how nervous they truly were. (There was some doubt over whether the documents were genuine, but Microsoft has indeed confirmed their authenticity. Admittedly, that citation is old, because this all happened 15-17 years ago.) The documents speak of tactics such as “FUD” (fear, uncertainty, and doubt) which were used to make users unsure about trying Linux and open source software, an unknown quantity, and to stick with Microsoft products because they had a known brand name. There’s also a suggestion of trying to turn open protocols into something controlled by Microsoft as an additional tactic against the open-source community. Whatever you think of Microsoft and the relative validity of the papers, this is a good example of how anxious software corporations were becoming in the face of open source.

But the question of whether open source is good for the economy isn’t really in debate, at least not any longer, and not by anyone who understands the concept of wealth. Any action or process which creates something valuable–like software–is good for the economy in general no matter who gets money for it and how, or even whether they do. Something exists that did not exist before (a good or service), somebody needs it, and money is only a stand-in to represent that creation.

Summary

This essay is now over 2,000 words, so let’s recap.

We’ve learned that open source is a software development method in which anyone can see, change, and redistribute the code. It’s better for users and companies than proprietary software because it’s often free of charge, it can be modified by the user, and it’s often well-supported. It’s better quality in general because there are lots of people fixing bugs, lots of different use cases being supported because anyone can make a different version of the program, feedback is taken more efficiently, and the developers enjoy what they’re doing. It’s also great for the economy, because it’s been creating jobs (despite fear that it would destroy them), and it’s also been creating wealth, which makes our society a little bit richer every time something valuable is produced.

I’ve been trying to come up with a joke or at least a conclusive-sounding sentence to end this essay, which is fast approaching 2,500 words, like a phone call that won’t end because neither party will admit they want to hang up. So, you’ll have to make do with that half-joke, and my thanks for reading.

Happy coding!

Sites linked in this essay

These are general addresses of sources I used earlier, listed here to outline where I’m getting this information. In some cases a site was used more than once. To find the exact pages I draw from, use the links in the essay.

Organizations

The Open Source Initiative: http://opensource.org

Github and related sites: http://github.com, http://choosealicense.com

The Free Software Foundation and related sites: http://www.fsf.org, http://www.gnu.org/philosophy

Product websites

Linux Mint’s official website: http://linuxmint.com

Ubuntu’s official website: http://www.ubuntu.com

GIMP’s official website: http://www.gimp.org

Mozilla Firefox’s forum: http://forums.mozillazine.org/viewforum.php?f=38

Papers, essays, videos, and magazines

[I list ESR’s papers separately, as they’re important citations and his web site can be harder to navigate if you haven’t been wandering it for a while.]

Eric S. Raymond’s paper on how to become a hacker (proficient open-source developer): http://www.catb.org/esr/faqs/hacker-howto.html

Eric S. Raymond’s paper “Cathedral and the Bazaar”: http://catb.org/~esr/writings/cathedral-bazaar/cathedral-bazaar

Eric S. Raymond’s annotated versions of the Halloween Documents: http://www.catb.org/esr/halloween

Paul Graham’s essays: http://www.paulgraham.com

YouTube: http://www.youtube.com

Computer World: http://www.computerworld.com

Info World: http://www.infoworld.com/

Microsoft’s admission: http://web.archive.org/web/19991013112307/http://microsoft.com/ntserver/nts/news/mwarv/linuxresp.asp

Last but not least:

Dilbert comic: http://dilbert.com/

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s