magazines/2014/2/171691-bugs-and-
bragging-rights/fulltext), where I wrote,
“I think the propensity for program-
mers to label their larger creations as
operating systems comes from the need
to secure bragging rights. Programmers
never stop comparing their code with
the code of their peers.”
Why is this important? There are two
reasons. One is intellectual honesty. KV
prefers to see the credit go to those who
did the work. Linus Torvalds and his
team have built an important artifact,
out of many tools, that many people use
each day, so the credit goes to them, not
to the producers of the tools. It takes
more than a compiler, linker, and edi-
tor to build something as complex as an
operating system, or even the operating
system kernel, and many of the tools
that go into building Linux have noth-
ing at all to do with FSF or GNU. Should
we now rename all of our systems as
GNU/APACHE/FOO/BAR? Only a law-
yer would think of that, and by now you
all know what I think of letting lawyers
name projects. The second reason this
is important is to point out that while
GNU stands for “GNU is not Unix,” that
was a reaction against the AT&T Unix of
the 1980s. Now it might as well be “GNU
is not Linux,” because the tool is not
the thing the tool builds. But then, GNL
doesn’t sound as good.
KV
P.S. If you want to read the GNU side of
this story, pour yourself a strong beverage and start here: http://www.gnu.org/
gnu/ linux-and-gnu.html.
Related articles
on queue.acm.org
Open Source to the Core
John Hubbard
http://queue.acm.org/detail.cfm?id=1005064
A License to Kode
George Neville-Neil
http://queue.acm.org/detail.cfm?id=1217262
Desktop Linux: Where Art Thou?
Bart Decrem
http://queue.acm.org/detail.cfm?id=1005067
George V. Neville-Neil ( kv@acm.org) is the proprietor of
Neville-Neil Consulting and co-chair of the ACM Queue
editorial board. He works on networking and operating
systems code for fun and profit, teaches courses on
various programming-related subjects, and encourages
your comments, quips, and code snips pertaining to his
Communications column.
Copyright held by author.
system. If you want to see innovation in
any type of software, it is very important
to have the source. In 2016, more than
50 years after all these changes started,
it is now common to have access to
the source, because of the open source
movement, but this was uncommon at
the start of the Unix age.
Over the course of the Unix era, several open source operating systems came
to the fore. One was BSD (Berkeley Software Distribution), built by CSRG (
Computer Software Research Group) at UC
Berkeley. The Berkeley group had started out as a licensee of the AT&T source,
and had, early on, written new tools for
AT&T’s version of Unix. Over time, CSRG
began to swap out parts of the system in
favor of its own pieces, notably the file
system and virtual memory, and was the
first to add the TCP/IP protocols, giving the world the first Internet (really
DARPAnet)-capable Unix system.
At about the same time, FSF had,
supposedly, been developing its own
operating system (Hurd), as well as a
C compiler, linker, assembler, debugger, and editor. The effort to build tools
worked out better for FSF than its effort
to build an operating system, and, in
fact, I have never seen a running version
of Hurd, though I suspect this column
will generate an email message or two
pointing to a sad set of neglected files.
The GNU tools were, in a way, an advancement, because now software developers could have an open source set
of tools with which to build both new
tools and systems. I say, “in a way,” because these tools came with two significant downsides. To understand the first
downside, you should find a friend who
works on compilers and ask if he or she
has ever looked inside gcc (GNU C compiler), and, after the crying stops and
you have bolstered your friend’s spirits,
ask if he or she has ever tried to extend
the compiler. If you are still friends at
that point, your final question should
be about submitting patches upstream
into this supposedly open source project.
The second downside was religious:
the GPL (GNU Public License). If you
read Hackers, it becomes quite obvi-
ous why FSF created the GPL, and the
copyleft before it. The people who cre-
ated FSF felt cheated when others took
the software they had worked on—and
which was developed under various gov-
ernment grants—started companies,
and tried to make money with it. The
open source community is very clearly
split over the purity of what one devel-
ops. There are those who believe no one
should be able to charge for software or
to close it off from others, and those who
want to share their knowledge, whether
or not the receiver of that knowledge
makes a buck with it.
All of this background brings us to
Linux and its relationship to the GNU
tools. Linux is an operating system kernel, initially developed by Linus Torvalds in reaction to the Minix operating
system from Andrew Tanenbaum. Torvalds used the GNU tools—compiler,
linker, assembler—to turn his C code
into an operating system kernel and
then launched it upon the world. He released the code under a GPLv2 license—
the one it maintains to this day—rather
than taking on GPLv3, which is even
more restrictive than its predecessors.
Other people took up the code, modified it, improved it, and built new tools
and systems around it.
Now, to the point about naming.
When you build a house, you use many
tools: hammers, saws, drills, and so
forth. When the house is complete,
do you call that a Craftsman/House,
a Makita/House, or a Home Depot/
House? Of course you don’t. We do not
name things after the tools we use to
build them; we name things in ways that
make sense because they describe the
whole of the thing clearly and completely. Linux is an operating system kernel
and some associated libraries that present a mostly, but not always, Posix, Unix-like system on top of which people write
software. In point of fact, Linux distributions do not ship with the GNU tools,
which must be installed from packages
later. Linux is a thing unto itself, and the
GNU tools are things unto themselves.
That one might be used to work on the
other is irrelevant, as is the fact that I
am holding a Craftsman hammer from
Home Depot right now … must put the
hammer down.
The whole GNU/Linux naming silliness is probably a case of kernel
envy, not unlike the programmers
who feel their ultimate achievement
is to write a process or thread scheduler, which I addressed in my February 2014 column “Bugs and Bragging Rights” ( http://cacm.acm.org/