ryan.freebern.org

Developer and curmudgeon Hank Williams, whose opinions about the generally sorry state of computing generally jive with my own, is totally with me on the “context is key” idea. His conclusion?

The point is that almost every piece of information we collect has a trail to other bits of information. Right now we can’t see those trails. And so, our data spaces, be they our Gmail archives, or our hard drives, or our Delicious tags, etc., are really more like old attics with years of junk covered in thick dust. Modern software technology can and should do better.

When you sit down at a computer and engage in an activity, no matter what it is, it must inevitably fall into at least one (and often more) of these three categories:

• Production
• Creation
• Relaxation

The “real world” analogues to these categories are art, craft, and (for lack of a better word, since I don’t want to just reuse “relaxation”) entertainment. All life pursuits have elements of these categories. Art is driven by imagination. Craft implies more hard work and focus on technique. Entertainment is of psychological value, as a de-stressing agent, and can fuel both art and craft.

So, on your computer. Writing an email to your mom? Creation and relaxation. Looking up a recipe? All three. Doing your taxes? Production. Editing a home video? All three. Making graphics for the website your boss needs? Creation and production. Playing a videogame? Relaxation. Making weekend plans with a friend? Production and relaxation.

What does this mean for interaction design? How can programs understand what activity you’re engaging in and optimize its suitability for that activity? This gets back to context, which I’ve written about before and will write about again. If I’ve been chatting with a friend and then switch to my web browser and look up movie times, my computer should know that I’m in relaxation mode with a hint of the production, and make subtle changes to how it reacts to my activities: if I then start to look for someone’s email address, it should know to suggest friends, and preferably local ones, before coworkers. If I’ve been writing work-related code for a solid hour and then switch to my IM buddy list, it should know that I probably want to talk to my coworkers about something and, perhaps, enlarge their names in the list slightly. These are subtle touches, but easily doable, and if enough of them are consistently added across your entire computing platform, the overall enhancement to usability and simplicity could be tremendous.

Obviously this requires a level of computer “understanding” of your data and actions that hasn’t been reached yet, but there are strides in that direction. Social networking tools and community websites are making your relationship data available for programmatic access, so determining who’s a friend and who’s a coworker is becoming easier. By watching your calendar and work-related activities throughout each day, your computer can learn when you’re generally working, and take that into account when making schedule-related suggestions. By checking the location of your geotagged photos and matching the photo’s descriptive terms (tags, title, etc.) with other items in your data-profile, software can guess where certain people live or where certain activities take place.

This is all part of your computer being context-aware. Once the intercommunication between applications and (secure) exposure of your data to approved applications is comprehensive, your computer will be able to use its knowledge to make whatever aspect of computing you’re engaging in — creation, production, or relaxation — simpler, faster, and better.

I’m a big fan of Jef Raskin, the thinker behind the concept of the Humane Interface, which basically encourages a lot of the same stuff that I brought up in my Reimagining series: the computer should take human fallibility and imprecision into account at all times, and allow humans to do what humans do best while the computer handles the stuff that humans struggle with. His son Aza has followed in his footsteps, starting the company Humanized, and building the Enso software that attempts to incorporate many of Jef’s ideas, albeit in a sort of minimal way.

(Three of Humanized’s four principals were just hired by Mozilla, which probably means Humanized will shut down, but Mozilla’s interface will probably improve. Congratulations to everyone involved!)

To generate interest and press, Humanized recently developed and released Songza, a simple website that lets you search for music and play it in the browser. It makes use of several Humane principles: transparent zero-interaction “monolog” boxes, pie menus, and text labels instead of icons (mostly). This is great! It’s a simple and useful demonstration of how a Humane interface can be quickly and easily understood by people even when they’re not used to it, and it shows how nicely it works. In this sense, it’s a success.

I consider myself a “power user” of the web. When I find a website that performs some function I enjoy, I try to incorporate it into my life as seamlessly as possible. One thing I use often, for instance, is Firefox’s Smart Keywords feature, which lets me specify a keyword that I can use to quickly send a search to a specific website. I’ve set up dozens and dozens of these, so that finding the information I want is just a few keystrokes away: I can type “google jef raskin” to do a Google search, or “wp jef raskin” to look him up on Wikipedia, or “amazon jef raskin” to find his book on Amazon, or “dict humane” to find a definition, or “wu chicago, il” to find the weather at the Humanized offices. Once I’ve set these up and used them a few times, they become habit, and I barely have to think; looking up the information I want from a site I trust is utterly simple, and the computer has “learned” how to use its smarts to help me achieve my goals more quickly. This is the essence of a Humane interface: turning the user’s interaction with the interface into a benign habit that requires no thought.

To set up Smart Keywords, Firefox has created a simple process: you right-click on a form field, then select “Add a Keyword for this Search…” and then specify the keyword you want to use. It works on any standard web form, and Firefox figures out all the nitpicky details for you. Handy, no? Well, when I tried this with Songza, something went wrong: Firefox didn’t offer me the option of adding a keyword for the Songza search form. Viewing the source showed me the problem: the Songza search form, contrary to standard web design practices, doesn’t specify an action. The whole interface is handled by javascript and Flash: when you push the search button or press enter, the text you’ve entered isn’t sent to the server via HTTP, it’s grabbed by javascript and sent to the server using AJAX in the background. Hence, Firefox has no idea what’s going on, and can’t automate it for me, thereby denying me the expected simplicity of turning Songza into one of my habits.

To further aggravate things, there’s no reason why the site should be designed this way. It would be dead simple, from a programmer’s perspective, to make the form send a GET request back to the main page, and make the main page automatically handle it. Then, voilá, the form works as a standard web form, Smart Keywords work, and people can even link directly to search results. Add an auto-play option, and when I want to hear a song, all I have to do is type “songza perpetuum mobile” and, seconds later, it’ll be playing for me. (”Perpetuum Mobile” as performed by the Penguin Café Orchestra is a beautiful song. If I could provide a link here for you to listen to it directly on Songza, something like http://songza.com/perpetuum%20mobile, I would.)

It frustrates me that Humanized is trying so hard to effect a sea-change in how people interact with computers, but they (at least with Songza) aren’t trying to play nice with standard functionality at the same time. I understand that a paradigm shift often requires cracking a few eggs, so I don’t expect everything to go smoothly as they try to show how the Humane Interface is better than the current accepted computer UI, but I don’t think it’s wrong of me to say that their attempts should try to work with the current system as much as possible. People are going to be more impressed, and more enthusiastic, if your groundbreaking interface also does all the handy little “power user” things they expect, and provides as many avenues to habituation as possible.

Edit: You know what? I feel so strongly that this would improve Songza that, if any of the Humanized guys happen to read this post and want to take me up on it (and give me access to their code, of course), I’ll gladly do all the work necessary to add the above functionality to the site. How about it?

Back in March, I posted about wishing I could use Google Docs offline, since sometimes I’m away from the internet but still want to do some writing, and while I love Google Docs, it just doesn’t have an offline mode. Well, yesterday Google released a beta version of Google Gears, a browser extension that provides a very robust offline mode for web apps. They’ve already integrated it with Google Reader, allowing one to download all of his or her blog feeds and read them while offline, and I figure it’s only a matter of time now until they add offline capability to their other apps, including Docs.

Jason Kottke doesn’t think offline mode is that important, which is a view I see often coming from tech-industry people who live in big cities (Kottke is in Manhattan), because most large cities have an abundance of open wifi networks available. For those of us who live in more rural areas, though, finding yourself without a connection to the internet is a commonplace occurrence. Since moving to New Hampshire, we’ve had two long-term power outages (too long for our UPSes to handle), and more than once I’ve sat myself down in a public place only to discover that the wifi network I thought I could connect to was too weak, so I’d either have to leave my comfy spot and try to find a place with a better connection, or just attempt to work offline.

Anyway, I look forward to being able to use Docs offline once Google gets its butt in gear (har) and adds Gears support.

I’m tired of using systems that only do what I tell them to. It’s sort of like having an annoying roommate who does the minimum amount of household chores, and only when you bug him about helping out for a change. The capacity is there for my computer to be context-aware, to look for patterns and try to anticipate my needs. It can do this without being annoying–I don’t need another Clippy to help me compose business letters. I need a system that tries to learn my usage habits and then offers to change its behavior in unobtrusive ways to accommodate those habits. I need a computer that’s just a little bit smarter.

I’m sorry Dave, I’m afraid I can’t do that

People think that making our computers into “smarter” tools is a bad idea. They say they don’t want a system that does things they don’t ask it to–as if they have one of those right now. They say you can’t make a smart computer that will actually be smart in a useful, non-aggravating way.

Like the Dread Pirate Roberts says, nonsense. You’re only saying that because no-one ever has.

It’s easy to make a smarter computer. All you need is some simple algorithms that look for repetitive behavior, on any timescale, analyzes it to figure out what’s being done, and then offers to do it automatically. The problem isn’t figuring out how to do it, it’s causing the paradigm shift in software design that will make this sort of analysis a natural and expected part of any application. Smartness needs to be used regularly and shown to be so effective that users begin to demand it. Why use an app that makes you do extra work when this smart app makes everything simpler?

For example, the computer can pay attention to when I power it on: usually around 6:20 a.m. on weekdays and 8 a.m. on weekends. It can notice that on days that my calendar says I’m away from home, the start time is erratic, and on days when I have a morning appointment, I don’t turn it on until afterwards. Then it can ask if I would prefer it to power itself on automatically based on these observations, and if I say yes, most days my computer will be sitting waiting for me, powered up, when I want it to be.

The system can notice what I do with it on a regular basis. If I tend to start a certain set of programs immediately after booting, it can ask if I want it to start those programs automatically after booting, and arrange their windows the way I arrange them. My web browser can notice what sites I usually go to at certain times of day and pre-cache parts of those sites to speed up their loading.

And on a smaller scale, if I’m going through a text document adding the same few characters to every line, the system can see what I’m doing after the first few lines and offer to do it for me, show me what it would do, and allow me to tweak that result if it’s not quite right.

Adding context

The more context the system has, the more it can respond to our needs. A computer with a video camera can tell when someone’s sitting down in front of it to use it, and spin up its hard drives in anticipation. A computer hooked to a weather station can adjust the estimated travel time for a trip if the current weather indicates road conditions are bad. A computer that knows when your alarm clock is set for can learn how soon after waking you tend to start it up, and get itself going for you by that time. A computer that pays attention to your calendar can have driving maps at the ready when you need to go somewhere you’ve never been before. If you want many more interesting ideas about context-awareness, read Bret Victor’s in-depth “Magic Ink” paper. It’s long, but well worth the read if you find this sort of stuff intriguing.

First thing in the morning, a “status report” would be great: something that summarizes useful stuff, like the weather forecast for today (detailed) and the next two days (brief), how many emails I have waiting, how many new items in my newsreader, any important news stories that broke overnight, and other customizable information based on my interests. It should read my calendar remind me of today’s scheduled items; if I’m traveling and have put my destination on the calendar, it should find the correct forecast for my destination. All this is available with a good portal website, but I’d want it to also integrate with the other devices in my life. It could query my DVR and find out what was recorded last night, what was not recorded that I would have liked, and what’s going to be recorded soon. It could find out if I missed any calls while my phone was off during the night, and show me the names (if available) and numbers of the calls, and say whether they left messages. Ideally, it could even query my car (wouldn’t a car interface like this be great?) and find out if there are any issues that need to be addressed. And so on.

Wrapping things up

I don’t think I’m asking for much. I want a computer that is stable enough to survive hardware failures and able to notify me when those failures need to be dealt with, usable enough that I can be very productive without needing to simultaneously have two hands on my keyboard and one on my mouse, simple enough that taking it apart and fixing items is a snap, and smart enough that it anticipates my needs and provides the information and behavior I want before I even realize I want it.

It sounds like a pipe dream, but I don’t think the stuff I’ve asked for in these five articles are out of reach, either from an engineer’s, a programmer’s, or a customer’s standpoint. With effort in the right directions, I believe all of this can be accomplished, and I don’t even think it would take that long once the right people set their minds to it.

I’m one of those people. As a computer programmer, I can start doing my part by attempting to write smart software that is context-aware and tries to learn patterns and anticipate needs. I’m just a small part, but if everyone does their part, it won’t be long before we have stable, usable, simple, smart computers that are more fully extensions of our lives than just dumb tools.

(This post is the fifth and final part of my five-part post series “Reimagining the PC.” You might like to start back at the beginning.)

If people in general were truly good at remembering tiny details, we’d never lose track of our car keys or the TV remote, and we’d always remember what time we scheduled that doctor’s appointment for and the date of our sister-in-law’s birthday. Thing is, we’re not. Human brains always have trouble with small details, and we constantly have to use memory tricks and the like to get something to stick. Computers, on the other hand, are great with details. Their whole point is for them to be able to keep track of billions and billions of bits of information and manipulate them for us. Why, then, do current filesystems require us to keep track of lots of fiddly information?

The Filesystem is a Robot Butler

Picture this: you wrote a paper by hand recently about chimpanzee mating habits and you put it somewhere in your house. A while later, you want to fetch that paper again, and thankfully, you have a robot butler to do the fetching for you, but first you need to tell the robot butler how to find the document. If the robot butler is like the current computer filesystem, you’d have to say “Robot Butler, bring me the document entitled “Hey Good Ooking” that’s in the yellow folder in the center pile on the top shelf of the second shelving unit on the western wall of the small room downstairs.” However, if your Robot Butler was designed for maximum usability, you’d just have to say “Robot Butler, bring me that thing I wrote about chimps,” and the Robot Butler would know just what you were talking about.

I dunno about you, but I’d rather have that second type of Robot Butler. Current computer filesystems are designed to be efficient for the system, and for programmers, to use. Their tree structure is logical and easy for simple algorithms to parse and build. However, to a human, trees like that can become unwieldy quickly. When I want to access something and I can’t remember if it’s in /bin, /sbin, /usr/bin, /usr/sbin, /usr/local/bin, /usr/local/sbin, or /usr/X11R6/bin, that’s a problem. People don’t remember which branches of trees to follow to get to the fruit they’re looking for, they just look up and grab the first fruit they see. A filesystem should allow us to specify what we’re looking for based on metadata–that is, easily-remembered contextual information about the thing we’re looking for. When I want to open that paper I talked about above, I don’t care where in my filesystem tree it’s located. I just want to say “open the document I wrote a few days ago about chimps” and have it appear before me. “Tagging,” which is all the rage on the web these days, is a useful and simple type of metadata that makes categorizing and finding information quicker.

A Humanized Filesystem

To solve this problem, we need a database filesystem designed primarily for human use. It needs to keep track of all the metadata it can, things like when the file was created, who created it, what type of file it is, and keywords it can extract from the file, as well as allowing us to specify our own metadata for it. Files should be associated into projects or packages for easy access. When we feel the need to view our creations, they should be grouped by default into projects and ordered by when we last worked on them, so that our current projects are the first things we see, and finding something we worked on last week is just a matter of scrolling back along the timeline a little ways.

A filesystem like this would require us to ditch the familiar but frustrating “open file” dialog that we’ve all become so used to. Opening a file will no longer be an exercise in digging through tree branches. Instead, the system will just need to prompt us for metadata. The new “open file” dialog will present us with a sensible selection of contextually relevant projects (recent ones at the top of the list, of course), and ask us to type some keywords. If we need to narrow things down further, we can select a timeframe or a filetype for the file we’re looking for.

Efficiency through Organization

Furthermore, we don’t expect one program to handle all our different filetypes for us, so why do we expect one filesystem to be the right choice for every type of file? I visualize four distinct filesystems on a computer: two for the system to use, two for the user.

For the system:

• Application filesystem: small blocks, organized to keep each application’s files clustered. All application settings, etc. stored in the AppFS. Programs bundled into packages so that uninstalling is as simple as deleting the package, and all settings go with it. Shared libraries are also stored in the AppFS.
• Cache filesystem: small blocks, used for high-traffic things like cached web files and temporary files. Transient user-specific application data, basically. When the CacheFS is close to full, the oldest stuff begins getting auto-expired, but until then it’s easily and quickly recalled.

For the user:

• Document filesystem: small blocks, designed to store user’s documents: letters, stories, papers, memos, etc.
• Media filesystem: large blocks, designed to store audio, video, and imagery. A notable difference in this filesystem could be the generation of psychoacoustic and psychovisual metadata for each file, to help keep track of media based on what it looks or sounds like instead of its exact data.

Of course, these different filesystems would be largely transparent to the end user. They wouldn’t need to know or care which filesystem is used to store a specific piece of data, and the operating system and applications should be designed to make it a non-issue. The organization of data among the filesystems is only there to make the system more efficient in regards to drive space and more sensible for programmers and software designers. Additionally, fully encapsulating applications into packages in the AppFS will keep cruft from building up in the system, and restricting most user activity to the DocFS and the MediaFS will help maintain software stability.

In the next and final installment of this series, I will explore how the system can proactively become more than just a glorified calculator by sensing and incorporating context in its algorithms.

(This post is the fourth part of my five-part post series “Reimagining the PC.” You might like to start back at the beginning.)

What’s the ideal way to tell our computers what we want to do? Basically, we need to communicate two types of data: symbols (text, numbers, etc.) and kinetics (for lack of a better term–moving, clicking, dragging, etc.). Ideally, all we’d have to do is think about what we want done, and the computer would do it. Sadly, while progress is being made in the direction of a neural interface, I can’t imagine a general-purpose one succeeding in the market for at least another decade. So, at least for the time being, we need to focus on improving the current physical interface that allows us to use our hands to do the input.

The keyboard is a fantastic invention: an arrangement of buttons designed to let a person type any word or string of symbols they choose. However, the QWERTY layout (it is often said) was designed to slow typewriter typists down, so that the typebars wouldn’t jam. This is obviously not a concern with modern keyboards, but do we ever see any serious attempts to correct the layout and increase typing speed and productivity? Dvorak has sadly never caught on. And worrying about the layout doesn’t even touch on the fact that, with the addition of the ubiquitous computer mouse, the typical computer interface is optimal for a human being with three hands.

The mouse is a stopgap measure. Originally created to act as a sort of finger-proxy, a way to translate the intuitive human ability to point, push, drag, and tap with the fingers onto non-sensitive screens, it could be entirely superfluous now that touch-sensitive screens are both available and relatively inexpensive. But we’re stuck in our rut, and we don’t want to give up our three-handed interface, so we continue using a system that would be perfect for a mutant but requires wasted effort for most of us.

What to do?

Let’s face it: half-assed measures won’t cut it. If people have the option of sticking with the familiar suboptimal interface, they will. The redesigned computer shouldn’t give people this option. Its redesign must be so compelling, so obviously superior, that people will be willing to make the leap from the comfortable to the new. We need a powerful, intuitive new interface that eliminates the three-hand problem while still allowing us to do everything we already do and more.

Lots of research is being done into new input interfaces for PDAs and mobile phones and small-sized tablet PCs, but very little time and effort is being spent on regular old desktop or laptop input interfaces. I’ve spent hours looking into one-handed keyboards like the Matias Half Keyboard, the Frogpad, and the Twiddler, but they all suffer from one notable problem: typing anything other than regular English text is very difficult, so programmers like me will experience significant slowdown, which can be a stumbling block to staying in the creative zone. I’ve checked out on-screen writing software like Quikwriting and Dasher, but while these would be great for mobile phones or PDAs, they’re far too slow for regular use.

The makers of the Frogpad have begun mentioning that they’re working on a Frogpad for programmers that makes typing punctuation and symbols easier, but until that comes out, I think we’re effectively stuck with a two handed keyboard. So what can we do?

I recently took an informal poll of some friends to find out how they hit the spacebar on their keyboard while typing. Over 4/5ths of them answered that, like me, they always use the same thumb to type a space, leaving the other thumb always hanging there uselessly while they’re typing. An eye-tracking system uses cameras to track where on the screen you’re looking, and requires you to use something to input mouse clicks. Why not use that other, useless thumb? Instead of having a giant spacebar on your keyboard, just cut it down slightly and use the extra space as a “mouse key.” Then, to move the mouse pointer around the screen, you just have to look where you want it, and to click you just tap that key. Sure, you’d only have one button, but as Mac users will tell you, that’s not necessarily a problem.

The drawbacks to this method are that accurate eye-tracking hardware is expensive, cutting down on the spacebar’s size will be uncomfortable to many people (at least at first), and trying to control the mouse via eye-tracking is somewhat difficult, since eyes are prone to drifting and moving somewhat unsteadily. For more information on eye-tracking, see the Stanford HCI EyePoint project and the openEyes resources from Iowa State University. And finally, it leaves users with the suboptimal QWERTY keyboard layout, which most people won’t voluntarily abandon.

The big pro of this method is that it gives you the ability to handle positional input with your eyes as well as use both hands for typing on a full-size keyboard–a truly two-handed interface, as long as the tracking hardware and software can be made usably accurate.

But eye-tracking isn’t the only potential solution. Ever since Apple announced the iPhone, the web has been abuzz with talk of how multi-touch screens will revolutionize computers. Most touch-sensitive screens in the past have only been single-touch: they could only sense where you’re touching with one finger, and if you used more fingers, the interface would either ignore them or get confused. Multi-touch screens allow you to touch the screen with multiple fingers, manipulating objects from various points at the same time.

While people are oohing and aahing over Apple, most of them haven’t heard of an NYU researcher named Jefferson Han who has been working on an intuitive multi-touch interface for years. While his technology isn’t available outside his own lab yet, someday it will be. To get an idea of just how cool a well-designed multi-touch interface can be, try watching this video of Jeff demonstrating his interface at the TED Conference in 2006 or reading this in-depth FastCompany article (and be sure to watch the accompanying video for that, too).

Unfortunately, multi-touch screens don’t necessarily provide any sort of fantastic new method for text input. You can use both hands to manipulate objects on-screen, but when you want to type, you’ll be forced to take both hands off the screen and place them on a keyboard, or maybe just type on a simulated on-screen keyboard. Either way, you can’t effectively do both textual and kinetic input, so while multi-touch screens may provide a more intuitive and thorough way to interact with the computer kinetically, it still leaves us with the original problem.

I envision our redesigned computer using a combination of these two technologies. While typing, you can control the mouse with your eyes and a mouse-button on the keyboard. If you want to manipulate things on-screen more directly, you can reach up and do so via the multi-touch capability. This isn’t ideal, but I think it’s better than what we have now, and it’ll have to do until we get those direct neural interfaces up and running.

Next time, I’ll explore how the core of the computer’s operating system can be better-designed to support a human way of thinking.

(This post is the third part of my five-part post series “Reimagining the PC.” You might like to start back at the beginning.)

A lot of the current research and development work on computer usability focuses on software: making it more intuitive, more contextually aware, and more powerful. I contend that this work should be secondary to making hardware support usability. The best-designed piece of software in the world is useless if the hardware it’s running on isn’t designed to keep it usable.

What does this mean? It means that hardware should be designed so that the user can totally ignore it and spend all their time thinking about their goals. The computer is a tool, and just like any tool, it works best when the user barely has to think about it. A hammer acts as an extension to a person’s natural arm motions; they hardly ever worry about the hammer itself, but rather about the nail they’re trying to hit.

Unfortunately, current computer hardware requires the user to think about it fairly often. Computers are great when things are running the way we expect them to, but as soon as something goes wrong–a power outage, a drive failure–the problems with the hardware totally overshadow any usability concerns with the software. Unless we solve the hardware usability issues, all the well-designed software in the world won’t make our lives truly easier.

Points of failure

I have identified six points of failure–that is, areas where current hardware falls short and can be drastically improved, thus making the hardware more usable and better able to support the user’s goals.

Power failure

If you’re using a traditional desktop computer system and you don’t have it plugged into a UPS, as soon as the power blinks or goes out entirely, say goodbye to whatever you’re working on. Software usability doesn’t matter one bit if you can lose your data and potentially corrupt your system in an instant when the power goes out. If computer power supply units included a strong surge suppressor and incorporated a small battery pack, data corruption could be stemmed and unexpected hard shutdowns could be avoided. The battery pack doesn’t need to be very powerful–just enough power to provide time for a clean save-and-shutdown is really necessary. Personally, I replaced our desktop systems with laptops a year ago and haven’t looked back since. Even in our current house in rural New Hampshire, where the power blinks every few days, we have no problems.

Power consumption

As power costs continue to rise and worries about global climate change become more widespread, concerns about power usage in the home are growing. All computers should be designed to be as frugal with power as possible. This means designing parts that put themselves in a low-power sleep mode when not needed and not including high-level power-hungry components like cutting-edge video cards on systems that don’t need them.

Additionally, it may be wise to investigate technologies to allow the system to generate its own power. Paneling exposed surfaces with solar panels may be prohibitively expensive now, but might not be in the future. Adding kinetic power generators to all keyboard keys (as detailed in this New York Times article and this patent) would convert the energy of the user’s keypresses into power for the system. Even if this only generates a few watts per day, Forrester Research estimates there will be 1.3 billion computers in use worldwide by 2010. That’s a lot of power saved.

Natural failure

Despite our best efforts, we just can’t seem to make computer parts that are infinitely stable and last forever. Surprise, surprise. At some point, anyone who uses a computer regularly has undoubtedly encountered some sort of hardware failure, whether it’s corrupted RAM, a dead hard disk, or a video card on the fritz. While companies will undoubtedly do their best to eliminate these problems, they’ll never completely go away. So what can we do to alleviate the problems?

Well, think about the concept of a RAID. The idea is that by using multiple hard disks, if one of them fails, your data is still safe, and your computer doesn’t totally flip out. Why not apply this concept to other areas of hardware? I propose the development of a hardware architecture that allows any system to have at least two of each type of major hardware subsystem: two video cards, two sets of RAM, two CPUs, etc. Included in this architecture should be the capacity for a smooth failover, i.e. as soon as a component fails, the system switches to the secondary component. While this isn’t entirely practical for some parts–you can’t really have a secondary motherboard, for instance–for many common points of failure it could, potentially, alleviate the problem.

Hardware RAID should also be a standard feature in every system. Any computer built should have at least two hard drives, one a straightforward backup of the other. Drive failure will become less and less catastrophic as more and more of our productive work moves online, but hard drives won’t ever really go away.

Diagnostics

Right now, computers are largely non-self-aware. When something goes wrong, the system continues blithely on, generally unable to even detect that something’s not right, much less figure out what it is. My theoretical new architecture must include, along with smooth failover to redundant hardware components, a thorough diagnostics and reporting system that can detect a problem, figure out what the problem is and how to fix it. hardware testing modules should be abundant and take cues from the software; checks can be triggered if there is a sudden unexplained change in the computer’s usage or memory load, or if a particular instruction or procedure fails unexpectedly.

Beyond merely detecting and identifying problems, the system should have a basic idea of how they can be fixed. If a hardware component fails, after the failover occurs the user should be alerted, and the specific details of the hardware that needs to be replaced should be noted. Ideally, the data provided should be enough that the user could simply print out the notification, take it to their local Best Buy, and walk out in five minutes with a compatible replacement part. Software could even detect these alerts and allow the user to automatically order replacements to be shipped to them. For less tech-savvy users, the computer could be set up to immediately notify a local computer repair center of the user’s needs, and the center could then call the user to schedule a time for the repair to take place.

Startup speed

Computers are starting more and more quickly, but it’s still a few minutes between turning on your system and actually being able to use it. Windows Vista has made some strides in the right direction here with their ReadyDrive technology: placing commonly-used but infrequently-changed core system files on a high-speed Flash NAND memory chip so that they can be read and executed more quickly. I’d propose taking this a step further, however, and connecting the NAND chip directly to the motherboard instead of on the SATA bus. Much like other parts, this NAND chip should have at least one redundant backup–here it’s even more important, since NAND chips are proven to have a finite lifespan, and failure is assured after some number of read/write cycles.

Security

As we become more and more connected in our daily lives, security in turn grows in importance in our lives. Today’s computers are largely insecure; even if a hacker can’t get in via typical attack routes, the various LEDs and electromagnetic radiations from the system are highly vulnerable to forms of Van Eck phreaking. I propose using shielded cables and components wherever possible, making sure that LEDs don’t flicker in ways that expose data (see this paper on “Optical TEMPEST” (PDF link), and scrambling video signals. While this all may sound paranoid, the countermeasures would be fairly simple to put in place and would help protect users against some possible attack routes. Even if scammers and identity thieves can be foiled in their remote work, that doesn’t mean they wouldn’t adopt local attack methods eventually as well.

Many laptops are already incorporating fingerprint scanners into their security systems. I think these should become standard, and a fingerprint scan should be requested anytime a sensitive operation is being performed or personal data is exposed.

Other hardware optimizations

When you open up a computer case, you’re presented with a bewildering tangle of cables and cords, all stretching this way and that, and parts plugged into each other willy-nilly. Even if your system has told you it needs its video card replaced, unless you’re already pretty savvy, it’s not easy to tell what the video card is. I suggest creating a standardized color-coding system, so that different standard computer parts use different colored plastic mounts. Instead of trying to slide a skinny circuit board into a narrow slot, why not design it to fit together more like a Lego brick, with an easily-accessible lock-lever to make sure it’s in place? And if a particular part needs a particular cable, the cable should also be color-coded to match the part. In addition to colors, all parts should have their role printed on them in large block letters (VIDEO, AUDIO, MEMORY, etc.), as well as a standardized symbol representing the role.

All cables should be rounded. Ribbon cables are incredibly difficult to work with. Additionally, the internal layout of a computer should be standardized to decrease cable-tangles: if we position the SATA connectors on the motherboard as close as possible to where the hard drives will go, we don’t need to worry about whether the cables will reach.

The end result

If all of these suggestions can be fully and robustly implemented, the resulting computer system will address all of the above issues. When the system is powered on, the time between the user pressing the power button and being able to use their software will be minimal, like turning on any appliance. If the power is cut, the system will continue running from its battery as long as possible, and then shut down cleanly. Battery life will be increased, and energy bills reduced, by using low-power components that incorporate energy-saving logic. The system itself will deny access to malicious hackers from a hardware standpoint, providing as much security as it can. If a part fails, the entire system won’t become unpredictable or useless; instead, it will smoothly recover by switching to its standby part. The system will notice the failure, explain it to the user, and suggest a course of action to remedy it. If the user needs to open the computer up to implement a suggested remedy, the physical hardware of the computer will be easy to understand and work with. This is stable, usable, simple hardware.

In the next entry, I’ll discuss how the computer’s hardware interface–that is, the parts that the user sees, touches, and interacts with–can be improved to support my usability goals.

(This post is the second part of my five-part post series “Reimagining the PC.” You might like to start back at the beginning.)

Since the advent of the commoditized personal computer in the mid-1970s (with the release of the MITS Altair 8800), things haven’t really changed much. Sure, computers have become significantly smaller and faster, and the number of things we can do with them has ballooned to the point where many of us can’t, or don’t want to, imagine life without them. But when you look at the nitty-gritty details of computer usability design, both the hardware and the software, it’s still largely based on assumptions made by a bunch of scientists who were flying by the seats of their pants decades ago, just making things up as they went along. Things don’t change, because we, as a global society, are stuck in familiar ruts. I contend that these ruts are not just suboptimal, they’re actively deleterious to our culture.

Here we are, brains the size of planets, and yet we’re using flaky computers that sort of do some of what we want most of the time. They require constant attention to keep them running smoothly, as if they’re made of sticks and twine rather than solid mechanical parts. We each spend countless hours fixing problems, upgrading, configuring, maintaining our systems instead of just using them. Throughout the entire computer-using world, that’s an unimaginable amount of potential productivity, education, enlightenment, or entertainment time lost to frustrating and annoying endeavors. And it’s even worse if you’re using a Microsoft OS!

How can you tell we’re stuck in ruts? Just look at the vestigial anachronisms that abound in the design of computers. When Microsoft releases a new version of Windows and the most apparent difference is that the windows are shiny and partially transparent, you know we’re not even attempting to seriously innovate beyond the WIMP GUI developed by Xerox in 1973. This sort of “upgrade” is like putting lipstick on a cow. Sure, the end product is superficially better, but the starting point wasn’t all that great to begin with.

Scientists and engineers have done hundreds of studies and spent millions of hours working on improving computer usability, but very little has actually been done. If we’re going to truly move into the next age of computer development, we have to be willing to take a giant leap in how we design our computers, including operating systems and software, from the ground up. This is what I want to explore.

Why does the PC need to be reimagined?

While computers have addressed many of our daily needs and have simplified many tasks, I believe they do so despite their design, not because of it. People are constantly fighting their computers, and that detracts from the potential of a computer as a tool to enhance life. Computers fall short in three major areas: stability, usability, and simplicity.

Stability: Computers are notoriously temperamental. The instant a single part fails, the rest of the system becomes frustrating and unpredictable at best, unusable at worst. Software usability only matters if the underlying platform can be trusted to be stable. My proposed redesign should correct this behavior, so that when something fails, the system smoothly and efficiently corrects for it, and gets it taken care of quickly.

Usability: Computers work in a way orthogonal to human brains–they’re excellent at the precise, mundane tasks that humans find difficult, like arithmetic and remembering data. Humans, on the other hand, are good at finding general patterns, making guesses and predictions based on observations, and generally being imprecise. Unfortunately, many of the ways computers are designed don’t take this fully into account, and still require humans to worry about precision, whether it’s accurately remembering a long file path or URL or aiming a pointer at a 16-by-16 pixel square to close a window. My proposed changes should allow humans and computers to each focus on what they excel at.

Simplicity: Computers are designed to be a tool, and the main purpose of any good tool is to simplify a task. Unfortunately, due to the way computers are created, the task is constantly redefined by competing groups with their own financial interests in mind. For instance, my laptop has 11 different types of ports in it, each designed to take a different plug. Computers (and this includes peripherals) need to simplify, so that when I want to plug something in, I don’t have to know the acronym used to describe the plug type and hunt through the myriad holes in the sides of my computer to find the right one.

What are my goals here?

I don’t think for a moment that my ideas and recommendations written here are going to, by themselves, jumpstart a revolution in computer usability design. I do hope, however, that by laying out my thoughts on all of these issues as clearly as possible and exploring the various problems and solutions, that I can start a discussion that might, at some point, lead to people making changes for the better. My goal is simply to highlight the problems that we all face (perhaps even unknowingly) but consider “just how computers work,” make it clear why these problems shouldn’t exist and can be fixed, and provide outlines for potential solutions.

I’m not an expert in computer hardware design by any means. My degree is in computer science, not engineering, and what I know I only know because I’ve spent two decades using, building, maintaining, and reading and thinking about computers. I’m open to hearing suggestions and corrections here as I write more on this topic; if you have any particularly good insights, I’ll gladly consider them and try to work them into my thoughts, so please, feel free to speak your mind. And just to make things clear: by “usability design,” I’m talking about the ways the design of the computer affects the way we use it.

In my next post, I’ll vivisect the beast and take at look at its innards, to see what could be designed a little more intelligently.

The reason I haven’t been posting for the past two weeks is that I’ve been working on a five-part series of posts about computer usability, just trying to collect all my thoughts in all areas of this topic and get them written down and perhaps start a discussion or two. The posts are almost complete, and starting tomorrow, I’ll be posting them one per day for the whole week. They’re fairly technical in nature but I think the ideas I’ve presented will be understandable to anyone conversant in computer usage, not just people interested in usability and design. If you’re at all interested, I think these will make for good reading.

So tune in tomorrow for part one of my series “Reimagining the PC.” I hope you enjoy it!

I do all my writing in Google Docs these days, and I love it. It’s simple and straightforward — I can write my stories, and it saves them for me and helps me organize them, and that’s it. It doesn’t have tons of fancy bells and whistles that I don’t need and it lets me fit a whole lot of text on the screen instead of cluttering it up with toolbars and rulers and stuff. And nicest of all, no matter where I am, if I can get to the internet I can work on my writing.

The problem is that when my internet connection goes down, like it did today, I can’t access any of my work. There was a problem with our cable service for about three hours this afternoon, and I sat here stewing, thinking “What can I do to pass the time until it’s fixed? Oh, I know. I’ll do some writing!” And then I realized my fallacy.

There is evidence that Google is planning on making an offline version of Docs, but right now it looks like it requires running the code on a local webserver installation, which is not optimal. Come on! It’s almost entirely javascript already — why not make use of the nicely-polished, awesome offline storage solution dojo.storage? It uses one of any number of available offline storage providers (a fancy name for “things on your computer that let your browser save stuff to disk”) to allow you to store data locally, and lets you sync the local and remote copies when you do have internet access. There are already demos showing that it works safely. Google really needs to take advantage of this neat thing, to make Docs available even when my network connection isn’t.

I briefly pondered trying to integrate Greasemonkey and dojo.storage to forcibly add this feature to Docs, but then realized that first, it would take way too much effort to both decipher Google’s code and learn dojo.storage, and second, I don’t have the time for that sort of stuff.

I installed this WordPress OpenID plugin this morning and played around with it a little. While the installation was fairly smooth, I couldn’t manage to get it to work in what I considered a sensible fashion. I’m sure if I spent an hour or so fiddling with it I could figure it out, but to me that means the plugin needs more work. Fiddling shouldn’t be required.

The first problem is that while I could make the OpenID login form appear above the comment box on a post, if I typed my OpenID URL and a comment and hit the submit button, it would log me in but bring me back to the (now empty) comment form, and my comment would be nowhere to be seen. If I’m given a login box and a comment box, it ought to perform both actions.

Second, once I had logged in with my OpenID identity, the “Logged in as” text that appeared above the comment form was ugly and I couldn’t easily figure out how to style it. It would be nice if the plugin options included text boxes that let me directly enter the styles for the various elements that it adds to my pages.

Third, and this is more a complaint about the WordPress architecture, I don’t like that my administrator login and a low-level commenter’s profile page both have the same URL and look nearly the same. I think the commenter’s profile page should be a totally separate file that I can lay out and style however I like.

I’d love to enable OpenID support on my blog, but these issues (especially the first) are deterring me.