As a Linux engineer, and long-time Open Source advocate, I was amused to hear the statement, "Who knows what Open Source really means, anyway?", particularly in the context - it came from a manager of an Open Systems team. I thought I might resist the urge to be snarky, and provide some clarity.
In the context of Open Systems, "open" is best translated as "transparent". That is, you get full and complete access to the code that runs your system. More than that, however, is that you get the ability to audit what the applications you run on your systems (business or personal) are actually doing. Consider the following real-life example:
In 1994, I was writing a small Visual C++ application to do various ROI tables for the company controller. It was a modest effort to be sure, but since it was going to be used primarily by non-technical managers, it had to be right. I was working on one of the screens containing a textarea control, into which the user is expected to type free-form text, and I anticipated one might try to submit some small tables of information. I set the font to a mono-spaced font to facilitate manual alignment of columns (remember - non-technical managers). During testing, I noticed that the text wasn't truly mono spaced. Different characters took slightly different widths. So, I called Microsoft, paid my $200 incident charge, and spent the next two weeks going back and forth with MS Devs to locate the source of the errant behavior. At the end, the support engineer from Microsoft gave up and could not find the root cause.
Throughout the entire process, I was beholden to Microsoft for assistance, and at no time could I challenge their engineer on any claim, as I could not see the source code (for the textarea control) that was at the core of the problem. Contrast this with another example:
Not too long ago, I was doing some performance testing for a new application being developed by a previous employer. One of the tools I used (netstat) provided exactly the data I required, but the layout wasn't exactly conducive to parsing, and extracting the output for other uses was more work than I thought it should be. So, I jumped on the internet, downloaded the source code for netstat, located the place where some modifications could be made to facilitate what I wanted to do, and after a little revision, was able to produce the output I wanted. I then took the changes, and submitted to the code's maintainer.
And yet another example:
static void wake_up_idle_cpu(int cpu)
{
struct rq *rq = cpu_rq(cpu);
if (cpu == smp_processor_id())
return;
if (set_nr_and_not_polling(rq->idle))
smp_send_reschedule(cpu);
else
trace_sched_wake_idle_without_ipi(cpu);
}
The above function is part of the Linux kernel's CPU scheduler. Anyone can get right into the core of the kernel, test it, change it, try new algorithms, and ultimately participate in improving it.
With openness comes access, and with access comes innovation. When everyone can see under the hood, anyone can improve what's there. When access is restricted, so too is the pool of talent that can generate new ideas for improvement.
And that is what open source really means.
