Post OS UI

It's a mite drafty in here. This piece is intended to be a wild bit of conjecture. It's in part about what doesn't work about traditional graphical user interfaces, and in part about the huge mental debt that we owe them. It's also about getting over the CLI, without getting over the power of language and about getting out of the desktop without losing visual representation.

Agin the CLI?

The pure command line interface has become a rallying point for the computer culture purists. Because the power of the command line is obfuscated and icy and mysterious it transforms those who master it into wizards of a sort with black box powers. Once anyone wanting to use a computer for any task had to wrangle with the CLI, but now with it is the domain of the wizards, it is like their club, and you can only get in by knowing the magic words. A dangerous mythology has emerged from the CLI club, about polarization of interfaces. Operating systems are often viewed as either easy to use and therefore unstable and weak (GUI) or powerful and complex, but still with that most basic of interfaces, the command line. This is wrong, but the only OS that even challenges this notion in the slightest is NT. NT's limited success as an accepted high end system has only served to reinforce the dichotomous notion. This vision gave birth to the social taxonomy of the computer culture: programmers, admins, etc. vs. users. Many don't believe there is a point in uniting the interface spaces for all these people, some don't even think users deserve stable or powerful computing. They want to keep users far away from their club. They don't realize how much of their own sophistication they owe to the users and to GUIs.

UI vs. programmer's interface

User interface is about how a person with something to get done sits down and does it. There is a traditional perceived need for a static environment; if the OS behaves a certain way then it needs to behave that way tomorrow because the OS is the background for the work being done. The programmer's interface on the other hand needs to be dynamic. The programmers needs to be able to change the basic behaviors in pursuit of a new and hopefully tighter way to accomplish a certain (usually user's) tasks. As such programmers must effectively be users, at least if they want to be decent programmers. There isn't any need for users to be programmers persay but it often helps to be able to change or at least understand the OS environment the user is trying to accomplish their task in. Some programmers cum users get very frustrated when they encounter a UI with no programming component or one they don't understand or can reach easily. The experience can be so traumatic and emasculating that they rail on about hating the Mac for years afterwards.

For about ten years after DOS became hidden and Windows competed with Mac the difference between the programmer's and user's interface was a question of CLI v. GUI. Before the Mac, everyone was on the command line. Now with everything from WYSIWYG html editors and visual administrative tools to integrated development environments the programmer's and admin's interface is becoming at least part GUI. The user is expected to use more language skills to interact with their computer and their network than the Mac ever intended. The distinctions that Mac made so clear for years are blurred, even in the recent MacOS itself.

Lending GUI and CLI context

Much of our relationships to computers, especially systems like UNIX and communications protocols like email are handled linguistically/literately. In the beginning and for many years, all of it was. It was the innovation of the first creators of the GUI to handle certain simplistic tasks much as you would in physical space. If you wanted to move a sock from one drawer to the next, you picked up the sock and moved it. What made this a brilliant moment between humans and computers wasn't just the usability of the computer, it was as well the usability of our own brains. Suddenly we had more brain power to bring into the mix; We could use our linguistics and some of the parts of our minds designed for the visual environment. We weren't just using the machines better, we were using our own heads better, even allowing ourselves to use our imaginations more. While literacy is powerful, limiting ourselves to them is still a form of dumbing down what we ourselves bring to the equation, and locking out complete weak sequential/syntactical thinkers. The downside lay in how many tasks we replicated physical actions for, because suddenly we were doing everything ourselves. After all, what we wanted was to tell the computer what to do and have it do it In an intensely graphical environment some tasks can take a tediously long time to do, like finding all items with similar features and affecting some common change in them. Written language is powerful, and it anchors more ephemeral forms of thought to a firm foundation. it is the main place we build upon each other's work in technology. many believe that what was wrong with the Mac was that it tossed out the written language power of the CLI. In a way they did throw the baby out with the bathwater, but perhaps in a way we needed.

Where Mac went right

It has been observed that a community, online and off, will evolve inside of it's technological setup to the point where it is as functional as it wants to be regardless of what the original intension of the technological setup was. They will often find ways and kludge ways to communicate that the inventor(s) of the technology never even imagined. Similarly a userbase will stretch a UI to get it to do what they want invariably beyond the original vision of the interface's capabilities. This is not without consequences, for at the same time the UI being stretched changes the way the userbase is actually able to think about the technology, again though in ways the inventor probably didn't imagine. It is a psychological and developmental tool recursion. Tool and user stretch each other in a sort of symbiosis, and proceed down a path that is unpredictable and hard to return from.

By placing the bounds of the GUI on a community of innovative owners and users Apple managed to stretch the capabilities of the desktop metaphor far past anything that the PARC lab, or for that matter Apple could have imagined. It stretched well past the bounds of the metaphor, in fact. Macs were in some ways easier to use, and in some much harder. It often required a great deal of creative "tweaking" to make a Mac do what you wanted, whereas on a UNIX machine you would have written a script. The downside to mixing the programming and user interface is that whatever the systems becomes capable of the interface itself isn't forced to grow. UNIX is recommend on many levels by its long time endurance in a largely unchanged form at its base, but to be stuck there means that we aren't fundamentally doing anything more than we were 30 years ago. we are perhaps doing it faster and far more of it, but for innovations we have to look at the hardware and the networks. Nowadays the network is fairly magnificent, the hardware is fantastic, our minds have been ready and waiting for thousands of years... and only the software between us stands in the way.

The next neural real estate: lots of unsupported assertions {this title left in to annoy Shannon}

IBM has worked for years with voice recognition, yet never made the leap into incorporating voice into basic computer functionality. This is a great loss; many tasks or approaches to tasks would be magnificently handled by the verbal parts of our brains and make more sense than the visual answers we have now when dealing with an agent that is supposed to act for us, the computer. It makes more sense that, if I wanted someone to move a sock from one drawer to another that I would indicate what I wanted move and tell them. Right now our two ways of handling this task on a computer are to either write them a letter, or guide their hand in the action every step of the way. Verbally we create non sequential conditions on information that when well formed (which is the vast majority of the time) can only be taken one way by context. When we write, either to a computer or to each other we must put all of our elements in a particular order. We must do the jigsaw puzzle work before we hand over the picture, even when it can only fit together one way. Verbal processing is handled by a largely untapped brain power resource in the world of computers. In the verbal sphere we are often very creative, good at rapid file work and better at memorization, all of this power is lost to the computer.

This is an example of thinking about designing UI from both ends; the user and the computer. We have worked very hard to bend the computer to the user and abandoned the adaptability of people, which is our strong suit. It would be interesting to see how we use our brains in conjunction with how we use computers, and how that changes across interfaces.

Towards a new metaphor, but not there yet

What makes the next useful UI metaphor for using computers is a metaphor that is most like.... using a computer. This is an annoying tautology, but it is a view emerging from the fact that we have now two generations with early physical experience of using computers. Computer use means more to a child than the desktop it is modeled from. That doesn't mean we can stop using metaphors. Metaphors are in large part how we learn, especially in abstraction. They act as object oriented transfer of experience, where purely physical experience and interaction serve as human learning primitives. In the process of metaphor we take what we know on a meta level and extend it to the new experience in question, similarly to object orientation we process our experience back through the analogous layers of what we can already do until it reaches what we know on a concrete level, what we can touch, our building blocks: human learning primitives. The next metaphors for computer use can perhaps be built a little closer to the primitive level, more our of how we interact that what we are interacting with.

CLIs have long been our retarded little friends that do whatever we say, but only if we say it exactly right. GUIs are more intimidating; they get the first and last words in. They use language and visuals to speak to us as something closer to equals. We've kept them largely separate and tried to keep them both very non threatening. Our metaphors were as dry and workaday as you can get: our solopsist desktop, WIMP. The next metaphor which has already started to poke out a bit (especially from the net) is more organic. It changes and flows with us and engages us more completely. It exists and is even active when we aren't looking at it. It incorporates language, written and verbal and the virtual physicality that we have now without the GUI. As such, it incorporates more of us and has the opportunity to move with us and with the network as a whole, both other machines and people. Computers don't exist in vacuums anymore, nourished by long carefully drawn out strings of characters. It would be good to stop behaving as if this is the more powerful way to use them. This isn't just a new metaphor for the GUI, it's a new metaphor for computer use that the GUI and CLI and a verbal component could wrap around.

Distributed UI

We have effectively blurred the lines between software and hardware. While the "bits you can kick versus the bits you can't kick" works in many cases, it falls down when you look too closely at something as simple as how data is stored on a hard drive. Similarly, there is less and less of a distinction in the user's mind between local and remote. In both cases they are increasingly fuzzy concept, dichotomies fall apart- active desktops, software controlled power supplies. (try explaining that to a 13 year out who's just worked out which are the bits he can kick and which aren't) Interface should be something that can travel, that can exist in a fluid state both in the mind of the user and on the network. Portals have attempted to achieve this through the browsers, and sites like and etrade are already functioning as interface agents to a particular facet of our lives. Distributed interface agents are designed to be customized and evolve with us, designed to break in like a shoe and fit only us while fitting seamlessly to the rest of the net. They are accessible from any computer and any platform and are based on who we are. What would be interesting is to see a spec written for a distributed UI toolbase, that anything like paymybills or My Netscape could build themselves out of to integrate with an individual's UI agent.

This emphatically isn't the end of individual computers. We are talismatic people and we are increasingly buying computers on the basis of how well they fit our self image. We are not going to let go of the possesion of a computer, but we may learn to float the interface layer across the network. We don't need to see the OS layer like we once did, and projects like Java acknowledge that. It would be interesting to stop designing UI in terms of OS.