The Metaface Project

March 21, 1999
Modified September 17, 1999

I have a dream.

No, not the one that involves Milla Jovovich in a string bikini, nice though that one is. Nor the one about the giant space station covered in plants. This is a Technology Vision Thing(TM), which means it's much, much stranger.

We take for granted that computers have a user interface. These interfaces are often the subject of holy wars between Windows vs Mac vs Unix and all the other permutations, but why? Well, the interface of the computer is where your mind melds with the program which the machine is running. It's symbiotic, in a way. Or at least, it would be if the damn things were any good.

Overlapping windows? Who's damn stupid idea was that? I spend half my life rearranging pieces of paper on my desk, an the other half arranging windows on my desktop! Did you ever try using a computer through a brailewriter? Ye gods, simulated deafness through not having a sound card can be hard enough.

I love my PalmPilot, and I wish I could use it to access the same services as my desktop. But, as users of other PalmTops know, everything is designed for 640x480 screens with billions of colours.

And what about when the user isn't a person at all? How many macro/keypress-replayer/APIs have been written in the history of computers to allow a program to 'use' another program as if it were performing a rote task on behalf of someone? And how many actually work? The reason that Unix is so powerful is the command line program which can seamlessly work with other such programs. Whole sets of them can be scripted together. But X windows is slowly taking away those abilities in the interests of usability. It shouldn't have to be a choice.

Here's the rub. The 'user interface' of a program can depend on who the user is, what hardware it's running on, how they're using it, what the ambient light levels are, which phase the moon is in... And asking developers to build interfaces for all these environments is obviously ludicrous. What do we do?

My answer is to separate the interface from the program. This sounds simplistic, but it's a hell of a job. Each 'program' concentrates on providing the core functionality, and publishing a 'generic interface' (or Metaface) on which other interfaces are grafted. The interface which sits on top 're-interprets' the Metaface model as something appropriate.

A program may publish through it's metaface a 'named list of choices' for the 'user' to pick from at some point. On a desktop, this might be a pull-down menu. On a phone voice response system, this might be "Press one to cancel. Press two to begin processing. Press nine to speak to the operator" In the Quake interface, maybe it's running down a particular corridor. Or maybe no user is there, and it's a script which needs to retrieve the list and pick one. (This is a very simplistic example, sorry.)

Going further, this separation means that programs can be hidden or blended: A button on the screen may perform actions in two separate programs. You may have used a macro program to script together chains of actions in other programs, now invoked by a single command, or later, another macro. To get efficiency from computers, common tasks must be scripted, and most interfaces don't allow that.

Because of the separation, the interface might be running on a different machine from the program. X windows got this right. I should be able to use my palmpilot to access programs on my desktop, and when I do, the interface agent re-interprets the metaface to better fit the Pilot's smaller screen. You get this separation, because the metaface is basically a protocol for programs to share their 'choice space' with each other. Using a program is a process of navigating through the space of choices and states that the program allows you. If you make this explicit in a protocol, then that's the metaface.

Don't get hung up on the standard objections, which all revolve around our current bloatware apps (Spreadsheets, Wordprocessors, etc.) being impossible to generalize across so many different interfaces. Yes, I know. That's the point.

We're about to see an explosion of user interfaces, from Palmtops to Interactive Rooms. All the programs that I build as a coder are limited to one interface. Hell, they were limited to one architecture before Java arrived. Call me weird, but I don't like that. Most of the programs that get written do simple jobs, with very simple interfaces. And as more stuff moves into computers, we'll find ourselves using hundreds of little programs that are the equivalent of a light switch or a radio dial or a remote control, (maybe literally those functions) rather than a few 'Applications'. And that's where the metaface comes in, re-interpreting the basic function of the program (to switch between one of three 'states', maybe) as whatever works best on the device of the moment.

Oh yeah, this means that software can potentially last forever now, since the main reasons for throwing out the old seems to be that we don't like the way it looks anymore. That's stupid.

I've been working on the conceptual stages of the Metaface. Asking people what they want in their perfect interface (Since the Metaface must be able to support all of them.) Thinking about protocols and data structures and metaphors. I've written some bits of prototype code. And my experience is that, like most things of value, this is a lot harder than it seems. But when I'm done, it must be even simpler than the current way of building programs if it's ever going to get used. Ye gods.

It's maybe another year before all the concepts are nailed down and some sample code is available. I'm starting with a small Cathedral, but I'll eventually shift it to the Bazaar. My primary targets will be Linux and the PalmPilot, but It'll go on almost any machine with a little porting. It will be open source, GPL'ed, and eventually I'll need lots of people to wrapper around existing programs to bring them into the metaface. My first application will probably be a unix sysadmin/code developers framework (using the tools to build the tools). My first two interface agents will likely be a GUI 'Okudagram' style similar to my home page, and probably a funky sort of command line.

I promise only two things. It will be weird, and it will work.

Update December 8, 1999

Programming of a sort has begun. I've chosen Java as the development environment because of it's serialization abilities, which will be critical to the distributed nature of the system. I'm working on a precursor project; an XML editor for my palmpilot. This will let me play with building custom interfaces on PDA hardware, teach me java, and will force me to write as elegant and efficient a system as possible, because there's not enough room for anything else on a palmpilot. :-)

I really want to try to get an IR module for my computer, too. Then I can use the palmpilot to command my linux server, and it might lead to metaface programs like an MP3 'remote control', which I, for one, would find bloody useful.