So I made a flashlight

Ever wonder how a flashlight is built.  Here’s how I built mine:

The first thing a flashlight needs is a lens

Let’s give it something to look at

but what does it see?

maybe we should make it transparent?

but no real lens is that clean.  Maybe it has finger prints?

maybe not that bad?

perhaps it’s dirty?

It’s both:

What’s behind the lens?  A reflector

what does that look like?

Isn’t there a light inside that reflector?

From another angle:

let’s protect the lens:

What color is this flashlight, anyway?

it’s dirty too:

and it has a logo:

Doesn’t it need something to attach to?

It’s red too:

and easy to grip:

and dirty:

But wait. Don’t we need a barrel?

that’s red:

with a grip:

and dirt of it’s own:

and a button

that’s black

and to finish it up, a tail cap

yup, it’s dirty

Let’s give it some place to sit

that looks less like an operating table

and isn’t just a side on view

how about some sun light?

and something reflecting the sun back at the lens:

That looks OK. Let’s take its picture and see what we think

Open Source Software Development: No magic bullet

I got about 2000 words into a long diatribe that nobody, not even me, would read.  I boiled it down to this: Since the 1950s, developers have variously, given away, sold, or denied access to the source code for the products. Some gave it away without any consideration about what would be done with it. Others imposed a range of restrictions on how the source code could be used. If the source is not available, or only available at a cost, it is said to be closed, or proprietary software. If it is available at no cost, it is said to be open software. Advocate of open source assert that because it is developed in a different way than proprietary software that it is superior. Among other things, it is said to have fewer bugs, including security holes, then proprietary software.

This claim is admirable in theory. In practice, it turns out to be erroneous. Direct comparisons of proprietary and open software intended to perform the same task, for instance operating systems, routinely shows that there is no noticeable difference. Both turn out to be just as buggy and insecure as the other.

The difference between theory and practice in this case is that the claimed advantages either do not exist, or are balanced by other factors. A stated advantage of open source development is that because the source is inspected by many people, bugs will be found and fixed by developers before they reach users. In practice, few people other than the original developer examine the source code looking for bugs. Even the developers, once they have finished their initial testing, will rarely read the code again, unless they are examining it to find a bug reported by users.

Simply put, the idealized model of open source development proclaimed by its proponents is not the way in which open source is developed.