Imran's personal blog

June 10, 2012

Debunking Closed Source software harm

Filed under: Uncategorized — ipeerbhai @ 7:44 pm

Hi All,

ESR wrote an essay titled examining the harm of closed source software.

Flat out, he’s wrong.  I used to work at a big. closed-source software company, and I do open source stuff now.  I’ve been in the real software world.  Not the “web world” where people writing html and css call themselves engineers.  (ESR is not one of those guys.  But the commenters on his blog almost certainly are. )  Or people in university wondering why people use closed source software.  There are those who are religious about open source or closed source.  But few have lived and worked in both worlds at a high enough level to see the differences.  So, I’ll get debunking.  I’ll also explain why closed source software is good — there are advantages unavailable in open source.


Open source advocates argue that open source software is more reliable.  That more eyes = more chances for code review = less bugs.  This is purely false.  There are 2 reasons:

  • All eyes are not created equal.  A good engineer is orders of magnitude better than a bad one.  You can have a thousand bad engineers look at a bug, and none will spot it.  A good engineer can do it in a second.  More eyes != better eyes. There’s another piece of information people forget.  Those who write software think differently than those who use it.  To many open source people, the glaring bugs in bad design( often, this is in UI.  But even without UI, this pops up everywhere.  Just the names of options to set in config files — or config files that don’t work by default on almost all deployments. ) are completely ignored.  I’ve seen many projects with terrible bugs go unfixed, since the author isn’t interested, and no-one else cares once they get it working for them.  Closed source fixes this — there’s someone else telling the author, “You must fix this, or I won’t pay you.”  This is why Apple, Nintendo, and Microsoft products are often far more complete and reliable than the FOSS equal.
  • Code review is not mandatory in FOSS.  In closed source, it almost always is.  Many FOSS programs have never been code reviewed.
  • Bugs are found by users, not developers.  It isn’t eyes on the source code finding bugs.  It’s real users, doing their real things, in their real way.  Open source software often doesn’t have the user base needed to find all the bugs.

Not to say that open source can’t be reliable.  Reliable open source has a “great engineer” in the mix somewhere.  Often, only one.  These people are so rare — but anything they do will be good.  At least in terms of quality.  They’re also so rare, that most open or closed source projects don’t have one at all. Closed source software can get a much better product out of the normal engineers that exist in the world, vs open source.  The reason is interest.  Closed source companies are interested in profit.  They’ll keep at a problem until that profit materializes.  Open source people are often interested in their own use case.  They’ll keep at a problem until it works well enough for them.  This core difference leads to a huge difference in reliability and usability.  Closed source often wins.  People sometimes say, “But linux is more reliable than windows.  It never crashes!”  I answer, “Linux is less complete than windows.  It never crashes, because it doesn’t do as much.”


Closed source software is far more often customized than open source.  Open source can cost less to customize — in some cases.  Anyone can go and modify the source.  Other than opportunity costs of your own time, there’s little cost.  But few people can do this.  Closed source software has 2 customization paths — feature requests, and contracts.  In closed source software, a feature request can be submitted to the maker of the software.  If enough people ask fo this feature, then management will add it.  This is because they want to sell, and know that feature requests == sales.  The only people in closed source who don’t know this are the unsuccessful ones.  So, the easiest way to get closed source software customized is to ask.  The other way is to pay for it. Most closed source companies have a way of custom modifying their software for a fee.

Agency harm

This is pure false.  Agency harm requires a closed market, not just closed source software.  As a consumer, you always have a choice.  Even if the other guys are also closed source.

Transition costs

This one could be true, but it just isn’t.  The reason for this is game theory.  Let’s pretend that some software becomes the default standard for something.  Say the default word processor.  Then game theory indicates that any other software must be compatible to succeed.  It increases the costs of development, since there’s now a reverse engineering step for any other software, but it doesn’t really affect the consumer.  I argue that it could be true — if the software is not dominant, then incentive to reverse engineer the format isn’t there, and then lock-in is possible.  But this is more true for SAAS than for closed source.  Your software can be open source, and you can have an externality that locks people in.  Reddit may be the best example of that.

Now, Open source software is in itself harmful, just as is closed source software.  In some cases, I’d argue that open source is more harmful than closed source,

The harms of open source:

Here’s a quick enumeration of the harms I have seen in open source software.

  1. False security.  Open source software has fewer users, often, and thus has fewer chances for all bugs to be found.  It’s also less likely to be maintained/patched in the long term.  As a result, many bugs exist that will never be found, but users use it as if it was reliable.  This is probably why Android phones crash so often or have so many bugs.  JD power ranked the least happy smart-phone users as those running 4G android phones.  There’s a reason for that.
  2. Prevent vertical integration.  The FOSS licences often prevent the kind of customization needed to improve the total experience.  A good example is in 3D printers.  The biggest problem in making 3D printers a “it just works” device that non-geek people can buy and plug in and get running is the software.  Many people go into the software problem, and many improvements have been made.  But improvements aren’t the answer.  What’s needed is a total stack.  Netfabb is the closed source software that takes the entire stack, and it gets the best results.  But no-one could start with a program like pronterface, and give it the ability to generate step-code.  It wouldn’t pay the author of that work in “recognition points” — which is the currency of open source.
  3. Not designed for users.  Open source software is written by people for themselves.  The few times that it isn’t, there’s some entity funding that as a game theory check.  Sun funded openoffice as a check against MS.
  4. Prevent innovation.  Open source software not only copies what exists in closed source ( aka the 3d Printer software copied what stratasys wrote ), but it also prevents innovation.  Open source software being in a space prevents people who want to write closed source software from entering that space.  There’s less profit in it, and the those people writing the closed source software are often completing the vision that the open source guys never will.

I’m not against open source.  I write open source now.  But open source is not less harmful than closed source.  It’s perhaps more harmful to the overall system than closed source.  If your point of view is only engineering, then open source software is less harmful, since geeks like to see and modify code.  But to the general population, open source disincentives better solutions, is hard to use and buggy, and is poorly supported.  The ethics of those problems is just as bad as the ethics of the closed source problems, and perhaps a bit worse.


  1. That’s an interesting perspective on open source. Now that I think about it, I don’t think I’ve ever seen anyone actually contrast the pros and cons…it’s always just pros. It hadn’t occurred to me that the existence of the RepRap project would be a disincentive for existing 3D printer manufacturers to move into desktop 3D printing. But now that you point it out it makes sense. There’s no telling how far the RepRap family tree will advance in the time it takes for an existing company to just do a market study, let alone get something to market. Eventually, with enough engineering, the thing will be come self-reproducing in a practical sense, and it’s impossible to handicap. I suppose it makes even more sense for Makerbot to move up into the plug-n-play desktop market when the biggies are hesitant to move down into it.

    Comment by mattmaier — September 21, 2012 @ 4:19 am | Reply

    • I wasn’t really thinking about size discrepancies between entities. RepRap may encourage big 3d printer guys to go into the desktop/home market, because it proves the market exists. Alternatively, it may create a disincentive as you mention. However, the bigger concern is that open source prevents vertical integration — a small company building the whole stack. For example, a small company building the electronics, the firmware, the GCode generator, the Windows/PC clients for managing the printer, the printer design, etc… Open Source creates a disincentive along every step of the chain to vertical integration. There are several reasons why — you now have to compete on every step of the chain, but some steps depend on steps below.

      For example, GCode generators depend on the firmware. Let’s say I have a new use case where I have multi-machine operations in a 3d printer( say extrude, colorize ) and wanted to make a new code, say I101 to enable it. Say that new code means something like, “strict order of processing GCode instructions” ( as opposed to prioritized GCodes ). In closed source, this is easy — I modify the GCode generator and the firmware to do this. But in Open source, this is hard. I have to compete with 2 different GCode generators( which generate slightly different GCode ), as well as maintain compatibility with them(since people now expect to be able to use them ). Open Source creates a game theory problem, as well as a technical problem ( I haven’t even gotten to the legal and other problems it created in this use case. ). Worse — open source would never create this change. You’d have to change 2 parts of the stack, owned by 2 different people, in a use case they can’t even see, much less care about. So you yourself would never make the change — just getting it approved and into the existing code would be a nightmare. As a result — everybody loses. Machines can’t innovate, just copy. There’s a natural reason why open source comes *after* closed source has already created the product. The way it works, via horizontal integration, and the way that best supports innovation, vertical integration, just aren’t compatible. I think some economists call this the coordination problem.

      Comment by ipeerbhai — September 21, 2012 @ 4:56 am | Reply

  2. Oh, so you mean like having one or more open source alternatives sort of splits the vote. Like it complicates things just enough that it doesn’t really accomplish much on its own, but it interferes with endeavors which could have accomplished more. Kind of like how a 3rd party candidate in an election doesn’t have a chance of getting elected, but they can pull enough votes away from another candidate to ensure they can’t win either. Is that more what you mean?

    It seems like your argument is trying to have it both ways. On the one hand you acknowledge that there usually aren’t very many users of open source technology, and there are even fewer who will ever consider editing the technology. On the other hand, you seem to be arguing that there are so many people using open source tech that they reduce the potential profit in the field, block innovation, and hold on to interfaces that prevent new users from joining. I don’t think those two arguments can be reconciled; they seem contradictory.

    Comment by mattmaier — September 22, 2012 @ 1:45 am | Reply

    • There are different scale issues. The Software argument is to large scale. The printer example is to small scale.

      Comment by ipeerbhai — September 24, 2012 @ 9:39 pm | Reply

RSS feed for comments on this post. TrackBack URI

Leave a Reply

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

You are commenting using your 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

Blog at

%d bloggers like this: