We've had network-centricity, document-centricity, web-centricity, now it's
time for some user-centric computing. Some people use the term user-centric
for describing there attempts at user interface design, but it goes much
further than that. User-centric computing, in short, means that the user
creates everything on the computer. They don't create it in the traditional
hard-coding sense; they create it in a multitude of ways. Whenever a user
interacts with a computer they are no longer using an application; they are
creating objects, documents and agents.
All this creating happens inside the 'software environment'. The software
environment contains everything needed to establish network connections, send
and receive information, create object interactions, display multimedia and
search for information. When a user creates objects (which essentially make
up tools, documents and agents) they are doing so through direct
manipulation. Direct manipulation use to mean having to understand the core
computer components, but just as you don't have to understand quantum physics
to move a teacup, you don't have to program C++ to create objects and object
interactions. What this means is - when you write a letter, you are no
longer typing in a word-processor, you are adding letter objects (or ink) to
a page object (or paper). This has advantages, not only does it model real
life, it also means I can add paint to my page, or hyperlink, or anything
else. No one programmed this in the traditional sense; it's just a fact of
life that inks stay on paper!
With this model come distinct advantages in I/O independence, media
independence and artificial intelligence. I/O independence is helped because
it doesn't matter whether you're using a pen, keyboard or voice, they'll all
write on any document object (necessary pen and keyboard interface
information will be kept in the pen or keyboard). It also allows for
switching between media types and the creation of multimedia interfaces using
intelligent media (media that programs itself for different situations,
creating user/situation-specific interfaces). Most importantly, this high
level abstract programming environment helps AI as well as the user - it
allows the artificial intelligence to work with objects that have meaning to
both it and the user.
An early (and failed) attempt at some user-centricity was the original
version of HTML. Older HTML commands are <quote> and <small>. This is
because font sizes and colours were to be defined by the user. This approach
failed because the web browser was not advanced enough to create a good
multimedia interface and because publishers wanted more control. It is not
yet possible to create a truly user-centric computer, but we can start moving
in the right direction. Making the ability to program applications as
in-built as the ability run them will open up many possibilities
(particularly in the business sector). The advent of Aspect Oriented
Programming (AOP), component software and real-time aspect weavers will also
improve user-centricity.
I'm in the process of designing a user-centric software environment for rapid
application design, prototyping and real-world interactions (making objects
that co-exist in the real world and the software environment). Eventually
I'll make a home version and crush Bills mighty empire, but that's for
another day…
--Wax
P.S. I just realised that if I succeed in creating my OS. I'll not only
destroy Microsoft, but *every* software company! How's that for a monopoly!