Richard Stallman. I have a lot of respect for GNU, the Free Software
Foundation, and for Mr. Stallman. However, I think the goal of creating an
operating system which is simply free has limited the GNU project from its
inception and is one of the chief reasons that the FSF has not been as
successful in putting free software into the hands of as many users as they
would probably like. In the end, it all comes down to usability.Richard Stallman has written and spoken passionately on many occasions about
the ideals and values of the free software movement. For him, it is a moral
imperative that people should be able to use and modify software freely.
Perhaps more important to him is the freedom to help one's neighbor by
giving them a copy of your software without the threat of facing copyright
infringement suits. These are laudable values and I whole-heartedly agree
that free software is "better."
But, unfortunately, this seems to be where the vision of the free software
movement ends. Stallman writes in his 20th anniversary letter to the
community "The most effective way to strengthen our community for the future
is to spread understanding of the value of freedom." The assertion here is
that freedom is enough for users of computer software to want to adopt free
software. Valuing freedom and free software will "satisfy" people more than
using proprietary software. The problem with this view is that it doesn't
take into account the average computer user and human nature.
Most computer users want an experience that is free of frustration and
hassle. They want their computers to be easy to use, but powerful enough to
handle any task for which they might want to use the machines. And most
people are probably going to choose to give up some freedoms and pay money
for a system that they think will be better at achieving these goals because
they value ease of use more than they value freedom. So if the free
software movement really wants to convince people that it is better to use
software that maximizes their own personal freedom, then the free software
community must begin to think more seriously about providing a computer
system that meets users' expectations for usability.
The goal that Richard Stallman set out to achieve twenty years ago was a
lofty one. Creating a free operating system from scratch was both ambitious
and noble-minded. Unfortunately, from the beginning the GNU Project
suffered from the decision to create a Unix-like operating system.
Unix is fundamentally flawed. It generally forces the user to learn and
memorize dozens of arcanely named commands just to perform basic tasks.
Many legacies and values from the ancient days of mammoth time-sharing
systems have forced Unix to be opaque and decidedly "unfriendly": brevity,
text-only foundations, and a culture which promotes tools that are more
useful to programmers than normal users (see "Biculturalism" by Joel Spolsky).
How ironic it is that the Macintosh personal computer was introduced at the
end of the same month that the GNU Project began its work. If only Stallman
had waited one more month before quitting his job at MIT, perhaps he might
have been inspired to clone the Mac's graphical OS instead of Unix. A free
software system based on the Macintosh would probably have been adopted more
readily, but it was an unlikely choice for 1984.
What I am proposing today is that we adopt a new vision for the free
software movement. A vision of creating a software system that is not
simply free -- for freedom is not enough -- but one of creating a system
which all users will not only find easy to use but will meet the needs of
personal and ubiquitous computing in today's world.
Such a system should not be a clone of any existing system but should itself
be free -- free of the trappings and the chains of older and outdated
paradigms of computing. We should not only enlist the help of competent
programmers and software architects, we should also seek out competent
interface designers and researchers of human-computer interfaces.
What form might this new system take? I won't pretend to have all of the
answers yet but I have culled together a few basic ideas from my own
experience and thought as well as from several innovative systems and
Here are some of the core features of such a system:
1. The system's interface will be fundamentally graphical (no underlying
command-line). Fundamental data types will include much more than plain
text and all data will be tagged with metadata.
2. The system's structure will be more integrated from the user's
perspective than it is now. There will be no applications and no visible
file system and resources should be treated similarly regardless of where
they are located (on the local machine, on the network, etc). There will
only be objects on the screen and the commands to manipulate those objects.
(This idea is similar to the Squeak
implementation of Smalltalk).
3. The interface should be as consistent as possible. Similar
functionality should appear the same to the user (and use the same
implementation). Any operation or command installed on the system should be
available whenever the context makes sense to use it (e.g. a spellchecker
should be available whenever editing text).
4. The user's data is sacrosanct! This means that all data must be
persistently stored -- no "save" operations necessary (think Palm OS).
Furthermore, all changes to data must be saved with unlimited and pervasive
undo. (A user should be able to undo last week's changes to her resume).
5. A high degree of customizability is required. Users would work
primarily in a set of custom created "workspaces." The system would be
pervasively scriptable as well as providing access to the source code for
all system components.
6. The interface will reinforce spatial memory. Visible objects will
maintain the spatial relationships onscreen that the user gives to them
(like the Macintosh Finder). Workspaces and projects will open back up in
the state they were left in. When starting up the whole system, it would
return to the same state it was in prior to shutting down.
Certainly, this new system could be built partially from existing free
software. But, if this vision for a new free and easily usable operating
system is to be attained, then it will take the work of a large and
I hope that this new vision will inspire the free software community to
strive to create a system that is more than simply free. If you want to
help achieve this vision, please contact me at firstname.lastname@example.org.
For more details about how this system might look, a temporary forum has
been created at The
Project for a Usable and Free Operating System on Yahoo! Groups.
The following people have contributed to my vision of a new computing system
centered on usability: Jef
Raskin, Bruce Tognazzini, and the
other original designers of the Macintosh; the Squeak team; the original Smalltalk
designers including Adele Goldberg and Alan Kay; Dr. Henry Ledgard,
Elizabeth Mather, and John Ughrin.