“You can have freedom without choice.”

That someone could even come up with this one is just amazing to me. Note that this is not an exact quote, but it is the summary of Friday’s topic. For example, this summary comes from the idea that Canonical is bad for considering making mainstream non-free software available for Ubuntu based on user preferences. It does not matter who came up with it, of course, but the important thing is that it be called what it is: patently absurd. The ability to choose is a major part of what freedom—or liberty—is. If you cannot make a choice on a matter, then by definition you do not have freedom in the context of that matter. It is quite simple and self-explanatory. Canonical is seeking to increase freedom here, not take it away. Some people actually want to use non-free software; others may not want to use it, but aren’t aware of alternatives. The latter group of people should have our focus with regard to education (but then we should let them make the choice for themselves!).

Note that I am not one of these people: I would rather use free software because of the liberty it gives me that I have come to expect over the years. But I am not going to tell someone else that they are harming me because they would rather use non-free software that is familiar to them. All I can do is show them that there are free alternatives that exist. I cannot—and I will not—make them use it or make them feel bad for not using it. I may not like proprietary software for a variety of reasons, but I will defend people’s right to use it just as I will defend even a stupid person’s right to spew nonsense by way of speech or written word. In other words, “I disapprove of what you say, but I will defend to the death your right to say it,” or perhaps more appropriately, “I [may] disapprove of what [software you run], but I will defend to the death your right to [run] it.” Even I use a package or two that is proprietary in nature (though it is looking like I will not have to do so for much longer, given the efforts to replace these packages with equivalent free software).

It is worth it to note that by adding non-free software to Ubuntu, the free software that is already there does not change. The mere existence of non-free software within its repositories does not make Ubuntu somehow bad or evil. It would add choices that do not currently exist, and that one such as myself or yourself can certainly opt out of—I most likely would, for the most part, as I do not need to depend on non-free application software, and I only use non-free drivers if I have hardware where anything else is nonviable (and only until there are functional free software drivers). Did you know that Ubuntu has an option in the installer to only install free software? Can you say that for your favorite desktop operating system distribution, whatever that might be?

The response to this idea, then, is that without choice, there is very little—if any, really—freedom. The thing that gives us freedom with free software is that we are able to to download the source code, to review/audit it, to change it to fit our needs or fix a problem, and to share those changes. If we cannot do those things, then it is not free software; see the essential freedoms. But non-free software inside a distribution is not something that should not cause you great consternation even if you are among the most dedicated of freedom advocates, for if you are a true advocate of freedom then by definition you must respect a computer user’s freedom of choice. Remember that we choose to run free software because of the benefits it brings to us; we choose to improve upon free software for much the same reason. Eventually, I think that free software will once again become the norm for computer software, on merit alone, for no other reason than the development, release, and usage of free software is a highly practical solution for many things ranging from library code to application software to complete operating systems. It is worth noting that free content—which is similar in concept to free software, which itself is merely a specific application of freedom itself—also appears to making major headway towards becoming mainstream; it is doing so more quickly than free software is, but there is every reason to believe that free software will follow, for it is already.

An Example

Imagine that you are in a store, because you need some milk for dinner some night. You always get 1 gallon of 2%. But, the store has stopped carrying it, because more people buy whole milk and they were throwing away the 2% milk—demand was low, supply got to be too high, so they just stopped carrying it altogether. You leave the store and head to the next in the same town and you find the same thing there. You have a choice of stores to go to, and you have made the choice to go buy yourself some milk. But there is only one type of milk. You no longer have the choice to buy 2% where you are, and so effectively, your freedom to buy it has been taken away. (Of course, you can make 2% milk from whole milk (and make whole from 2% even, or even butter), but I suspect just as many people want to do that as want to write their own free software that they demand simply must exist, but doesn’t yet).

Now, the point here is that there is more than one freedom in play: the freedom of the store to stock (or not stock) various products, which affects your freedom as a consumer to buy the product you want. In the case of software, and choice, if the software you are running gives you all the choices you want, then it fits your needs. If it does not, then you are not going to be able to use it the way you want. Now you have two choices: you can do the work that it would take to make your desired choice possible, or you can use another system (free or proprietary) that will give you the choice that you want. Many people will choose the latter, especially if they are non-programmers. Though I’ve seen programmers also choose to use proprietary systems for something that they could themselves implement. That is their choice, of course. After all, if you really wanted 2% milk, you would have the same choice: make it yourself, or drive to the next town over which might have it available for you (assuming that there is some in stock and that the stores neighboring towns have not also decided to stop stocking 2% milk).

Ubuntu One: The Reason Behind This

This discussion came up because someone on identi.ca made the claim that Canonical is forcing proprietary software into Ubuntu by way of the Ubuntu One client software. I cannot even begin to state just how woefully incorrect this point of view is. First off: the only thing added to Ubuntu is the ability to connect to Ubuntu One, and the software that was added to Ubuntu do to that is licensed under Version 3 of the GNU General Public License. The claim made in response to that was that Ubuntu One is only partly free software, because the server is somewhere else and has not been released. As we shall soon see, that claim is nonsensical—it depends on an extremely naïve view of how software actually works in order to make sense, really.

So, first things first: Ubuntu One, which was added to Ubuntu 9.04, is not proprietary software. The proof rests in the fact that it GNU GPL v3.0, and we know a priori that software licensed under the GPL is free software, so we do not need to go further on that point.

Now, because the software in question added to Ubuntu is free software, we can read it. The essential freedoms granted to us by truly free software ensure this, and the GPLv3 is indeed a truly free software license because it grants those freedoms. Because we are able to study the software and see how it communicates with the server. Once we know how to communicate with the server, we can write that up and design a server that communicates exactly the same way. From there, it is just a matter of patching the sync dæmon that is in Ubuntu to talk to an arbitrary, Ubuntu One compatible server. To determine how to do that, one need only read the Python source code contained in the python-ubuntuone-storageprotocol and python-ubuntuone-client packages. If you do not know Python well, you might expect to spend several days doing that, but if it bothers you so tremendously that you are going to practically start a flame war over it, you may find it worth it to do so.

Of course, the other side to that is this: if you really want Ubuntu One to talk to an arbitrary server that runs free software, and you want that free software to be written, you can fund the effort to write the free software. Approach a proficient developer somewhere out there on the Internet and ask them how much they’d charge to write a server for Ubuntu One. You might not be able to afford the fund the project entirely, but if you get a number from someone, you can start a coordinated effort to raise the funds. If you are lucky enough to be able to fund the whole project, then do so: it is but one way that you can help provide something back to the community. This does not apply to just an implementation of the Ubuntu One protocol, it could apply to anything that you see that is missing and needs to be created. Or you could spend time learning what you need to learn to pick up the project yourself, if you care for the project that deeply. The most important attribute that a person can have in order to get started with development is motivation—James Westby reminded me of this a couple of years ago, something which I had forgotten.

Perceptions: Another (Possible) Reason

It was suggested to me that another possible reason that people would object to having non-free software inside an operating system distribution such as Ubuntu is that they are afraid that the proprietary options have higher quality, or offer superior features, or provide functionality that is not offered by any existing free software. Thus, they have this perception that by adding such non-free software into a distribution like Ubuntu, people will automatically use and prefer it over free software. This simply is not the case. Sure, some people will use iTunes if it is available on Ubuntu. Maybe many people would. I might even do so, if it were legally available for me to use that way and if it supports the purchase of DRM-free music. However, if there were a free software client for the iTunes store, I’d much prefer to use that. To my knowledge, however, there is no such thing that exists.

If there is not a free software alternative for a non-free component inside a distribution of software, if you are offended by that, then by all means, create a free software alternative for it! As mentioned above, you can start on such a project’s development, or you can look for people that would be interested in volunteering for it and coordinating them, or you can put up funds to pay developers to implement it. If you have money, this can be the easy part: find someone who is willing to accept payment for the service of implementing the free software alternative for whatever it is that someone else has funded, wrote, and released as proprietary software. It is not like free software is developed without cost (and if you think that it is, then you seriously do not understand what free software is or anything about the world of free software and have no standing to be getting mad when a company spends money writing software and does not release it as free software. You can try to write companies that write such software and ask them if they will give you any form of written specifications for the software, or an interface definition, or something along those lines. The worst thing that could happen is that you will be told “no”. And do so nicely, or they’ll be more inclined to tell you “bugger off” instead of simply “no”.

“Allowing users to choose proprietary software is anti-freedom.”

Nothing could be farther from the truth; it is the same, in fact, as the above statement that one can have freedom without choice. For example, if Ubuntu adopts iTunes and makes it so that you can “sudo aptitude install itunes” in the future, that is not a bad thing! How can it be—It contributes to the ability to choose, and thereby contributes to the freedom of the end-user. If you are a die-hard free software supporter and do not want to run non-free software on your system, then there is a very simple solution for you: simply don’t install it.  That is a valid solution to the problem. There are tools already available that can be run as a cron job and report on any non-free software that you might have accidentally (or even intentionally) installed. If you are worried about additional non-free software getting into Ubuntu, then help enhance those tools. Or write a GUI front-end for something like the virtual RMS program and work to get that included into Ubuntu as well, perhaps something that can run every time you login to the computer, or that runs as a persistent process that watches the package database on your distribution of choice for updates and then checks to see if newly installed software is non-free and alerts the user. Of course, it’d be most effective as an opt-in system, and not an opt-out one where it would just be annoying.

There is no way, then, that freedom is actually reduced in this way when another choice becomes available. If iTunes were to be included in the repositories (and I suspect it would be, like the restricted, universe and multiverse repositories, a separate opt-in repository; perhaps simply “proprietary” would be fitting), this does not reduce your ability to choose to run a free software media player and manager like Banshee, or Rhythmbox, or even AmaroK if you are so inclined to run that KDE stuff.

Once upon a time, FUD (fear, uncertainty, and doubt) was the tool of Microsoft. We (the free software world) completely hated it when Microsoft would put out FUD, because we would then have to fight that FUD by way of explanation and demonstration. Well, some time ago, a subgroup of the free software world decided to start using FUD themselves—it was done with Mono, and it is being done now with just a survey asking people what sort of software they would like to see in Ubuntu. Now, those of us who are left who are advocates of liberty—both personal and societal—are stuck potentially fighting two battles. One with Microsoft’s FUD—such as the constant notion that you have to pay for software—and one with the “free software evangelists” FUD, who have even gone so far as to say that people should not use certain types of free software (the one who calls himself “The Open Sourcer” even still today tells people to remove certain truly free software from their systems). The truth is somewhere in the middle, between these two ends of the spectrum.

Conclusion

Back to the point at hand: to say that giving a person a choice is a constraint on that person’s freedom, that is doublespeak.; it is saying that “slavery is freedom,” albeit to a lesser degree than that very melodramatic extreme—it simply does not make sense. The concept just does not make sense unless the words that are used to express the concept are dramatically redefined to mean things vastly different from what standard English dictionaries define them to be. The only reason that one has to try to convince someone that additional choice is a constraint on freedom is to try to convince people of things that are not true; to install fear, uncertainty, and doubt into people. This is the sort of behavior that—no matter what community it originates from—is completely immoral, unethical, and absolutely unacceptable. It’s dishonest, and for those of you who know me personally, you know what I think of dishonesty.

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.

That’s right.  Now, there are many things that the man has done that have been effective, and the man has worked hard to ensure that we have freedom in the vast world of software.  But recently, he has stated that Miguel de Icaza “is basically a traitor to the free software community,” and no matter how much good a person has done, I cannot stand by such a fallacious statement.

What is freedom, people?  The two cornerstones of freedom are education and choice.  A person who is uneducated cannot choose, and so one depends on the other.  Some people will choose to use either free software or proprietary software exclusively, and others will mix the two together, with varying priorities that they place on their choices.  As long as people are aware of what’s out there and can determine what is best for the way they use their own systems, freedom is available.  Yes, that means some people may choose to run Windows.  Many will not, and if one makes a conscious choice, that is for them to do for themselves.  My concern is that people need to know about the choices in order to make a choice to begin with.

Now, de Icaza has done a great deal of work for the open source community.  He’s one of the key people who has been behind Midnight Commander and GNOME.  And of course, Mono.  He has given us a great deal of good quality, free software that many people can choose to use, and he has given the ability to use a VM-based runtime environment that previously was not cross-platform, as well, on nearly any platform that can be chosen.  The GNU people are even working on a similar one.  But this is not the reason that de Icaza is supposedly a traitor to the community.  The reason?  de Icaza is helping Microsoft out with their new “Open Source Labs”.

Guess what, Mr. Stallman?  The fact that Microsoft is starting to enter the world of free software cannot be considered to be a bad thing.  You did a great deal of work to ensure that free software that is adequately licensed can stay that way, and the turn the copyright system around on those who have sought out to corrupt it.  You have put free software on the radar around the world.  You have done a great many things that others would not have the heart, nor the motivation, to carry out.  It would appear, however, your time is up:  the world can and will move on without you, and I declare that it is time for you to go away.  When you start attacking people in the very world that you helped to create, you become obsolete and no longer serve your purpose.  I dub St. Ignucius of the Church of Emacs to be a heathen who has forgotten his message, forgotten his values, and is now a harmful creature; hardly a saint, more like a devil.  Overtaken with fits of arrogance.  Lately, you have caused a great deal of infighting within the community.  As I am sure you are well aware, infighting serves very little useful purpose but to tear apart communities.  And now you make a bold, arrogant, and false statement that serves only that purpose, but to an extent the likes of which we have never seen from you.

I say that we shun him—and his kind. Things are starting—albeit slowly—to come around to the way we want them, and he would prefer to attack it.  Why?  What logical reason is there to do so?  Because he’s not the controller of it?  Because it grew to be something that even companies that he helped cultivate an irrational, religious-like hatred of, are beginning to see is useful (not only to them, but to all of us)?  What is his new goal, that all software should be GPL’d and if it isn’t it is evil?  We should not tolerate these sorts of counterproductive behaviors.  Stallman has reduced himself to a Schestowitz, a creature who deserves no respect.  A troll.  I suppose in his old age, he has decided that attention is more important than our freedoms.

Richard Matthew Stallman, you are no longer relevant to our community, our world, the world of people who truly believe in and advocate for freedom, that of choice and that of the rights to study, improve, and distribute software.  Thank you for your services, for they were needed to get us where we are today.  However, you have chosen to do us no further good, only ill.  And for that, I say damn you.  Leave the Free Software Foundation and permit it to continue to work for freedom, or take it down and let the GNU project carry on to produce software without all of the utter crap that you have begun to spew of late.  I have no problem with the GNU project.  I love the GNU project.  And I am grateful for the work that you, independently and through the Free Software Foundation, have done so that we can enjoy the freedom to choose a free software system to do our work and our play.  But you are no longer helping; you have become a bully, an old troll.  You do not help free software any more.  Your recent action is a great offense to free software, and very much condemning a road which will lead to more free software.  Go away, troll.

Long live freedom—true freedom—and free software.  And thank you, Miguel de Icaza, for all of the great software that you have given us, as well, for your continued work to make software more useful and portable.  May you never wind up irrelevant and petty as Stallman has wound up being.

• Bar a container from SSH’ing into its host system,
• Bar a container housing public services from SSH’ing into any of its sibling systems that are not also public (i.e., firewalling against the entire RFC1918 set of networks), and
• Bar a container housing completely private services from communicating with any non-RFC1918 addressed machine.

This way, I can ensure that services that I absolutely want kept private (such as the database servers) are that way without chance of mistake.  In situations where one of the private machines must have communication with the public Internet (for example, the database server needs to be able to replicate over the Internet to its sibling), a whitelist rule to permit exactly just that communication will be dropped in, and all is well and good.

My original plan was going to be to use KVM, and have the choice of running any operating system I wanted.  This didn’t work well with the storage strategy that I wanted to employ, though, without writing a lot of custom scripts to manage it for me.  Xen wouldn’t boot a Dom0 Linux kernel on my hardware (and NetBSD would not install successfully), and so I figured I had two reasonable choices left: FreeBSD jails and Linux Containers.  I installed FreeBSD, at first, thinking back to when I ran it on servers as my first choice of operating system.  The more I was thinking about the jobs that the server would be performing—along with the fact that the server was going to be performing many Linux-specific jobs, at least that is in the plans—I realized that jails under FreeBSD would probably not be the ideal solution.  So I started tinkering with container support on Linux.  So far, I am pleased with it.  It’s very much like FreeBSD jails, in that you can have a separate namespace for processes, mounts, and networking.  I think the mounts part is different from jails, since I don’t think you can mount new filesystems in a BSD jail (or at least, couldn’t at the time I used them, when they were very new; they may now have a tweakable or just support it out-right).  That said, it works nicely.  It can be easily managed with default system configuration files and minor additions to the init scripts.  (It can probably even be managed as an Upstart job, as I do with my DNS server, but I haven’t gotten there just yet.)

Currently, there are only two containers running on the server, though that will change very soon.  Containers/VMs were the very reason I needed to make this setup in the first place…

In Other News…

I am still stuck on AllTray.  I somehow still do not completely understand the code that I’m going to need to write to get the minimize-instead-of-close feature to work properly, nor how to elegantly handle various situations that it seems like will arise once it is written.  Once I “get it” (or someone else is able/willing to make it happen), the next release of AllTray will be made.  It looks as though that will definitely not be in time for inclusion in the forthcoming distribution releases for the latter half of the year, but I will try to build packages for then-current distributions and work to get the new AllTray into the next versions of distributions soon after that.  I’m not giving up; I’m just stuck at the moment.

Of late, however, I am extremely disappointed in our community. Maybe it is because many people have started to come into it who do not always think critically nor pride themselves on the accuracy of their perceptions. This may sound arrogant, but it certainly is not written to be. There are many people in the world who do not seem to care to spend any significant amount of time thinking about problems anymore, and they are becoming more and more, everywhere you go. I am not disappointed that we have more “mainstream” types in the community, though. I am just disappointed that the process of critical thinking seems to be disappearing from the mainstream, where truth is whoever has the loudest and most pervasive advertising and marketing.

In my own personal experience, it simply is: many people make the very strong assumption that they are correct on their stand of a position without completely analyzing their own position; sometimes the position of a person is taken on faith that their friend(s) are correct in their assertions, or on faith that the past must be an accurate prediction of the future, or on faith that the marketing messages they see/hear/read daily are correct. When did we start to think in these terms? When did we stop contemplating things and arriving at a decision based on that independent contemplation? Why?

As with any polarizing issue, there is an entire spectrum of people. At either end of the spectrum, you have people who are extremists, or “die-hards”. The ends of the spectrum are often emotionally-charged groups of people who feel that their position is correct despite everything. At either end, regardless of the position being stood for or against, the typical belief is that the other side is inherently evil, inherently incorrect, or inherently otherwise undesirable.  As one approaches the middle of the spectrum, what is seen is people who are more willing to consider the issues of both sides. By nature, these people are more prone to considering the situation in as much depth as is possible—perhaps discovering that their position was based on a flawed assumption or axiom—and (possibly) changing their mind. This is what consists of an open mind: not necessarily actually changing one’s mind blindly, but considering the facts of a situation and assessing their position based on the facts and merits of the arguments as they understand them.

An open mind is one that is willing to see the facts in the first place, not one that reacts with highly-charged word-slinging. Some days, I very nearly want nothing to do with the community, because of this highly-charged slinging going on. It is like we have become small children again, but not in a good way; not full of youth, vigor, excitement, curiosity. More in the sense that we are prone to pointless and emotionally-charged bickering and the use of strong dysphemisms when talking about Mono (such as Mono “infecting” things as if it were a self-replicating computer virus for any operating system that has runtime support for viruses installed by default), which just makes the community look like a bunch of uneducated 12-year old angry boys.

So, what is a fact? This is far too much to get into here, but it is probably sufficient for our needs to define a fact as “a statement which is as objective as can be, which is typically verifiable.” For example, it is a fact that Microsoft is a corporation, and it is a fact that I, Michael B. Trausch, am a natural person.  If we cannot agree on this so far, it is best that you leave now, and spare both of us a bit of wasted time.

Patents

Now, as I understand it, the general position of the anti-Mono crowd is based on several vague arguments. Most of these arguments center around the issue of patents. The claim is along the lines of “Mono is subject to patents by Microsoft, and therefore must be bad.” Now, first, this statement makes the implicit assumption that the Linux kernel is not potentially the subject of patents (but, it is, and by Microsoft). Note that this threat is vague, and because of that, it cannot be worked around. Though, the community has proved time and time again that it can and will react to real patent threats efficiently.

In the context of Mono specifically, there was a patent application to cover .NET, which was rejected in part due to prior art. I have yet to find a granted patent—let alone an enforceable granted patent—that covers any aspect of the ECMA or ISO specifications that Mono seeks to implement, nor the Microsoft extensions to the BCL; it took me a long time to find the patent application, truth be told. Now, should I find one that may apply, I would take the time to check and send something off in the form of a bug report or a private communication to let someone know of the issue. That is precisely how free software can get around patents, in fact: volunteers such as you and I can help defend free software from patents by finding patents and pointing them out to the developers of projects we like and use. Then, those developers can make a choice: either remove the infringing code completely, modify the code to no longer be infringing but retain its functionality, or ignore it altogether. Free software projects can be forked and so if the developers take an action that others disagree with or simply do not like, one could fork the project and apply their own choice instead (presumably remove or modify the code as opposed to ignoring the potential patent problems).

The nifty thing about patents is that in general, a software patent can be worked around if what is patented is known. If Microsoft has one way of doing something and patents it, and someone else comes up with a different way of doing the same thing, the latter cannot be affected by the patent granted to the former. A patent covers a process, not a result. This means that if Microsoft (or someone with enough time) were to identify the patents that the Linux kernel potentially infringes, the Linux kernel hackers would then have enough information to work around the patent. The same goes for any free software system, including the Mono runtime and associated development tools which are licensed under the GPL and MIT licenses.

Given the nature of software patents and what they represent, for any country, state, city, or locale which holds software patents to be valid, it is accurate to say that any software, both free and proprietary, are subject to unintentional infringement of somebody else’s patent. There is no way around this except to rally together to change the laws in your region. There is no easy out of that. For more information on that, head on over to the End Software Patents Web site.

In some regions, such as here in the United States, patents on software are either in extreme danger or disarmed completely. Currently in the United States there are several tests which a patent application must pass before being granted. A patent cannot be granted for a process that “claims ‘laws of nature, natural phenomena, [or] abstract ideas’”. Also, “a mathematical algorithm alone is unpatentable because mathematical relationships are akin to a law of nature”. Addtionally, a patent must be for something non-obvious and is not prior art. The Supreme Court is taking the case. Personally, I am awaiting that decision eagerly, as it is a chance for the Supreme Court to clarify its previous rulings and reinforce the “machine-or-transformation” test, which would spell the end for many different types of software patents, particularly those purely on software itself. Here is hoping.

Patents and the Agility of Free Software

Free software has long been something that has been attacked in one way or another by one movement or another. Early on, you paid a great deal for the hardware, and wrote most of the software yourself. People traded software, and somewhere along the way, there was rise to proprietary software. Not strangely, Microsoft’s rise was in this era. I am sure that some of you cannot even imagine this—and others of us have forgotten this—but there was once a time when there was a great majority of proprietary-only software available for common computers. Linux was only started in 1991 for the 32-bit x86, and BSD was (as far as I am aware) never ported to the pre-32-bit x86 systems. Most of those ran Microsoft’s DOS. There was “freeware” around, but that was really still proprietary software in many ways. You could get free software from bulletin board systems with source code and be permitted to modify and redistribute it if you looked around hard enough.

It amazed me to see the sheer amount of free software that was available when someone handed me a set of operating system CDs—for free—and said “check this out.” I had heard of UNIX before then, but nearly always in this capacity like it was far too costly to ever acquire or run at home. The machine I was running on at the time had DOS and Windows 3.1 on it, and I would get software either via bulletin boards (rarely) or more frequently going to the store. I never was able to modify my system, or fix anything that was wrong with it in software. Suddenly, though, there was this system that I could install that came with source code, and I could modify it in any way I pleased. I was like a kid in a candy store.

The GNU project, which has sought to implement a UNIX-like system, and the Linux kernel, make a hell of an operating system. There is, today, a very large amount of software that is BSD, GPL, MIT/X11, or otherwise freely licensed that we can use, modify, fork, experiment with, study, and expand on. Free software is about those things. It does not hurt us to have free implementations of various things that would otherwise be proprietary, because part of the reason to run free software is the fact that it is itself free.

Alas, it seems that many people think that the reason to run free software is because they hate Microsoft. Indeed, that is one reason that a person could choose to run a free operating system. And there are many to choose from; hundreds of Linux distributions (both with GNU and alternative userland components), a handful of BSD systems (FreeBSD, NetBSD, OpenBSD and others) and a handful of other free operating systems such as MINIX, ReactOS, or Syllable. However, for those of us who use free software because we love it, that is not (necessarily) the reason. Indeed, many of us also have feelings for Microsoft ranging from neutral to blazing hatred for their software, common business practices, or both. These people argue against Mono because they think that it means that Microsoft is somehow “infecting” the free software world and they already ran away from such an “infection” in the world of proprietary software. By this point of view, there is a great deal that such a user can never use, such as the Web. Since they continue to use technologies “infected” by the influence of Microsoft, that must not be their primary motivation.

Can patents have an adverse affect on software systems, when software is permitted to be patented? Yes. Look at the story of compress and gzip. The reason gzip came into being was because of a patent on the LZW compression scheme that affected the compress program. In that case, free software’s answer was to replace the algorithm with a new one, instead of modifying the original one. Either option would likely have been acceptable. Also look at FreeType, portions of which has code that is covered by patents owned by Apple Computer, and the solution to getting around them is disabiling them in the default build, letting people who have the lawful ability to run that code enable it manually, themselves. The community has ways to deal with and work around these things.

If there comes to light a real and specific patent threat against the Linux kernel, against the GNU core utilities, against the Mono runtime or against a piece of free software yet-to-be-written, the answer will be much the same; for something as large as Mono, a modification to circumvent the patent would be done. For something as small and replaceable as compress, a new program with a new or thought-to-be patent-free algorithm would instead be written. Potentially even, resistance would be a viable method, such as is the strategy of the EFF’s Patent Busting Project.

“It’s From Microsoft”

The other major argument that I often hear (or read) is that “Mono is from Microsoft”. Even if it were true, it is an argumentum ad hominem, which is a deceitful and fruitless argument tactic. That said, Mono is not “from Microsoft”. It is also not “from Novell,” as it was created prior to Novell acquiring Ximian.

More than one person on the Internet has quoted the following sentence given by ECMA as an answer to a query on the CLI:

Ecma does not have anything to do with possible licensing of .NET. But Microsoft is one of our members, so I have asked them whom to contact there – if anything is needed, what I just do not know.

This statement is factually correct. However, most people stop there and fail to apply their critical thinking skills—which we all have and are capable of using. ECMA indeed does not have anything to do with the licensing of .NET. .NET is Microsoft’s implementation of the ECMA and ISO standards that comprise the CLI and the BCL, including the runtime environment and the IL engine and the C# programming language. It is not the standard. .NET is distributed under a typical Microsoft EULA, with some permissions for redistribution (as is the case with many of Microsoft’s runtime libraries). Along the same lines, ECMA does not have anything to do with the licensing of Mono, which is licensed under the GPL and MIT licenses. They cannot answer questions directly pertaining to either. In short: ECMA can say nothing of an implementation. Consider this, if you asked about DHCP, and they said, “We have nothing to do with the licensing of ISC DHCPd,” it would be the same; DHCP is a protocol, a specification, and ISC DHCPd is an implementation.

This is a simple case of either the wrong question being asked, or someone along the “telephone” chain misunderstanding the question and/or rephrasing it to become incorrect. So the correct answer to the wrong question came back out. This is life.

Mono was started by the same programmer who co-founded the GNOME project (a GUI implementation), and who wrote Midnight Commander (a free software and enhanced reimplementation of the old Norton Commander program from the days of DOS), both of which are licensed under the GNU GPL, Miguel de Icaza (see the History section of the Wikipedia article of GNOME and the MC FAQ, § 10.1). This was quite some time before Ximian was acquired by Novell. Now, I am not saying that everything de Icaza has written or worked on is absolutely awesome—that would be a flawed assumption. He is an intelligent programmer and a competent leader, but that does not in and of itself mean that everything he has done has been perfect. However, GNOME, Midnight Commander, and Mono each stand on their own merits. Mono is to .NET what Midnight Commander is to Norton Commander: a free software analog to the other product which is not identical and in some (if not many) ways demonstrably superior.

In case you were caught unawares, here is a list of other technologies that Microsoft has had (at least) a part in creating or spreading: the HTTP/1.1 standard, HTTP Digest Authentication, SOAP, WSDL, Sender ID, MADCAP, DNS SRV, PPTP, many variants of the BASIC language, and many more. Many of the developments that they have put time and effort into over the years, we still benefit from today. Is Microsoft a bad company? Generally, it seems as such. But they are a company, not a person. Even still, like people, they can not be inherently good nor evil, even though their actions can be one or the other. Are they always bad? No. Are they always good? Certainly not. Are they incapable of being productive? No, they are capable of helping, even if their primary motivation is to help themselves first.

A Digression on “Law”

Freedom is something that we all must use, and pay for, or we lose it. Some of us have never had it and have to pay a price to gain it. Admittedly, this section is apt to largely only accidentally apply to non-U.S. regions of the world, so if it does not apply to you, skip it.

In the United States, we have this funny thing: we have the right to vote. On leaders. On issues. In some states in the U.S., people can even be the legislators, given sufficient motivation. This is called citizen’s initiative. Some states have both direct and indirect citizen’s initiative. But at the federal level of government here, what we have are representatives.

Now, we can write letters to our representatives and ask them to consider and raise certain issues at the federal legislature on our behalf. This of course does not work if only one of us does so, nor does it work if only a small handful of people from a certain district were to do so. It would have a significant effect, however, if many people from many districts—and in many states—were to do so. This is the power that we have as Americans to craft the laws which apply to our land. This can, of course, be used for both good and bad laws to be created. This is why we have courts. It sounds terribly basic, but it is something that we all seem to forget that we can do sometimes, or that we only think of to do for especially major atrocities. No, it is something that we can do for many things. Patent law is one of these things. If we want to assure ourselves that patent law goes away, we have a limited power to make that happen, through our representatives. Let us not forget that.

However, there is a more important set of law that we also forget about, which does not apply in any singular territory or state: actual law. That whole process that builds common law, case law. Now, I am not saying that it is okay to just blindly disobey law. But law is not crafted through the idle state of society. There are provisions in law for certain things—affirmative defenses—to make otherwise illegal things legal precisely because nothing is purely black-and-white. There is no law that says that it is unconditionally wrong to kill another person; it is not murder if you are absolutely required to kill in order to defend yourself, for example. Changes to law to add affirmative defenses sometimes occur as part of a realization that a law prohibited too many things, and laws are written, amended, and tried in courts all the time to try to find gaps or holes in the law and refine them, through new legislation or through new case law. Therefore, an action that may be illegal by statute is not necessarily illegal if there is some reasonable cause for it not to be and that reasonable cause is noted by a court or a body of legislation (such as Congress).

On some level, everyone knows this. Many people commit wanton acts of copyright infringement and do not even think twice about it, because they do not perceive it to be wrong. Some people only “pirate” copyrighted acts that are of a certain age, seeing codified law on the length of copyright as invalid and refusing to recognize it. After all, whose definition of “wrong” are we working with? There may be consequences for such actions, and people more or less accept that when they commit the action that they know to be wrong, at least as far as law is concerned. But there are certain things that, if disregarded entirely amongst an entire population, have a funny way of finding themselves to disappear from the law, either because the law is dropped from the books or because the executive branch of government no longer bothers to enforce it.

Conclusion

Before patently (ha, ha) screaming against Mono’s inclusion in various distributions, be that Gentoo, Ubuntu, Debian, Slackware, or $YOUR_DISTRO_HERE, think about something: Why?

Mono is no more inherently dangerous than any piece of GNU software, the Linux kernel, the various BSD-derived operating systems, or any other piece of free software. All software amounts to very specialized applications of mathematics; data is input, transformed, and output in every system. That does not matter if the data is bytes to a sound card, a stream passing through a compression program, a cryptographic encryption or hashing system, an application-layer protocol, a network-layer protocol… whatever. It does not matter. All software has risk of infringing on a patent. Not even proprietary software is safe against software patents held by others, even when the author of the softare and the backer of the legal team behind it is as wealthy as Microsoft’s.

There are certainly issues that we all—as a community—need to get together and work with. Development is not the only thing that people can do in the community. However, spreading FUD is not helpful, and it seems to be catching on these days. Are we not the very same community that worked to debunk Microsoft’s FUD, now wasting time and resources that would have better gone into the development of software, the maintainence of Web sites advocating and supporting free software, the documentation of user software and development APIs, or research on various aspects of the software (including trying to fish out potentially infringing patents and helping the community by bringing them to light)?

Freedom is not free. If you care for free software, you can help. Are you good at reading highly-obfuscated documents? If so, you could help the free software world by reading patents and trying to document them and where they apply. Are you good at reading source code? You could work together with the patent-readers to audit code and find things that are potentially covered by patents and alert someone—presumably a developer for that project, whatever it is—to the specifics so that the issue can be further investigated and dealt with in some way. Likewise, there are a ton of other ways that people can help free software to grow, help new free software projects to mature, help old ones to be maintained and/or documented, help contribute CPU cycles, disk space, or network bandwidth to projects that you care about (especially the ones that are independent and not under the umbrella of the Free Software Foundation, the GNOME Foundation or the Linux Foundation).

Yes, you can help free software out, even if you cannot fix bugs. Just help, don’t hurt. Those who are hurting us as a whole, the ones who are making us look like immature preadolecents, are doing the free software community a mighty disservice. So what if you do not like a particular piece of free software on your system? If you do not like it, remove it. If you do not like it being in your distribution, then change distributions. Do something about it. If you actually want to discuss it, then fine. Find a forum to house a rational debate on the issue. Short of that, this pointless war—like we Americans’ wars on terror and drugs—really needs to stop. After all, “A house divided against itself cannot stand,” so let us not fall.

Edited at 2009-06-22T05:13:51Z to fix a typographical error.

I’ve never had a use for a *huge* amount of this type of space on every partition on a system. Just enough “elbow room” to work with is fine for me, and lets more data be stored. So, for partitions larger than 2 GiB or so (which is just about the case these days for any machine, with the possible exception of a boot partition), there is an awful lot of space that just isn’t used. Now, this is the number that works for me and most of my systems, so of course some people may want more space (and some may want less). I cut the reserved space to 100 MiB, which frees up a lot of space on my filesystems. Here is the effect of doing it on my server:

Tuesday, 2009-Mar-03 at 17:35:04 - mbt@allspice - Linux v2.6.28.7
Debian Lenny:[0-23/167-0]:/srv> df -h
Filesystem            Size  Used Avail Use% Mounted on
/dev/sda1             5.5G  859M  4.5G  16% /
tmpfs                 503M     0  503M   0% /lib/init/rw
udev                   10M  116K  9.9M   2% /dev
tmpfs                 503M     0  503M   0% /dev/shm
/dev/mapper/lvmsys-opt
                      4.0G  502M  3.3G  14% /opt
/dev/mapper/lvmsys-home
                       99G  1.9G   92G   3% /home
/dev/mapper/lvmsys-srv.db.mysql
                      4.0G  136M  3.7G   4% /srv/db/mysql
/dev/mapper/lvmsys-srv.db.postgres
                      4.0G  136M  3.7G   4% /srv/db/postgres
/dev/mapper/lvmsys-srv.vcs
                      4.0G  136M  3.7G   4% /srv/vcs
/dev/mapper/lvmsys-srv.vcs--mirror
                       20G  172M   19G   1% /srv/vcs-mirror
/dev/mapper/lvmsys-srv.www
                      4.0G  136M  3.7G   4% /srv/www

Tuesday, 2009-Mar-03 at 17:35:09 - mbt@allspice - Linux v2.6.28.7
Debian Lenny:[0-24/168-0]:/srv> for i in /dev/lvmsys/{home,opt,srv.db.mysql,srv.db.postgres,srv.vcs,srv.vcs-mirror,srv.www}; do sudo tune2fs -r 25600 $i ; done
tune2fs 1.41.3 (12-Oct-2008)
Setting reserved blocks count to 25600
tune2fs 1.41.3 (12-Oct-2008)
Setting reserved blocks count to 25600
tune2fs 1.41.3 (12-Oct-2008)
Setting reserved blocks count to 25600
tune2fs 1.41.3 (12-Oct-2008)
Setting reserved blocks count to 25600
tune2fs 1.41.3 (12-Oct-2008)
Setting reserved blocks count to 25600
tune2fs 1.41.3 (12-Oct-2008)
Setting reserved blocks count to 25600
tune2fs 1.41.3 (12-Oct-2008)
Setting reserved blocks count to 25600

Tuesday, 2009-Mar-03 at 17:35:25 - mbt@allspice - Linux v2.6.28.7
Debian Lenny:[0-25/169-0]:/srv> df -h
Filesystem            Size  Used Avail Use% Mounted on
/dev/sda1             5.5G  859M  4.5G  16% /
tmpfs                 503M     0  503M   0% /lib/init/rw
udev                   10M  116K  9.9M   2% /dev
tmpfs                 503M     0  503M   0% /dev/shm
/dev/mapper/lvmsys-opt
                      4.0G  502M  3.4G  13% /opt
/dev/mapper/lvmsys-home
                       99G  1.9G   97G   2% /home
/dev/mapper/lvmsys-srv.db.mysql
                      4.0G  136M  3.8G   4% /srv/db/mysql
/dev/mapper/lvmsys-srv.db.postgres
                      4.0G  136M  3.8G   4% /srv/db/postgres
/dev/mapper/lvmsys-srv.vcs
                      4.0G  136M  3.8G   4% /srv/vcs
/dev/mapper/lvmsys-srv.vcs--mirror
                       20G  172M   20G   1% /srv/vcs-mirror
/dev/mapper/lvmsys-srv.www
                      4.0G  136M  3.8G   4% /srv/www

Tuesday, 2009-Mar-03 at 17:35:27 - mbt@allspice - Linux v2.6.28.7
Debian Lenny:[0-26/170-0]:/srv>

That’s quite a noticeable improvement.

The number 25600 is the number of blocks to reserve; to get 100MiB of reserved space, I held 25,600 blocks (4KiB in size on these filesystems) for root. The percentage really only makes sense if the filesystem size is small, since you’d obviously not want a 100 MiB reservation for a filesystem that is under 2 GiB or less in size, since you’d be consuming a very large portion of the filesystem for a reservation. The point of the reserved space is to give root some wiggle room when the users fill up the drive, and 100 MiB is enough to do that with. Maybe even less is enough.

Why?

I’ve used AllTray for a long time. It is one of those pieces of software that performs a useful function, but you have to know its quirks to make it do what you want quite often, and you have to work around some of the things that it does for it to retain that usefulness. Users shouldn’t have to do that—they should just be able to start using a program or utility and have it work properly. Also, utilities should be (reasonably) independent of the environment that they run within, which AllTray isn’t. And, good utilities should integrate with the system pretty well, which AllTray does not, since it carries a hard dependency on GDK/GTK. (Kdocker is an alternative piece of software, and while I don’t know how well it works compared to AllTray, I know that it is bound to Qt, which is just as bad.)

The license will most likely be GPLv3, since nothing will actually link to it and it’s not a library. If there is a library component, it will be LGPLv3.

The actual “braindump”

The actual *docking* part isn’t terribly hard, it would seem. With GTK+ it can be done in only a few lines of code (especially in C#). However, C# wouldn’t be the language to use for the this tool, because of the dependency on Mono. My thinking is that the proper language to use would be C itself. It makes me think of how easy everything would be if only the desktop environment and all its software were already written in managed code… the effective cost of using C# would be significantly less than it is already.

Using C as the language isn’t that big a deal to me. What is a big deal to me is that the application be well-integrated and well-behaved. For example, AllTray depends on GTK for some of its tasks, and uses a custom (ugly, IMHO) widget for displaying its title when you over over it in the system tray. There’s another program out there, KDocker, that would appear to be slightly more featureful than AllTray, but it carries with it a dependency on Qt, which I don’t like. Ideally, the core for such a docking utility should be able to have various back-ends that serve the purpose of integration with the system, with a single back-end that would apply without dependencies on anything else for the rare scenario where neither GTK+ nor Qt are available.

What would this thing be required to do?

• Dock any arbitrary application to the system tray, not just a single window from the application. (Using the System Tray Protocol Specification)
• Run in a single instance, managing multiple applications within that instance if necessary.
• Provide session management for those who use it, and act as a session manager for applications that are run underneath it that support session management.
• Be able to use something like inotify to be able to show an indication of when the application’s title for its windows change.
• Use a single icon for the application, with a window list if the application carries more than a single window.
• Use individual backends which provide a native look and feel depending on the desktop environment currently in use.
• Use the application’s icon to represent the application in the system tray.
• Support blinking the icon when the application decides to do something like present a modal dialog box or something (if this is even possible, that much I am not quite sure of).
• Detect the desktop environment currently in use and (if possible) load a backend to integrate with it.
• Carry a dependency on GLib so as to make implementing it quicker and less error-prone.
• NOT carry any hard dependencies on any widget libraries like GTK+ or Qt.
• Return an error to the user if there is no running system tray, and there isn’t one after some sort of timeout (say, when starting the desktop environment, there may not be a system tray right away). (I don’t think that sort of situation would be commonplace, but it’s not really the job of this program to create a system tray if one doesn’t exist, since this is the job of the desktop environment.)

The backends would not have any specific configuration items (the entire configuration would be housed somewhere like ${HOME}/.config/docker, for example). There probably ought to be a backend entrypoint that would show a dialog for configuration, but I haven’t really figured out if that’d be the case yet. The docker should probably do all of its configuration by way of the command line for each invocation, which is suitable for use as a desktop shortcut or panel launcher.

This approach requires that each individual desktop environment have its own backend, which might become a bit of a pain for supporting a great number of desktop environments, but the upshot of that is that the application then feels native no matter what environment the user is using. Obviously support for GNOME and KDE would happen, and most everything else would depend on someone with programming experience for various environments to implement a backend for it.

The backend doesn’t handle, say, docking, since there’s a standard for that already. It would handle things like displaying the tip when hovered over or displaying a menu when right-clicked. So, the job that each backend would do would be pretty lightweight. And as much as possible should be handled in the core, with the backend consisting of just enough “hooks” into the target system to be able to provide a useful interface.

The way that this would have to work, using C as the programming language, would be that the core would have to use dlopen() and friends to load the backend and then use the entrypoints that the backend provides. Since dlopen, dlclose, dlsym, and dlerror are defined by POSIX.1-2001, support for those should be in every reasonably modern Unix-like system that supports at least a subset of POSIX. This of course eliminates Windows, but I am not terribly worried about that since there are probably other Windows-only utilities that serve this purpose.

The primary goal, then, is to replace other DE-dependent and toolkit-dependent dockers with a utility that carries the goal to be universally useful and highly robust. The aim of this goal is to replace AllTray entirely in (at the very least) Ubuntu, and hopefully be seen as useful in other distributions as well.

I’ll need some help…

This is the part where it’ll get interesting. I’ll need some help in actually doing this, in many areas.

For the moment, where I’ll need help (be that from Google, or from people in-the-know that happen upon this post) is to find all of the documentation that I’ll need to understand how to implement the software. I can use software that already exists to try to learn how the underlying system works, to a degree anyway. But some of the software doesn’t handle various situations correctly (or I don’t have a way to see if it does) and so studying them would be less than useful for everything I am trying to do. Namely, the things I need to find out yet are:

• How to run a program in such a way as to be able to reliably know what windows belong to the program and be able to dock them. I suspect that it’d involve using LD_PRELOAD and some monitoring trickery, but I would hope that there is some sort of API to do this already. Also, need to know how to manage the application itself; say it continues running but without any windows, the tray icon should obviously disappear while it’s running like that, until it has windows to manage again.
• How to perform session management and be a session manager for subordinate programs. (I might be able to study the source for KDocker to learn the answer to that, though I am not 100% certain yet of that.) I also have a paper to read yet on the subject that may have all the information that I am looking for, though I am not certain there yet, either.
• How to reliably detect the running desktop environment without resorting to ugly kludges and ad-hoc trickery.
• How to work independent of the currently-running window manager and operate reliably for any standards-compliant WM that is running, without having to special-case for various types of software or various types of window managers.

I suspect that there is useful documentation out there for most (if not all) of those things for X11 and other relevant points. I just haven’t found what I am looking for yet for all of it. Standards documents and system documentation are useful things to find, and maybe an example or two of source code on how to do it as well, are what I am looking for, so that I can try to understand these things better.

At some point down the road, I’ll need help with getting the backends written when they have an API to conform to. I can, in all probability, write a GTK+ backend that will work for XFCE and GNOME since I use GNOME. However, I don’t use KDE or anything that runs on top of Qt, so I will definitely need help from someone that is familiar with writing software for Qt to get a Qt backend written. If XFCE has any sort of non-standard special UI guidelines that are incompatible with GNOME, then I’ll need some help there, too. Any other non-GNOME or non-KDE environments (such as GNUstep, if it supports it anyway) that support the System Tray Protocol Specification will need backends written for them by people that are able to do so.

Append the following to the end of your ~/.bashrc (if you use GNU bash, anyway) and you’ll have a pretty cool looking prompt (IMHO, of course):

prompt {
    local WHITE="\[\033[1;37m\]"
    local GREEN="\[\033[0;32m\]"
    local CYAN="\[\033[0;36m\]"
    local GRAY="\[\033[0;37m\]"
    local BLUE="\[\033[0;34m\]"
    local BROWN="\[\033[0;33m\]"
    local RED="\[\033[0;31m\]"
    local RESET="\[\033[0m\]"
    local KERNEL_VERSION=`uname -r | grep -o '[0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*'`
    export OS_RELEASE=`lsb_release -is`\ `lsb_release -cs | awk \
'{ print toupper(substr($0, 1, 1)) substr($0, 2) }'`

    export PS1="\n${CYAN}\D{%A, %Y-%b-%d} ${BROWN}at ${CYAN}\D{%H:%M:%S}\
 - ${RED}\u${BROWN}@${RED}\h - Linux\
 v${KERNEL_VERSION}\n${OS_RELEASE}${CYAN}:[\j]:\W> ${RESET}"
}

function pcmd {
    printf "\033]0;%s@%s - %s - %s\007" \
        "$USER" \
        "$HOSTNAME" \
        "$OS_RELEASE" \
        "${PWD/$HOME/~}"
}

prompt

case "$TERM" in
    xterm*|rxvt*)
        export PROMPT_COMMAND=pcmd
        ;;
esac

And here’s another ironic twist: Consumers may actually prefer to pay for Ubuntu — rather than get it for free. No joke: Many consumers don’t like free software. They fear it. My brother in law didn’t understand how Ubuntu and OpenOffice could be free. “Is it legal to actually download and share that software?” he wondered.

I understand how some people can feel like it may not be legal to acquire software that is free, I suppose. Microsoft and the BSA have pretty well attempted to drill the thought into people’s minds that software acquired without a financial cost can be somehow illegitimate, implying that it’s simply not possible for the Internet’s citizens to create software that is of any measurable quality. Of course, anyone that is “in the know” is quite aware of just how wrong this idea is; the quality of Microsoft’s own software is somewhat debatable.

The simple truth is that people just like you can learn to write software, and write high-quality software if motivated to do so. A large portion of free/open-source software is worked on by people such as yourself. Things ranging from the actual programming, to bug management, to documentation—all of those things can be done by regular, everyday people. There’s nothing—other than Microsoft’s business strategy—that says that the work that you or I do on a free or open-source software project is automatically of any sort of lower quality when compared to Microsoft’s software. In fact, the major argument for such software is its transparency. I know that when it comes to any software, I often want to change it to fit me better than the original programmer or company provided for. For software such as Windows, or Internet Explorer, or Microsoft Office, or any other proprietary software offering, this is impossible without violating some sort of license agreement. Now, that having been said, there is the belief that copyright law permits some “tinkering” of something which one has the right to use. I suppose this make sense—nobody would dare invoke copyright law to declare that the notes you’ve written in the margin of your textbook are illegal. Effectively, writing notes in the margin of a textbook or highlighting passages is “patching” the textbook to contain more information and do more things for you the next time you read it. So, why should it be illegal for a Windows user to write (or run) software to bypass the silly restrictions on theming in modern versions of Windows? It’s essentially the same thing.

The fact that Microsoft, the BSA, and other companies and organizations are so successful in drilling this “thou shalt pay for thy software” commandment into people’s brains is somewhat terrifying to me. It means that people in general are still easily had; they think that a corporation that makes billions in revenue every year is somehow more legitimate than the loosely-knit ecosystem of free/open-source software programmers. Of course, we can confirm that idea by simply looking at the U.S. Government, as well; people are inclined to trust it to provide the freedoms that we’re supposed to have, while all the while taking those freedoms away in the name of “national security”.

The point? Think before accepting what corporations and alliances such as the BSA quote as gospel truth. Yes, it is illegal to copy and redistribute Microsoft software without a grant of permission from Microsoft to do so. That restriction does not hold true for all software, though; you can freely copy and redistribute the Linux kernel, the Firefox Web browser, the OpenOffice.org suite of office software,˙and so many more, worthwhile pieces of software—including the entire Ubuntu operating system distribution discs. (In fact, they even say “Pass it on!” on the official media!) There is a lot of value to a system that can be modified on the fly to fit the needs of its user… and this is something that corporations and “copyright advocates” will seemingly never understand.

The book tells the story of Marcus Yallow, a high-schooler, and his interactions with various governmental agencies. The story is set in California, in what can only be described as “potentially not very far in the future”. The telling of the story is direct and powerful.

Even better, the author of the book is very knowledgeable with regards to technology. Nearly every piece—if not every piece—of technology talked about in the book exists or has the potential to exist today. The story is not far fetched, it’s not fantasy, and it’s not surreal in the sense that it depends on things that we do not yet know. It is highly relevant, and everyone—children and adults alike—should read this book.

The story is also released by the author under the terms of a Creative Commons license. It can be copied and distributed on the Internet, or in any other medium, at will. The book is also published in traditional “dead-tree” format by Tor®, which publishes lots of science-fiction and fantasy books such as the Ender’s Game series of books. The author of the book also contributes to a wide variety of other publications, such as MAKE Magazine, which has all sorts of very nifty do-it-yourself type technology projects.

If you read nothing else, take the time to read Little Brother. It is thought-provoking and highly realistic, and well, well worth the read.