I'm a huge Free Software enthusiast. I founded the Open Graphics Project
because I want to promote Free Software.

So, I think Free Software should rule the world, and I believe that it is an
ethical issue, not merely a practical one. I feel that I am a minor activist
in this regard. The more Free Software that people use, the more freedom
we'll all have, and I am trying to do my part in my own community project.

At the same time, I'm also an engineer and a scientist. I think about the
systems I use, critique them, and consider how they can be improved. As part
of my Ph.D. studies at OSU, I'm minoring in Cognitive Engineering. Putting
Freedom into people's hands is useless when those people can't figure out
how to use what they have.

While it's good to think about the total novice, it's even more important to
have consistent and logical mechanisms. This way, if someone has to learn
something new to use the computer, they have to learn it only once. This is
why I think it's good that Apple and Microsoft have UI development guides
that encourage developers to make their apps act consistently with other
apps in areas where their functionalities conceptually overlap. And this is
where I start to get disappointed with GNU/X11/Linux systems. (Even though
Rick says this isn't important.)

Apple didn't invent the idea storing all application-related files in one
place. I think I read somewhere that an early version of RISCOS did it this
way, but Apple has adopted this idea very nicely, and Windows isn't too far
behind. The basic idea is that most files for an application are stored in
one single place.

Linux, unfortunately, sticks to its UNIX heritage of spreading things out
all over the file system. Executables to in /bin, /sbin, or /usr/bin or
/usr/local/bin. Shared objects go into /usr/lib or somewhere under
/usr/local. Configuration files (all plaintext; see below) go somewhere
under /etc or somewhere under /usr/local. There is a standard that describes
in detail how things should be structured, but it's much too brittle. In
theory, conventions, even complex ones, can be strictly followed, and
everything works out well. But this is an example of a convention that adds
just enough complexity and confusion that it doesn't get followed
consistently, and the one left holding the bag is the end-user who can't
figure out where their files are when something goes wrong.

*Configuration data*

Microsoft almost got this right. With the introduction of Windows 95 came
the introduction of a centralized registry for all system and application
configuration data. It's a hierarchy of key/value pairs accessible from any
application. In principle, this is a rather nice way of doing things. The OS
provides a simple mechanism for apps to keep settings in a database.

Users of Windows and other systems panned this approach for one good,
practical reason: It's unreliable. Although things have improved, registry
corruption is still the bane of the Windows user. Install a new app, and it
or the OS does something weird, and bang!, the whole registry is hosed,
requiring a complete reinstall of the OS. Single points of failure are bad.

Because of a strangely black-and-white sort of thinking, GNU/Linux systems
have avoided anything remotely like a registry and stayed stuck in the dark
ages with respect to config files. Stored in seemingly random places, every
application keeps their own config files in their own special formats, in
plain-text ASCII. Despite being littered with comments, most of them, when
you can find them, are basically impossible to figure out. Some apps provide
GUI tools to edit them, which is great, but they're not always available.

But an even bigger problem, the one thing that made me ditch Gentoo
completely and get frequently very annoyed at Ubuntu, is the nightmare of
application upgrades. If you have made any changes at all to an
application's config data, and then you want to upgrade that app, you have
three choices: (1) Keep the old config file, not benefitting from any new
options or defaults provided by the upgrade; (2) use the new config file,
tossing out all of your changes, requiring you to redo them all; or (3) go
through a painful largely-manual merge process, often guessing about the
meanings of any new options you find and whether or not your old change is
appropriate for the new version. From first-hand experience, I can tell you
that this is a very tedious and error-prone process that can leave
applications completely broken.

For instance, every minor KDE upgrade under Gentoo would leave me finding
that some standard KDE app was completely missing, and no one in the Gentoo
forums could help me figure out what happened. (And that was after manually
sifting through a few hundred config files that were updated.) This total
lack of a standard is a huge embarrassment for Linux.


X11 basically lacks a clipboard. Instead, the basic X11 cut/paste mechanism
is based on a convention of storing information in atoms on the root window.
This is another example of a lack of standards. For instance, one of my
favorite editors, Nedit, won't work correctly with the clipboard under KDE
or GNOME. The problem here isn't a technical one, however. Like so many
other problems with Linux, it's all about ego. Everyone thinks their way is
the best and has no interest in adapting to other conventions.

*Ego is the problem*

Here we are exposing one of the fundamental problems of Linux systems. It's
all about ego. Windows users are elitist snobs because they use the dominant
platform. Apple users are elitist snobs because they use the "cool"
computers. And Linux users are elitist snobs because they use Free Software.
What sets Windows and MacOS apart from Linux is that Linux doesn't separate
the developer community from the user community.

Most Linux developers do what they do because they have a passion for it,
which is great, but that also means they are sometimes stubborn and
unwilling to cooperate with others who think differently. At Microsoft or
Apple, a committee decides on APIs and system conventions, and then some
coder is paid to implement it that way; as a result, applications see a
consistent organization and set of system services. Linux follows a
completely distributed development model, where often, it is individual
developers who make unilateral decisions about system organization and
architecture, quite frequently eschewing established standards (when there
are any). I don't know how to fix this problem, but I believe it is a major
barrier to Linux's success on the desktop. If it can't be fixed, then Linux
and Free Software won't dominate.

My suggestion to the Linux community: Put aside your egos and work together.
Stop all of your egocentric bickering and let reason work out who is right
and who is wrong. Develop good standards and stick to them. Of course, no
one can develop the perfect system, so you eventually have to declare a
version "good enough" and move on. But be willing to make drastic changes
when a better idea comes along!

** Posted from **