Why Punks Should Support Open Source

by Kai MacTane

This article was written quite a few years ago, and many of the events referred to in it are no longer as “recent” as they were described here. Nonetheless, I’m keeping the article intact for historical reasons. All the issues are still relevant...

Your hair is brighter than a fire engine, in three different colors. Your jacket has enough spikes on it to use as a weapon, and your face has enough metal in it to set off the airport’s metal detectors at thirty paces. So what does this have to do with what kind of software you use?

If you’ve done all your computing on the Windows and Macintosh platforms, you may not really comprehend the buzz about open-source. Why does anyone give a damn?

What the Fuck Is "Source", Anyway?

“Source”, in computing, means “source code” — the human-readable instructions that become a program. Stripped of all the geeky details, source code is essentially a recipe or blueprint for how to make a particular computer program.

When you download some .exe file off the net, or buy some shrink-wrapped software in a store, what you’re getting is a “precompiled binary executable” — the thing that’s made from the source that someone wrote. It’s sort of like going into a restaurant and ordering a meal — you get the meal, as laid out by the recipe that the chef, cook or minimum-wage burger-flipper is following. You don’t get the recipe, and if you want to change the food — or even just know exactly what’s in it or how you might make it yourself — you’re screwed. But what if you could get the raw source code instead (or as well)?

That would be like having the recipe. You could see what went into the meal, you might learn a little about cooking in the process, and if you felt like going into the kitchen and messing around with it, you could put your own twists on that food and turn it into something new.

The standard capitalist corporate regime is committed to only selling precompiled binaries; companies like Microsoft, Apple, Adobe and so on consider their source code to be proprietary business secrets, just like McDonald’s won’t tell you what’s in their “special sauce”. But not everyone thinks this way. There’s a whole movement out there called “open source software” or even “free software”. And when they say “free software”, they mean free as in “free speech”, not as in “free beer” (though their software is usually free in both ways).

What Makes it so Free?

The basic tenets of free software are like this:

  1. People should be able to get the source code for the software they’re using;
  2. They should be free to make changes to the source code, thus changing the way the program behaves;
  3. They should be free to redistribute the modified code, thus sharing their changes with others; and
  4. They should not be able to deny other people those freedoms.

You’ll notice there’s nothing in there about money, so charging for free software doesn’t make it un-free in the sense of being restricted, it just makes it un-free in the sense that it costs money. This is why free software advocates object to having their stuff called “freeware”: that phrase more commonly applies to software that’s available for no cost, but which doesn’t include the source code.

In practice, however, most open-source authors make their software available for free. If they want to make a living doing it, they charge for documentation, support and consulting rather than the software itself. (This makes sense, because software is very easy to duplicate, while duplicating printed documentation is annoying, and “duplicating” support and consulting is impossible.)

The general idea of free software is that when you buy or download the stuff, you are free to do what you want with it. This is much more in tune with punk philosophy than the proprietary model of software distribution, where you have to accept a license agreement that basically says you have no right to expect anything out of the software, you don’t own it, and you can only do things with it that the corporation approves of.

What's So Cool About Having the Source Code, Anyway?

One of the major uses of source code is customization. With the source code for a program, you can make it behave however you like. (Of course, you have to speak the computer language the program’s written in...) Lots of places have used Linux’s source code as a way to adapt it for specific purposes, like some examples that I really ought to research.

Power to the People

But there are other benefits to having the source. One is simply being able to inspect the code. You may have heard rumors about Windows 98 sending personal user information back to Microsoft, or security holes in this or that program. Microsoft claims it’s discontinuing that practice of Windows 98, and that it had no idea users would be so upset. But how do we know they’ve really turned it off? How do we really know anything of what’s actually happening in the guts of Windows (any version) or even MacOS? We basically have to trust that what Microsoft (or Apple, or whoever...) tells us is true. You can’t get the source for their software. If you could, though, you could read it and see: “is there anything here that sends out information without telling the user?” “Is there anything here that an unscrupulous user (or corporation!) could use to breach security?” “Is there anything here that’s going to bite me in the ass later?”

And if there is, that’s where the “customization” comes in real handy.

Ask a computer security expert “does Windows 98 still send your information back to Microsoft?”, and the answer will be something like “probably not, but it’s very hard to be sure.” Ask that same expert “does Linux send your personal information to Red Hat (or whatever company you got it from)?”, and you can get a definite answer. The code is there for all to see. How’s that for corporate accountability?

There have been quite a few cases where a security hole was found in software that was out in wide use on many different operating systems. Without exception, the open-source systems had the holes patched within two weeks — sometimes even within a few hours. The proprietary OSes generally took months; usually they just put the bug-fix in with their next scheduled upgrade, according to timetables set by marketing. The “ping of death” is the best example, but there have been many others.

If you have the source, and you hear of a problem, you can fix it yourself. Even if you don’t speak any computer languages, you can pay someone else to do it. (“Hey, dude, if you’ll patch my program I’ll give you a case of beer.”) But if you’re using a proprietary OS, like Windows (any version) or MacOS (also any version), you’re completely out of luck. The only people who have the code, and thus the only people who can fix the bugs, are Microsoft and Apple. And if they don’t feel like the problem is important enough to warrant an immediate response, you’re screwed.

The Features You Want

Most importantly, however, open-source software is modified and evolved by the people who use it. At Microsoft, Apple and other large software companies, features are added sometimes because the developers find it easy to do, more often because the marketing department thinks people will want it. Sometimes they’ll even demand that certain features be put into (or kept out of) a piece of software just to strengthen their market position or hurt a competitor. The marketing department will then tell the consumers that “consumers have asked for it”, and people who think it’s a piece of crap will assume they’re the lone dissenters, because they don’t have access to the company’s market research.

With open-source software, there is no marketing department to insist on certain features. There is no “corporate bottom line” to protect, there’s only the stuff people write because they think it’s useful. Come on, who do you know that ever “wanted” the bouncing paper clip in Office 97?

With the source code, you can make the software do what you want, not what the people in Redmond or Mountain View think would be “good for you” — or for their profit margins.

Open Processes, Open Protocols

There are a couple of other important things about open-source software that aren’t immediately obvious. One is that is simply produces better, faster, stronger and less buggy software than the standard, closed, proprietary way of doing it. Eric Raymond, a noted open-source theorist, has explained why this is in his essay The Cathedral and the Bazaar, but it basically comes down to the fact that the open-source model turns everyone who uses the software into a bug tester and even a potential co-author. That means you can have millions of people capable of finding — and fixing — your bugs. That’s far more programmers than even Microsoft can afford to hire.

Even more importantly, open-source software naturally works with open protocols. A “protocol” is a way that any two computers communicate — for example, communication on the World-Wide Web is done by HTTP, the HyperText Transfer Protocol. (That’s what the “http://” stands for at the front of a URL or “Web address”). Email, on the other hand, may be transmitted using SMTP (the “Simple Mail Transfer Protocol”) or POP (for “Post Office Protocol”), while other files may be transmitted by other protocols.

Protocols in wide use on the Internet are generally documented in standard manuals called RFCs, so everyone who wants to make software that uses those protocols can check to see how the protocol works and how their software needs to work if it’s going to speak the protocol properly.

But big corporations don’t always follow the standards. In fact, a common tactic of megacorps that want to control a market (or build their market share) is to release a product that mostly follows a given protocol, but also adds some new features. Since they don’t release the source code that would tell people how the new features work, and they don’t release the specifications on their additions to the protocol, nobody else knows how to make a product that has those features. This gives them a marketing advantage: “Why buy any other company’s program, when ours is the only one on the market with Feature X™?” But it does it by creating a new, secret way of doing things, and helps make it harder for computers (and therefore, people) to communicate with each other. Just what big corporations want, of course, but is it what we want?

Even worse, a company that already has a very large market share may even try to hijack or replace an existing standard. They can do this by flooding the market with software that does something that isn’t part of the standard, knowing that if enough people start using it, others will have to adapt just to remain compatible with the first group. And if the software is everywhere, then a good number of people are practically guaranteed to try it out. If you can keep anyone else from figuring out how to make their software do what yours does — perhaps by making the process needlessly complex, in addition to not providing any documentation on it — you can drive your competitors out of business this way.

(Netscape was one of the first companies to try this trick: when their Navigator Web browser was used by about 90% of Web surfers, Netscape introduced new tags like <CENTER> that weren’t part of the HTML spec. Soon everyone was using the Netscape tags, and any browser that couldn’t understand those tags became obsolete. Eventually, the World Wide Web Consortium had to rewrite the spec to include <CENTER> and other Netscape tags.)

But you can’t do this sort of thing with an open-source program, because any programmer can read your source code and figure out exactly how your program does what it does. They can even copy your code directly into their own program to duplicate your software’s abilities. One catch, though, based on the fourth tenet of the free software ideals listed above: if someone copies code from your open-source program into a new program, they have to release that program as open-source as well! Not the sort of thing corporations really want to get involved in, but excellent for insuring that secrets get out where everyone can see them.

What Are Some Examples of Free Software?

The one that’s gotten the most media buzz lately is Linux, the open-source Unix-based operating system. It does the same stuff as other operating systems (like Windows 95/98/NT or MacOS), plus a lot more. In addition to managing your files and hardware devices, supplying Internet connectivity and a graphical interface, Linux comes with a complete development environment (allowing you to write your own programs), a Web server (allowing you to “publish” your own pages and sites on the Web), and much more. Plus, it’s faster, more stable, more reliable and more customizable than Windows NT, at a fraction of the price. (Many people say that the price — free if you download it — is unbeatable. But part of the point of having the source code is that the customizability is even more unbeatable: you’ve got the source code right there, so anything you want it to do, you can make it do, if you can write the code for it.)

A new player in the open-source world is Netscape’s Navigator Web browser. Though Navigator started life as a proprietary standards-breaker, the execs at Netscape were eventually convinced (partly by The Cathedral and the Bazaar) that turning the browser into an open-source project would be a good idea. The Mozilla browser and project are now irrevocably part of the open-source world.

A Web browser would have nothing to browse if not for Web servers, the computers (and associated software) that show Web pages to browsers. The most widely-used server software on the Web is Apache, an open-source package well known for its speed, reliability, stability and versatility. Despite Netscape and Microsoft spending countless millions to promote their Enterprise and IIS servers, Apache still has over 50% of the market — and is gaining ground.

The original email server program, Sendmail, started life as an open-source project. Recently, the software’s main author has decided to start a company that sells a commercial version and distributes a free (and open-source) version. How free and open the software will stay remains to be seen.

FreeBSD is another open-source operating system, similar to Linux. It has also spawned some spinoff projects, called OpenBSD and NetBSD. All of them are open-source Unix-based operating systems.

For programmers, there are the GNU tools, made by the Free Software Foundation, the programming project that originated the whole idea of open source in the first place.

There are many other, smaller open-source projects as well — not just too many to list here, but too much for this author to even keep track of.

The Corporate Counter-Attack

You might expect that corporations are doing something to protect their “proprietary secrets” against the onslaught of open-source code entering the marketplace, and you’d be partly right. Some companies are actually looking at the idea with open minds, and some have even embraced it. Netscape, for example, decided in early 1998 to release the code for Navigator — if you have a reasonably fast Net connection and some spare time and hard drive space, you can now download the complete source code for what’s soon going to be Navigator 5.0. [Update: It became Netscape 6 instead, but you can still download the Mozilla source code it’s based on. — KDM] You probably don’t want to, unless you’re experienced with large and complex software projects, but you can. Netscape doesn’t mind. IBM and Apple are also experimenting with open-source projects, of varying degrees of openness.

Microsoft, on the other hand, is gearing up for an all-out war against the open-source community, and particularly Linux, which it sees as a competitor. And they don’t plan to play nice at all. After Netscape released their Navigator source code, on March 31, 1998, Microsoft commissioned an internal review of exactly what the threat from open-source software was, and how best to combat it. Some anonymous, ethical soul within the company leaked it to Eric Raymond (the author of the aforementioned The Cathedral and the Bazaar), and he posted it on the Web, with comments, on Halloween weekend of 1998. The memo, which Microsoft acknowledged as an internal strategic document, was titled “The Halloween Memo”. It’s kind of long, but the gist of it is that Microsoft is scared that free software will beat the pants off of Microsoft’s stuff in the marketplace, and that Microsoft needs to crush it. One of the proposed methods for doing this is to “de-commoditize” the open protocols that open-source software promotes and relies on — to keep their profit margins healthy, they’ll hijack any protocol they feel like, replace open, well-documented ways of doing things with their own secret processes, and lock everything up tight in their unreadable source code.

What Can the Average Punk Do?

The “ideologically pure” party line on that would be “don’t use any proprietary software, spread the open-source (or free software) gospel anytime you can, and write lots of open code.” But not everyone can do that, and I’ve never toed party lines anyway. Here’s my advice:

Other Information

If you like KMFDM and hate Microsoft, you’ll love KMFMS. Anti-MS information and art by Brute in the same place — what more could you want?

Kai MacTane has been webmastering the GothPunk.com(Munity)’s site for five years now. Being a goth-punk hasn’t stopped him from also being a geek (who’s proud to run the site on open-source software).