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 ( [e-mail]) 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/