Two misconceptions about open source
There are a couple of ideas which circulate about open source1 projects which I think are misconceptions about how software is developed.
Throw it over the wall
The first one is about criticisms of projects where the developers publish the source code only for released versions instead of maintaining a public version control system. That is, tarballs are made available when the software is considered to be ready, instead of pushing all the changes in real time to services like Github or Bitbucket.
This started to annoy me when a couple of years ago, some bloggers and podcasters started to say that Android is not really open source, since the development is not done in the open. I am not at all a Google fanboy, quite the opposite actually, but I understand that both Google and the individual lone hacker in a basement, may want to fully control how their code evolves between releases without external interferences.
I personally don't do things like this, but if the source code is available, it is open source. It may not be a community project, and some may find ugly to throw code over the wall like this, but this is another thing.
Eyeballs and shallow bugs
The recent buzz about the Heartbleed bug has put back under the spot what Eric S. Raymond called Linus' Law:
Given enough eyeballs, all bugs are shallow.
Raymond develops is as:
Given a large enough beta-tester and co-developer base, almost every problem will be characterized quickly and the fix obvious to someone.
Right after Heartbleed, many voices in the inter-webs took it as a counterexample of Linus' Law. Their reasoning was that since the bug was introduced more than 2 years before, the fact that the source code was open didn't help to catch it quickly.
I think that the argument is flawed if we take into account the 3 steps involved in debugging software:
- Identify that a bug exists: some user (which may be one of the developers) detects a misbehavior in the software. This step may involve characterizing the bug in terms of being able to reproduce the wrong behavior.
- Find the bug: track down the issue until a limited piece of code is identified as containing the source of the problem found.
- Fix the bug: modify the source code in order to obtain the correct or desired behavior.
Usually, the second and third steps are the hardest, but they can't be taken until the bug is detected. After that, Linus' Law comes into play, and the more people looking at the source code, the more likely is for the bug to be found and fixed.
I don't like criticizing Wikipedia, but this time I think that the misunderstanding may come from explanations as the one in the Linux' Law Wikipedia page about Raymond's text.
I will use the term open source instead of free software because here the important point here is that the source code is available, not the particular license under which it is distributed.