When is it GNU/Linux and when is it not?
Of the many controversies in free software, this is one that I have long found to be interesting. People seem to define things in different ways, which leads to confusion (and arguing) when one person calls a system a "GNU/Linux" system and the next calls it just the "Linux" system. Too often, I have found people saying "You must always call it GNU/Linux, Linux is nothing without GNU!" and this is simply incorrect. So, here I try to spell out the issues and when something is "GNU/anything" and when it is not.
Question 1: What is an operating system?
Here is a (very partial, heavy on the Unix-like systems) list of operating systems: GNU, FreeBSD, OpenBSD, NetBSD, Microsoft Windows, Mac OS, XENIX, AIX, OS/2, MS-DOS, PC-DOS, FreeDOS. All of these are full operating systems, though some are more compartmentalized than others. I hear some saying already, "But GNU is not an operating system!" Incorrect. When using the Hurd and a GNU userland operating system stack, that is the GNU system. I hear others saying, "But you left Linux out!" Correct, I did: Linux is not an operating system by itself. Many people are under the impression that the kernel is the operating system, and this is simply incorrect. A kernel is the core of an operating system, but it is not the operating system itself.
If the kernel is not the operating system itself, what is? An operating system consists of a kernel and software that is used to make that kernel useful—software that provides the user (or the programmer) with an interface to the kernel. An operating system in the modern sense comprises a kernel and software that surrounds the kernel. In the case of POSIX, UNIX and UNIX-like operating systems, this includes the C library, a set of utilities (kill, ps, ls, cp, mv, rm, sh, and so forth), and more. To compare to Windows, the Windows operating system is not just NTOSKRNL.EXE. That’s the kernel, but there are a suite of executables and libraries that surround it and provide interfaces to it which make the kernel useful. While it is technically possible to do, law prevents the creation of a "GNU/Windows" or "GNU/NTOS". It would not be as straightforward as it is to run GNU on a Unix-like system, but it would be possible (Cygwin is as close as it can lawfully get).
So, when we talk about the FreeBSD operating system, we are referring both to the FreeBSD kernel and the utilities and software that make it useful. "FreeBSD" includes utilities and libraries and all of that, just like the NetBSD or Windows operating systems do. But, Linux does not. When we say "Linux", we are necessarily talking about only a kernel, the project that is the brainchild of a man named Linus Torvalds and the army of programmers around him.
Question 2: What is an OS kernel?
An operating system kernel is the core of the operating system. However, without the rest of the components that build an operating system, a kernel is useless. To make matters more interesting, a single kernel can be used as a component in several different operating systems. This is actually the case for many systems, though it is most prominent in the case of systems that are built around the Linux kernel because there are so many of them.
The lifecycle of a kernel is generally something like this: Set up and initialize itself, load and initialize basic hardware drivers, kick off one (or more) processes that are required to make the system useful, and then loop, handling things like hardware interrupts and system calls from software. In the case of a Unix-like system, the kernel attempts to run a program called "init" (usually on modern systems, this is found in /sbin/init), which initializes userland and starts running services that make the system useful. So a Unix-like operating system provides at least a kernel and an init process, as well as programs for logging in from TTYs (or virtual terminals), manipulating files, processes, and the kernel’s state, and so forth. If a Unix-like system cannot find an init program, it will halt (panic) or return to firmware where a user could tell the kernel to use an alternate program for init (for example, you can pass "init=/bin/bash" to the Linux kernel, and it will start a single program: bash).
Question 3: Where is the line between an OS and the rest?
To answer this question, we must look at several operating systems, and we must be able to know what the difference is between core software and application software. The line can be blurred, of course, especially when the core software depends on certain application software. So in order to more accurately tell the difference, we need to know exactly what the core system uses. A classic example in the UNIX world: some software is used as system software, and is also available for use as application software. A system cannot be called a Unix without some of it, and a system certainly isn’t Unix-like without it (and remember: Unix is an operating system definition).
For non-technical people, an operating system is a distribution. That is, Microsoft Windows is an operating system as it is installed; Ubuntu, Debian, and Red Hat Enterprise Linux are also operating systems. For those who are more technical, though, the line isn’t there: the line is somewhere between what is shipped for installation and what is the core system.
Let’s compare FreeBSD with Linux. A typical FreeBSD system contains the FreeBSD kernel, FreeBSD’s C library, FreeBSD’s kernel management utilities, an implementation of init, and implementations of the Unix utilities (ls, ps, cp, kill, etc.).
However, a typical Linux system contains the Linux kernel, the Linux kernel utilities, the GNU C Library, GNU coreutils, GNU findutils, GNU bash, filesystem-specific utiltiies, an implementation of init (could be sysvinit, Upstart, or any number of other ones), and others.
Question 4: When is it GNU/Linux? When is it not? When is any system GNU/anything?
The simple answer: most systems aren’t GNU/anything, but they could be. Take as an example the project to use the FreeBSD kernel (but not the FreeBSD userland). The system cannot simply be called FreeBSD any longer: a significant portion of the FreeBSD operating system is removed when its userland is replaced. The project’s operating system is called "GNU/kFreeBSD", not "GNU/FreeBSD" because FreeBSD was a complete operating system before its utilities were removed and GNU implementations dropped in. This would include the GNU C library and the typical things you see in a Linux installation. This also means that it’s a different operating system entirely! Any piece of software that expects to be built on FreeBSD and assumes a complete FreeBSD system might not even build when using the FreeBSD kernel and the GNU userland.
In the case of Linux: When you’re using the GNU utilities and core system, it’s GNU/Linux. When you’re not, then it’s not. For example, Android is a distinct operating system from Ubuntu. They both use the Linux kernel, but that’s where the similarities stop. Android is one example of a distinctly different operating system that shares a kernel with another operating system. Aside from the fact that Ubuntu is most commonly run on x86 or x86-64 systems and Android is most commonly run on ARM systems, if you sat the two side-by-side on the same platform you’d still have different operating systems that do things differently. This is because Android doesn’t even use the same C library as Ubuntu; many pieces of software that are stated to work on a Unix-like system such as GNU/Linux or FreeBSD assume a richer environment (closer to that specified by operating system standards). They would have to be ported to Android to run on Android successfully; that’s a major red flag that says "Oh, that’s a different operating system."
Question 5: Does that mean I can create my own operating system?
Yes. You can. And you can even re-use the kernel from any other operating system that is licensed in such as way as to permit you to do so.
Let’s think about this in terms of OS X and what Microsoft could potentially do for Windows, as an example. Apple used to have its own operating system called "System", which was then called "MacOS", and today we call it "Mac OS Classic". This system was a cooperatively multitasking operating system that ran software specially built for it. It was very popular, and it was also not as robust as modern operating systems. It was pretty interesting, though: it did not have a command-line interface. Nearly everything that was in the System Folder was the operating system itself, aside from installed fonts, extensions, and system enablers (though often extensions and enablers would patch the operating system in memory, or hook into it in some way so as to attach itself to it). Apple abandoned that system years ago for OS X. They took a BSD kernel and wrote a stack around it, reusing some components but using a very different architecture to put things together. The kernel for OS X is called Darwin, and it’s a very important—in fact, the central—piece of the OS X operating system stack. But it is not OS X; it is but a component.
How could Microsoft do something like this? Let’s say that Microsoft went and did something similar, taking the BSD kernel and porting Windows’ software stack to run around it. They also call it Windows. Let’s say that they modified the kernel to load Microsoft’s old drivers and that they had incorporated a PE loader and ported their software to this new operating system (but retained API and binary compatibility with their legacy operating system that used a very different composition of kernel and userland, by necessity). Would this mean that they were running FreeBSD? No. It would mean that their operating system were based on (at the very least) the FreeBSD kernel. Though they could keep the FreeBSD stack and package it as a set of extensions to their new operating system, and claim the ability to run FreeBSD (and in a limited fashion, some Linux, if they retain the Linux compatibility mode of the FreeBSD kernel and system) software. Now that would be an interesting market position for Microsoft to be in, wouldn’t it? Microsoft could even make their new system compliant in some way with POSIX and the SUS and get branded as a UNIX® system. But the new system would be more like Windows than it would be FreeBSD if they didn’t keep FreeBSD as-it-were, since they’d likely replace the core stack to fit their desires and needs, like Apple did.
Conclusion
I hope that this has clarified things a bit. However, if it has not, a good place to start reading is the Wikipedia articles for "operating system" and "Kernel (computer science)". They are a long articles, but they make for a great starting point for research and clarification of just what an operating system is. Both articles look at different operating systems (and their kernels). As to whether or not you can determine what an operating system is, you will want to become intimately familiar with many different operating systems (and types of operating systems; there are families of them as people create more and more systems both original and reimplementations of others) before you start trying to figure it out. Look at native code and managed code operating systems—also realize that the distinction of what is the operating system can sometimes be relatively hard to determine accurately.
If you want to see what a bare operating system looks like, though, check out one of these operating systems’ source code: FreeBSD, NetBSD, OpenBSD. Each of them in their version control systems has the complete operating system, which is much more than just a kernel. You can then, should you want, figure out exactly what packages on a typical GNU/Linux system take the place of the remainder of the operating system. It’d be an interesting exercise in learning—if learning is truly what you’re after, and not just argument.
Corfy 30th September 2009
So why do we stop there? Considering that many apps are online and require a web browser, why doesn’t anyone argue that we should call it, for example, GNU/Linux/X/KDE/Firefox?
Michael Trausch 30th September 2009
Why do we stop where, at the border of the core system? Because that is where the border is.
Generally speaking, an operating system is something which has one (very complex) job: it must manage software programs that are competing for resources. Once upon a time we had many operating systems that were single-task, single-thread operating systems (think along the lines of the MS-DOS or ProDOS model). These operating systems would have their API in memory, typically as well-known assembly entrypoints or parameters to a well-known software interrupt hooked by the operating system. We know this, because we have history to show it to us. If we don’t look at that, we can take a look at the FreeDOS kernel to see just how that’s done.
In the case of simple systems, such as FreeDOS or MS-DOS, the line is very clear; the OS is in memory after the system is booted, and all application software must be loaded. In the case of DOS, the OS would even flush the shell out of memory if the application needed the memory that the shell took (this is what happened when you would receive the message “Please insert disk with COMMAND.COM” (or whatever filename was the SHELL as configured in CONFIG.SYS). Of course, that was never seen by users of DOS that ran DOS from a hard disk, either, but if you used DOS without hard disks you’ve probably seen that message before.
Now, we can say with certainty that was the operating system. Why is it certain? Because the architecture of DOS is well-known. In the Microsoft version, you had a bootloader program that would check the disk for IO.SYS, and if it was found, it would load it and start running it (and it would load MSDOS.SYS, at least until the point that DOS 7 decided that only IO.SYS was necessary). To compare, with FreeDOS, you have KERNEL.SYS, and it can be a regular file (it doesn’t have to be specially-placed on the disk like legacy DOS required with the SYS command). When the DOS system boots up, the entire operating system—tiny little thing that it is—is in system memory (“high memory” if you’re lucky). The only thing outside of the kernel that is part of the operating system is the shell.
Nowadays, the job is a bit more complex. At one point, there were people around who were willing to argue that if it’s not loaded at the time of IPL, like DOS and CP/M were, it’s not part of the operating system. By that definition, that would mean that kernel modules aren’t part of the operating system’s kernel even, despite being linked into the kernel at runtime. Oops. That is obviously incorrect, because anything that links with the kernel is by definition part of the operating system at the kernel level.
To compare with a system like Ubuntu (though this whole process can be completely different if not running GNU/Linux, because clearly most of this process requires the userland to be functional): The bootloader loads the kernel (and, most of the time these days, and initial RAM disk for it to use to boot up, with—you guessed it—a miniature operating system on it). The kernel looks for it’s init process (or in the event of an initrd, /linuxrc or something, I think, but am not sure) and starts it. If the init process dies, the kernel panics. If the init process cannot be started, the kernel panics. The kernel cannot, will not function without an init process.
Now, most init programs use shell scripts to configure the init system and to tell init how to provide services to make the kernel useful. That means that in a Unix-like system that works just like Unix, the shell that the init scripts depend on is part of the operating system. The utilities that the init system uses to work with the kernel (maybe indirectly, such as in the case of most Linux-based init systems) and configure things at the level of the kernel are also part of the operating system.
Can they be replaced? Hell, yes they can. Ubuntu now is different from the first version of Ubuntu—not only because it’s newer, since that’s obvious—but because it uses an entirely different infrastructure than it used to. Instead of sysvinit, it now uses upstart (which pulls Python and a fair number of other things). It makes the operating system larger; perhaps so large that people are no longer comfortable calling them operating systems.
In this world of free software that many of us are familiar with, it’s easy to say “the operating system is just a kernel” and point to the fact that today, we’re capable of replacing our userland with any stack we see fit. However, just because we can replace the stack does not mean that the operating system is just the kernel. That has not been true for multiuser, multitasking, multithreaded operating systems in a very long time. Linux and the userland stack (most often, a mix of GNU and the Linux-kernel specific utilities) accomplish the same types of jobs that DOS was able to do in just the kernel.
Then again, the DOS kernel and API didn’t have anything to do with a great number of situations that we deal with today. In the case of DOS on the 8088 and newer Intel architecture, it worked in real mode with access to no more than 1 MiB of RAM, though extensions were shipped with later versions of DOS to increase the system’s capabilities when enhanced hardware (such as the 286 or 386+ and more than 1 MB of RAM) was present. Device drivers almost never shipped with the operating system, either, so you would wind up running an operating system that was a combination of quasi-standard APIs from various vendors for things like virtual memory or enhanced (e.g., better than PC Speaker) sound card support.
Anyway, the point is: yes, operating systems are a hell of a lot larger than they used to be. Kernels are larger than they used to be, too. And even you build the userland stack that the kernel requires into the kernel by way of a persistent RAM disk (and why would you want to do that‽), the kernel isn’t the only thing there is to the operating system: all you’re doing is successfully creating the illusion that it is (and making it harder to update the userland components of the operating system at the same time). Microsoft’s systems are built in a similar way these days, though they were not always that way. Things that are not used by the core system but are installed alongside it are application software, and that’s where the operating system truly ends and the user’s system begins.
Thinking about this you should be able to arrive at the conclusion as to why software such as an X11 server or a desktop environment (or the web browser) are not parts of the operating system. X11 is an application program that optionally speaks to a device driver in the kernel, though the window system is not part of the operating system (unlike Windows, where the window system is a part of the operating system). X11 could be moved into the kernel if someone with the appropriate technical expertise were to do so, or make the kernel depend on it, and then it would be part of the operating system, but thankfully nobody has done that. That isn’t to say that there haven’t been conversations about it, though. They just always wind up ending with “there be bad road here,” and things go on.
dave 1st October 2009
Besides, it wouldn’t be GNU/Linux/X/KDE/Firefox anyway. It would be Firefox/KDE/X/GNU/Linux….
David L. Craig 1st October 2009
Frankly, identifying exactly what functions, services, or coded entities are part of any particular OS is so fuzzy, extending the exercise to all OSes results in chaos. Compared to z/OS, any flavor of UNIX is merely an operating system toolkit–you have to add a lot of code to get to what z/OS provides the programmer; e.g., tape management. However, z/OS tape management is very rudimentary compared to what most z/OS environments provide and are depended upon by their programmers and users. The function gap is filled by 3rd party software vendors, noteably Computer Associates, which owns many software products it did not develop–it just brought the organization that did.
Therefore, I submit the definition of an operating system is up to the distributer/vendor that packages the OS core. What .deb files does Debian require for any installation running Debian? That is the Debian OS. Oops, that doesn’t work either, since they’re developing a Debian distribution based on FreeBSD.
Are z/VM and VMWare operating systems? Will Single System Image z/VM be one or many operating systems?
Maybe it’s time to drop “operating system” and use “operating environment,” meaning all software maintained by the support staff for the benefit of the folks who are merely tring to get real world answers from the system without any human intermediaries; i.e., users.
MrDolomite 1st October 2009
Interesting reading, with valid points, but can’t we all just get along? To the mainstream world, just call it Linux and lose the technobabble. Otherwise it all sounds like an RMS rant.
shmerl 1st October 2009
How could you miss OpenSolaris?
Michael Trausch 1st October 2009
@David: Very interesting point of view.
I’d say that a virtual machine is not an operating system. Why? Because it provides virtual hardware. It is a computer within a program. It runs operating systems, but it is not one itself (for the same reason that your computer hardware is not part of whatever operating system it is running at the time; part of the job of the operating system is to “own” the hardware and control it, at least for modern operating systems).
It is true that the definition of what components are necessary for an operating system depend on the operating system itself, somewhat. That’s actually determined by the family of operating system moreso than the operating system itself, though any OS can tweak what it does or how it does it compared to the other members of its family. Most members of the UNIX family extend the definition for their particular system, including methods of kernel module management. Some, like Linux, FreeBSD, and Windows, have made it their job to take management of the system disks to the next level and provide one form or another of logical volume management.
I think that what is largely being misunderstood here is the term “operating system” itself, and among laymen the term “operating environment” might be more sufficient as it represents something to people that is more concrete than the definition of an operating system. An OE is a set of rules, and the OE can be as narrow-focused as a list of dependent behaviors, mechanisms, or libraries, or it can be as broad as “GNOME” or “KDE”. The definition of an OE is no longer concerned about the rift between the system and non-system utility or application software.
I think that some would take my words to mean that GNOME can be considered to be part of the operating system if the operating system distribution includes graphical utilities for GNOME to manage the operating system: this has, to my knowledge, never been the case because system management utilities implemented as a GUI generally “ride on top of” the authoritative command-line versions that are intended to be used with the particular kernel.
One valid way of defining an operating system could be to use the use the analogy of an application itself. Take as an example, the PostgreSQL database server product. It comes with a library and a shell front-end to the database server (a kernel). However, the database server could just provide the server and an interface definition for the rest of the software that would make the database server useful, if it desired. The software built to comply with that definition then fulfills the application. Another example of a differently-tasked but similar design would be Gwibber, which uses a GUI-oriented front end and a back end that runs as a per-user dæmon handling the communication between the client (Gwibber’s front end) and the remote service (identi.ca, a StatusNet server, Twitter, whatever). Can you replace the database’s front end or Gwibber’s back end? Sure. But what you have then is still something that fulfills the intended role.
That is to say, that both operating systems and application software have come to be developed in a more component-oriented way, and that can blur the line between the two (or internally amongst the two). But DOS, bare-bones as it was, is just as much an operating system as GNU/Linux or z/OS. If DOS wants to speak to a tape drive, you load a device driver which extends the operating system to handling those tasks (and in the case of DOS, sometimes those device drivers would hook into lower-level things like the BIOS and hook those instead, because DOS permitted applications to bypass itself when talking to lower-level things and hardware directly). But if the tape drive access is implemented such that a single application must act as a “gateway” to it, so that all data sent to and from it must go through that application and not a driver that was installed to make the tape drive accessible to all applications, is not an extension of the operating system: it’s an application that has a special capability. That is, that which is an operating system task happens to be a function of architecture as anything else. Userland software can certainly be used to enrich the original operating system interface if it desires, but userland software can also be built for the purpose of managing the kernel, and then it’s part of the operating system.
Another example is an archiver tool: UNIX provides for tar to be standard, and POSIX provides for pax, for the same purpose. Is SuperTar (fictional product) then part of the operating system if it is downloaded and installed? If it’s installed as “tar” and “pax” and “supertar”, and it is drop-in compatible, and the base system depends on it (which both UNIX and POSIX do) then yes, you’ve just patched your operating system. If “supertar” is not really a tar (or pax) implementation at all, and does something completely different and uses a completely different format, then no, you did not just patch your operating system, you added a new userland utility that (while it may prove to be very useful) is not part of the operating system at all—but it would be part of the newly redefined operating environment on that machine.
Michael Trausch 1st October 2009
@MrDolomite: I’m not trying to not get along with anybody.
RMS, on the other hand, would say that “all Linux systems are GNU/Linux” and even tries to enforce that by not speaking at any Linux User Group that calls itself a Linux User Group and not a GNU/Linux User Group.
The fact is, many of us do use Linux systems that have no root in the GNU stack; Android is one such example. RMS would probably rather it be called GNU/Android because the gcc compiler is used to build it. I call bullshit there, though; GNU isn’t used, and GNU is a metaproject seeking to develop a complete operating system. Just because a piece of software or an operating system is built with the gcc compiler does not make it GNU/anything; using it with the GNU operating system utilities as a replacement for the native utilities (or in the case of most Linux systems that I know of, as the native utilities) does merit the distinction, though. It does not merit distinction with Hurd, because Hurd is the completing component to the GNU operating system. If someone were to run the Hurd kernel on top of a busybox and klibc or µClibc based environment, it would not any longer be “GNU”, it’d be “Hurd/whatever” or (like Android) just called something else altogether.
Michael Trausch 1st October 2009
@shmerl: An oversight, I wasn’t thinking of it at the time. Though I also wasn’t going for an exhaustive list of operating systems; there are far too many to do that here! Wikipedia has a great list, though.
LinuxLover 1st October 2009
Point blank, GNU/Linux is too much of a mouthful. Linux is similar in sounding to Unix and dispenses with a techno-babble geeky sounding term, therefore, the term works in our psyche. Therefore, it’s called Linux and not GNU/Linux.
Michael Trausch 1st October 2009
@LinuxLover: If you do not care about the inaccuracy, sure, whatever.
However, that has got to be the worst argument for anything I’ve heard all year.
somejerk 2nd October 2009
I think LinuxLover’s got a great argument going on there. Solid truth. I wish most people would just out and admit that, rather than trying to redefine what an OS consists of just so they feel justified in omitting “GNU”.
Now, if LinuxLover’s last statement was worded “Therefore, it’s properly called Linux”, it would have fell apart. Because, Michael, as you so elegantly explained to us, if we follow the accepted scientific definition of operating system, it’s obvious there’s some GNU surrounding most of our Linux’s.
akf 2nd October 2009
It is simply not true that RMS calls any system that is compiled with GCC an GNU system! You’re right, that this would be bullshit! But RMS doesn’t do that!
For example he wouldn’t say GNU/BSD although BSD system are compiled with GCC and they include lots of GNU tools.
see http://www.gnu.org/gnu/gnu-linux-faq.html#bsd
and http://www.gnu.org/gnu/gnu-linux-faq.html#justlinux
David L. Craig 2nd October 2009
Michael, I believe you are confused about the concept of virtual machines and the relationship of a virtual machine to the operating system that creates it. It sounds like you are saying if it boots on the hardware, handles all the hardware-generated interruptions, provides and services some kind of API, and manages programmatic access to all hardware resources, it is an operating system. So far, so good. Debian GNU/Linux boots on the bare metal of an IBM Multiprise 3000 in Basic Mode, so it is an operating system. That same collection of disk extents used by that Debian system can be allocated to a virtual machine named EXAMPLE that is defined in the directory area of another collection of disk extents that can also be booted on the Multiprise 3000. When booted, it handles all the hardware-generated interrupts, provides and services several kinds of APIs, and manages programmatic access to all hardware resources, When it is running, I can sit down at an “enabled” 3270-type terminal connected to the Multiprise 3000 in some manner and enter the command “LOGON EXAMPLE”, respond to the prompt with the appropriate password, and a virtual Multiprise 3000 as defined for user EXAMPLE in the directory is instantiated and booted using the Debian system’s boot configuration. Very soon afterwards, that Debian system is fully operational, but the hardware interrupts it handles are all virtual. Are you saying that Debian system is now not an operating system simply because it is in a virtual machine? No, you said it still is. However, I believe you are saying the system now handling all the real hardware interrupts, providing and servicing several kinds of APIs (to that operating system, a virtual machine’s operating system is just another application program), and managing programmatic access to all hardware resources–you are saying that system is NOT an operating system? It is balancing the needs of thousands of users, all of which are virtual machines running whatever operating system has been virtually booted, plus its own needs. Surely it, too, is an operating system, and a rather magnificent one at that, I dare say. It can even be run in a virtual machine itself!
Now suppose I take the conceptual abstractions that operating system embodies and embed them into the firmware of the Multiprise as microcode, such that the Multiprise is no longer in Basic Mode, but LPAR Mode. Now all the real hardware, including use of the processors, is managed by microcode that has been configured to establish some set of Logical Partitions, each of which can run any operating system that can be run in Basic Mode. Is it still an operating system even though it’s now inside the hardware it used to control? The answer to that depends on who you ask.
LinuxLover, I agree with you. The GNU/Linux naming concept is like using hyphenated last names after a marriage–it just doesn’t scale. Not only that, it fails to deliver what RMS thought it would–greater exposure for the FSF and its raison-d’etre. I have proposed in the past that “GNU/Linux” should be replaced with “Freedom,” with Debian GNU/Linux probably being the purest form of the “operating system.” Then “Linux” can go back to being just a kernel without all the political baggage. I’m not holding my breath about that, however.
Michael Trausch 2nd October 2009
@somejerk: While I appreciate the honesty, I only do logical arguments. I am not talking about people’s emotional positions here, just aiming to provide clarifications on what is. Most end users simply do not care what operating system is running on their system, so long as they can use it. And there isn’t a single end user I know that can correctly define what an operating system is, let alone what software it is comprised of.
@akf: I think you mis-read me. I said that he would probably rather it be called that, but I did not make any declarative statements that said what his position on it is for sure, because I simply do not know. What we know of him generally so far makes it an issue on the fence, because we don’t know all of what goes on in Stallman’s head.
@David: An operating system’s definition does not change dependent on whether or not it’s running on bare metal or virtual machine. A VM takes the place, logically, of a computer system itself. It is special in that it runs within an operating system and provides virtual hardware (possibly paravirtualized on the real hardware) to run another operating system within it. Just because an OS is running on a VM and not real hardware doesn’t make it any less of an OS, nor does it make a VM an OS in itself. While one could have a virtual operating system (this is indeed the case when we consider Linux containers and FreeBSD jails, at least to a certain extent), that is another topic altogether.
As far as what LinuxLover was saying: that’s why we have names. Ubuntu, while based on Debian, is a different operating system (though substantially similar). It is valid, when asked what your operating system is, to say “Ubuntu” or “Debian” or “RHEL”. The reason, of course, is that they all work differently in sometimes subtle, sometimes not-so-subtle ways, starting from the moment where the kernel spawns PID 1.
akf 3rd October 2009
@Michael Trausch: you would know what goes on in RMS’ head, if you had read the links I provided. That was written by him.
Michael Trausch 3rd October 2009
@akf: We can see what he has written, but we still cannot read his mind. That was my point. He’s become more and more extremist, and even shockingly so. Clearly, this shows that we cannot predict what he is thinking and we cannot predict what he will say, or how his viewpoints have changed or will change over time.
gnufriend 4th October 2009
Good article. good work.