If you’re a guy, you’re probably aware of “splash-back”, which is just an unfortunate by-product of peeing in a urinal. If you’ve never heard of splash-back, then let me assure you, it’s exactly what it sounds like. But leave it to human factors psychologists to devise a solution.

What do you think men do when they stand there and pee? What do you think they think about? Well, if you think world problems are solved at those wall-mounted, porcelain receptacles, think again. Most men seem to focus on aiming their streams. Yes ladies, it’s true. Whether we admit it or not, we aren’t doing much more than playing “First One to Erode the Urinal Cake” or pretending we are Chief Fireman Baker, a gruff loaner with a heart of gold who also happens to be Urinal Town’s only hope to quell a fire that threatens to decimate the local orphanage.

So what do human factors have to do with splash-back? Well plenty actually. Some scientists got together and found the optimal area to pee on. An area that saw the least amount of splash-back. Once they found that area, they would need to mark it. Basically, they would need to get all the men to aim their stream at that one spot. How to do that ? Stick something there. By conducting some simple experiments, they found that men would aim their stream at specific “targets.” They chose a bee, but it could have been anything, really (others have used flies, bulls-eyes, and an assortment of quirky little targets). You can click on the thumbnail above to enlarge the image (sorry for the low quality shots, all I had was my iPhone).

So the next time you see a little bee on a urinal, and can’t help but a) wonder what it’s doing there, and b) why you have to aim for it, well, now you know (and it’s not there to reduce “spillage” as falsely reported by BoingBoing). Personally, I think it’s actually pretty cool to see something I read about in class, applied to the real world. These were taken on campus, and when I saw them, I was secretly proud of my academic institution for being so progressive.

reCAPTCHA is a free service that adds a magnanimous twist to the whole, “prove to me you’re human” paradigm of anti-spam technology. It was a novel idea back in the day, I’m sure, almost taking a page from the Turing Test. I can remember the first time I used one. I thought it was a great idea—very neat way of identifying humans from spambots. Then, new ones came out. More advanced ones. Some more difficult to use than others. Some downright annoying. Some did a better job than others. And for a time, things were good.

I have alway wondered whether some of the more difficult ones were made that way because spammers figured out ways to circumvent them, or if it was just overzealousness on the programmers part—trying to make an anti-spam system that could never be beat. In any case, it looks like reCAPTCHA has really gone into overdrive.

I admit that I installed the service on my own site (and for most of my clients) primarily because it helps digitize books. I think that’s a terrific idea. I can’t tell you the wealth of information that exists in the scientific community, but most of which is still relegated to physical journal articles. I would much rather have a hardrive full of PDFs, than a closet full of boxes. The trees we save not withstanding, it also helps make knowledge dissemination much easier and fluid. A win-win in my book. I am all for the spread of knowledge, and if I can protect myself and my clients from spam and promote the distribution of information, then just show me where to sign up.

But it looks like we hit a chink in the chain. In all honesty, reCAPTCHA “challenges” have never been the easiest. Every now and again, I’d get one that was perhaps a little challenging; something that didn’t just pop out at you. Then they added “blotches” behind the words, which has inevitably made their system far less attractive. Here you can see just how difficult some can be. Now I didn’t cherry pick these in an entire afternoon. This list was taken from around 15-20 reCAPTCHA challenges. That means a considerably high number of challenges are far too difficult, while some are just downright impossible (the last one eludes me completely, I want to say the first sequence is “im”?).

For a native English speaker, most of the challenges can probably be deciphered with minimal effort, despite the new blotches. Being familiar with a language affords you the advantage of knowing what letters you are likely to expect. In fact, research into cognition and perception have illuminated researchers on how the human brain processes letters. Wchih is why rideang steneces lkie this, aern’t all taht hrad. If we see the letters B-E-A… most likely we are going to presuppose that either a T or an N or an R may likely follow. If we see something that looks like a vowel, or an H, we would be required to expend a little bit more cognitive power in deciphering the word. This is also the case when reading full sentences. We come to expect certain words, and if they don’t follow (through typos or just bad writing), it becomes difficult to read. It’s like having to stop at every house to see if it’s the correct address. Just not productive.

However, the world is a large one. The internet has been breaking down the walls between countries for some time now, and while I’m sure the vast majority of people that frequent my sites are indeed fluent in English, they may not all be. Moreover, English may not be their primary language. If that’s the case, then they may not be as comfortable or as adept at decipher English text. Sure reCAPTCHA provides access to other languages, but as far as I can tell, it has no “multicultural” setting. It’s either English or German, but not both.

If it were a simple system that identified spambots, I would have removed it, but I am still wanting to digitize those books. Yet, I also care about my visitors and those of my client’s. And what’s more, I am also a usability freak. I don’t feel the current reCAPTCHA interface provides a clear enough “refresh” button to create new challenges. Moreover, I don’t think that’s an adequate solution. Forcing visitors to continually cycle through challenges until they find one they can accurately transcode doesn’t jive with productivity. I think it also asks too much of people. Let’s face it, people want to send you an email, not decipher a Sherlock Holmes mystery. I would like to make that process as easy and as noninvasive as possible. In an ideal world, they should be able to click a button and fire that email; all this spam protection should be well behind the scenes.

With the advent of social network and the blow up of blogs, the nuisance these kinds of devices elicit has increased exponentially. Most blogs or forms require some form of human validation. Well, I for one, am getting really sick of these time consuming processes. I know I’m human. I feel like I’m in some awful universe that’s overrun with militant robots, forcing the remaining humans to constantly present their IDs wherever they go. If that’s the case, then it seems to me we have already lost the war on spam.

So let’s get back to the drawing board. Sure these types of anti-spam measures worked when the internet was a static place to visit. But it has matured. It is full of dynamic content. Moreover, it has become a real communication platform. Information is exchanged readily and drives commerce to real relationships. Let’s bring down spam, but in a sensible manner that still respects the human behind that keyboard. After all, time is exceedingly precious.

The only thing remotely ridiculous about this project is the name, unless you count how ridiculously good the concept, presentation, and underlying thought behind this revolutionary way of viewing your articles and magazines, um, is.

The project, an amalgamate of Berg and Bonnier (who publishes Popular Science), is truly awe-inspiring and aims to take the current paradigm of hyperlinks and images to a whole new level. So much so that I had to blog it, being the techno-freak that I am. I would love to see a world that payed this much attention to detail. The Mag+ is downright elegant and just flat out beautiful. Gorgeous even—in both the design and delivery. It is a concept derived from people that no doubt have spent countless hours thinking about a thoroughbred way of bringing magazines into the 21st century. Hopefully companies that care about their readers will organize some elaborate meeting with the possibility of Thai food and drink.

Enough with the praise, I’ll let the video speak for itself. There is a drool warning attached to the clip, so slide those keyboards away from under your chin.

Read more about the Mag+ Project over at the Berg Blog.

MacRabbit (of CSSEdit fame) has loosed another version of their “vapourware turned legitimate program,” Espresso, unto the suspecting public. Version 1.1 expands on the “skeleton-like shell” of former iterations by adding several new features, a lot of polish, and some general refinements to the interface and operational program behaviour. Admittedly, I have given little time to this program in the past (yet I’ve always strangely wanted to like it, despite its many failings), as it proved to be quite buggy, and just too eclectic for my taste. However, this new iteration seems to tie a lot of loose ends together and is getting to be an attractive alternative to the already popular Coda. It generally feels a lot snappier and much more refined than previous versions. There are still some rough spots, but it’s certainly starting to come into its own. So I decided to give it a good, solid evening of testing.

So without further ado, let’s run through some of the most prolific components that grabbed my attention, for better or for worse.

The Navigator

The navigator, with its nested and collapsible tags, is something MacRabbit absolutely did right. Adapted from the popular CSSEdit, it really does make combing through your code quite less tedious. Working in unison with the code folding in the Text Editor (read below), it really does set itself apart from Coda in this respect (that regrettably behaves more like a text editor on steroids than a true, enhanced coding environment).

In addition, the tags are draggable, allowing a user to quickly reorganize the structure of the webpage in a matter of seconds. No longer does a designer have to grudgingly peruse their code. A quick scan, a few clicks, and the structure of the page unfolds before their eyes. This is something Espresso does exceptionally well and is a welcomed addition to any coders arsenal. Additionally, the structure and layout of the navigator are clear, intuitive, and well implemented.

The Text Editor

Code writing is pretty much standard in Espresso. It has all the goodies: Predictive code creation (called CodeSense), spellcheck (which needs to be tweaked as to stick to the text and not so much the code), colour formatting, and current line highlighting (which, like Coda, is implemented very poorly).

It also features code folding: The ability to collapse and expand blocks. This highly simple, yet powerful feature really does make coding a lot less manic. It greatly helps improve productivity by making things manageable. No longer does a coder have to rely on tabbing for organization. With code folding, collapsing and expanding blocks of code is a mouse click away, and makes managing lines upon lines effortless. This feature is a great addition to any web design program in my opinion and really does turn a program into a “true” coding platform, as opposed to an enhanced text editor. I’m a progressive person and see no reason why we have to continue writing code in basic document editors. We desperately need to drive innovation in this area, and I’m glad developers are starting to bounce around with various ways to improve efficiency.

The Sidebar

The workspace doesn’t actually provide tabs, but instead, merely lists items. Thus, the instruction to “drop or double-click files to open them in tabs here” seems somewhat misleading. We all know what tabs look like, yet when I propagate my workspace, I see nary a tab in sight. Either the directions need to be re-worded, or a true tabbing system needs to be implemented (I’d prefer the latter rather than the former). Or better yet, devise a system that can incorporate both listings and tabs, to circumvent the problems of “tab hell” (faced by their competitor, Coda).

Firstly, Espresso doesn’t support active scripting (php, server side includes, etc.) which is actually a pretty big failing if you typically code in something other than HTML/CSS. It took several version for Coda to implement and it’s still very buggy several iterations later. Hoping the guys over at MacRabbit not only provide similar functionality, but do a much better job of it.

Preview doesn’t denote what file a user is currently viewing. An entry in the workspace entitled Preview pops up; however, no clear identification is made between which file is actually being previewed. Moreover, each preview adds another listing under your workspace. In fact, Espresso really suffers from exploiting the sidebar with superfluous listings, or rather entries that perhaps should be presented to the user in other ways. Previews, for example, could be made visible by using an icon rather than a brand new entry in the workspace (similar to the “blue dot” that identifies when a file’s changes have not yet been saved). This would prove to be a much more logical and less intrusive way of handling the task.

Remove Server Settings from the sidebar. Considering the settings are made available using the standard right click (on the server of choice), the extra listing seems rather like an oversight or a bug than an actual, legitimate entry. System settings of any kind should not be mixed with concrete listings (such as user files or in this case, designated servers). Again, we have needless entries in the sidebar.

My biggest criticism of Espresso is certainly the haphazard way the sidebar has been implemented (this version is said to improve on previous versions, which actually frightens me to think what preceded it). A user can select an item from the files list and begin to modify its contents. Once a change is made, the respective file propagates into the workspace listing. I am, however, at a loss why this is the case. Would it not be easier to identify the file using an icon that its contents have been changed (which Espresso currently does) and leave it at that? What benefit does a user gain by propagating the workspace section (other than having newly modified files listed at the top of the sidebar)?

There is, however, one benefit from adopting a list view over a true tabbed system: It remains usable even under heavy file load. Coda’s traditional tabs quickly become irritating and cumbersome to use when multiple files are open. As the tabs compensate by incrementally getting smaller, they also become less and less functional. Organizing the files in a list does workaround this problem, albeit it does suffer from its own set of drawbacks (viz., an unintuitive feel). But ultimately, I am still left wondering why my files are moved up into a workspace? Navigating a list hierarchy doesn’t seem to be a problem, not enough to warrant such a quizzical approach to organizing currently modified files.

The sidebar is basic and tries to keep things simple, but often fails by inexplicably listing items whenever the program wants to communicate with the user. This implementation is either unintuitive to downright senseless. This area is by far the most crippling component of Espresso and is probably the area that needs the most refinement and attention. Sadly, it also draws away from all the things Espresso does so well. It also doesn’t help that the sidebar is probably the most interfaced component of the program, thus increasing its prevalence.

Find in Project (New Feature)

The Find in Project feature is done quite well and certainly deserves a notable mention. It is snappy and lists results using site structure, something that really helps identify location at but a glance. The Coda guys could learn something from this way of implementing find and replace. It is clean, intuitive, and feels quite snappy.

Conclusion

Espresso is becoming one to watch. If I was not already immersed in Coda, I may consider migrating, but at this point, it’s just too early to make the move. However, the new features in v1.1 really brings things together. It still needs work, mind you, and there exist elements that certainly need to be rethought entirely, but at least it’s progressing, and I’d say a solid contender (albeit it a little steeply priced) for anyone shopping around for a design program on the Mac OS X platform.

We’ll see if the updates steam along, or whether the project gets “shelved” again (from my understanding this program is maintained by students, which sadly means time is not usually a luxury). Time will tell. While it may fall short in its current asking price, it seems like the team is at least on the right track. Let’s hope they devote more time to getting this program up to snuff; choice is always a good thing.

I’m sure I haven’t covered everything Espresso has to offer, but it should give you a rough idea of what you can expect from this web development program. Hit up MacRabbit and have yourself a look. You have a 15 day trial should you wish to do your own testing.

Lukas Mathis recently wrote an article on realism in UI design. Will Shipley (of Delicious Software fame) also wrote an article on interaction design and heuristics. But both fail to cover the underpinnings of heuristics and the human mechanism—to truly get at the source of how the mind works and why design needs to be shaped in a different direction.

Understanding Heuristics

Firstly, the definition of heuristics taken from Wikipedia is less than satisfying. (A heuristic is “an adjective for experience-based techniques that help in problem solving, learning and discovery.” Is it me or is WP getting more and more difficult to read and digest? Do they even have editors?) Let us take to my second year cognition textbook (written by the most boring and lacklustre authors alive. I begrudgingly had to read this book from cover to cover, and it was nothing short of sheer agony let me tell you): “A heuristics is a strategy that is often, but not always, helpful in solving problems” (Reed., S. K. 2004. Cognition: Theory and applications, 6th Ed. Belmont, CA: Wadsworth.)

I think this definition will better serve our purposes, and is much clearer than the one provided on Wikipedia. But let me put it in simpler terms. A heuristic is analogous to being late for work. You wake up in a rush, deciding to forgo a shower, and choosing to grab a cereal bar instead of your traditional toast and coffee before running out the door. You make it to work on time, but you realize that you forgot your phone, and to lock your front door. You succeeded, but you did it cutting corners. Provided nothing detrimental happened, and all your stuff was still there when you got home, it would have proved a success. That is essentially what a heuristic allows you to do: Achieve your goal using tried and true shortcuts. They don’t always workout, but for the most part, the time and effort they save makes up for their less than pristine track record. It’s a trade-off. A process that tries to reach an outcome with the lowest possible denominator.

Before pressing on, let’s get a better understanding of what constitutes a heuristic and how they are formed. Way back, some few million years ago, human beings began to use tools, walk upright, and mould their environment to better suit their needs (thank you opposable thumb!). After generations, certain constants helped shape not only the way human beings interacted with their surroundings, but how their perceptual systems were being structured. This is the case with all organisms, for they adapt to their environment.

A cat has fur because that organism choose that particular phenotype (an observable component expressed throughout genetics) to handle some part of their habitat. That is not saying that fur was the only option, but it was a mutation that was accessible (an elephant, for example, doesn’t have the genetic capabilities to develop wings so it’s not an option should the environment call for them), and selected for by their sexual partners. Remember that evolution is a dualistic system, in that, random mutations lead to strange new abilities, but those mutations must be a) beneficial to the organism, and b) selected for by their mates. If they don’t pass on those traits to their offspring, then the benefits die with them.

Interestingly, a recently discovered cave fish has been shown to lack the “ability” to forget. Placing this fish in an empty tank with a small cylinder in the middle, saw the fish learn to avoid the object. However, after the object was removed, the fish never swam in that spot again. Scientist feel this is likely due to the environment of the fish. A cave is stagnant—there isn’t really much going on. So rather than expend energy to handle this extensive cognitive ability, it evolved without it. This fish a testament to the sheer awesomeness of evolutionary processes. I digress.

For humans, light always came from above (i.e., the sun), so we our visual system operates best under these conditions. Even the fear of spiders and heights are deeply rooted in human history (you tend to live longer if you don’t play with poisonous bugs and keep your ass firmly close to the ground). And my personal favourite: spontaneous food aversion. You ever eat something and within a few hours, start to feel nauseous? If that nausea turns into a violent illness, how likely are you to eat that meal again? Not very. It doesn’t matter if it’s the cause of your sickness. Your brain makes the connection without your active consent, and you develop an aversion to the substance. It varies in strength from person to person, but if you ate an egg salad sandwich and in a few hours, spent the rest of the night hugging a porcelain God, then I bet dollars to donuts you won’t be ordering it the next day for lunch, or the one after that.

Now it is important to note that heuristics don’t form overnight. They take generations, and the longer the stimulus has been present (and pervasive), the stronger these “rules” will become. After all, it makes sense to trust rules that nearly always return a favourable outcome. It also makes sense to put a “bypass conscious processing” proviso on these rules too, for the sake of rapid execution under minimal exertion. In fact, the most prolific heuristics (the ones there from the dawn of humanity) are so pervasive that they often replace (or at the very least, bypass) logic and critical thinking. They may sound like a detriment, but they play a crucial role in allowing us to parallel process oodles and oodles of information. Even those massive server farms having nothing on the human brain (all readers should give their lapels a soft tug).

Heuristics & Software Design

But classic computer programming has largely failed, because it failed to copy nature. Nothing in nature works 100% of the time, but it sure works well MOST of the time – and when it fails, well, you die and get replaced.

—Will Shipley

I’m afraid Will has all but lost me here. I’m imagining a bank machine that sometimes gives me money, while other times, it takes it from my account. I’m not sure what he’s driving at, but if a button doesn’t work 100% of the time, then I’d have to say that the coder is the one who’s going to get replaced. Admittedly I’m no coder, my formal training is psychology and philosophy, so maybe he’s talking about coding dynamics that are beyond my understanding. But I’m still trying to wrap my head around a program who’s code structure sometimes does this, and sometimes does that. I’m still not sure how that might work.

At any rate, in my opinion, he’s barking up the wrong tree (ouch, sorry for the cliche). It’s not the code that needs to improve, but the way it’s being applied. Code needs to be logical and its application too, needs to be logical. The problem, repeated for the upteenth time, is the coders themselves (sorry guys, as much as you hate to hear it, it’s true). Their superior understanding of code makes them volatile, often resulting in a convoluted and irritating program that general users find unusable (or not very enjoyable to use). This is precisely why scientists shouldn’t run the world. Or plumbers. Or engineers. What truly needs to change is the way coders perceive and ultimately conceptualize the their finished programs.

Usability pundits (Donald Norman, Alan Cooper, etc.) have all fingered the root of the problem a long time ago: A lack of understanding. Not in writing code, but of the human being. And this brings me back full circle to the actual issue at hand. Coders aren’t trained in heuristics, nor are they trained in the human machine. They have no idea what heuristics humans employ, why, how, or when. Take for example human memory. The average person can remember 7 +/-2 digits. That’s why North American phone numbers are 7 digits long (area codes don’t interfere because they are usually quite static, only having a few local ones to remember). When this tidbit of information leaked to the masses, coders retooled their programs. Every drop-down menu now had no more than 7 items. Every preference box had no more than 7 buttons. The problem? People don’t need to memorize drop-down menus, they are staring them in the face. Sadly, because coders aren’t experienced in psychological research, or fully understood the findings, they were inadvertently misapplied.

Good Design Through Metaphor: Tapping Into Heuristics

The use of metaphors are common practice. They work because a single metaphor (by definition) can serve many functions, in that, it is applicable across many instances.

Graphical user interfaces are typically full of symbols. Most graphical elements you see on your screen are meant to stand for ideas or concepts. The little house on your desktop isn’t a little house, it’s «home». The eye isn’t an actual eye, it means «look at the selected element». The cog isn’t a cog, it means «click me to see available commands».

—Lukas Mathis

Heuristics offer programmers a b-line straight to the soft, chewy centre of the human brain. It taps into knowledge that is already there, waiting to be put to use. This is the key to “intuitive” design. The human brain is already hardwired for a great number of things. By tapping into this current network, programmers can access streams that already provide well established knowledge regarding the function. And as mentioned above, this is best done through the use of metaphors. Things like folders, windows, buttons, and desktops. Even icons and labels work in this way. (But bear in mind, a metaphor is not a heuristic.) Do you see a trend? Human beings are cognitive misers. We don’t like to think about every little detail. We prefer automation. The shortest route travelled.

Admittedly, the best way to develop programs (or new technology) is to employ teams that have a wide breadth of expertise—from coding abilities to varying degrees of psych experience. When you design a tool for a human, you better damn well understand the human. Having experts on both the technology and the user will guarantee an exponentially better final product.

Anyone truly interested in crafting better programs (if nothing else) needs to read these three books:

1. Interaction Design: Beyond Human-Computer Interaction link

2. Emotional Design: Why We Love (or Hate) Everyday Things link

3. The Inmates Are Running the Asylum: Why High-Tech Products Drive Us Crazy and How to Restore the Sanity link

And if you are looking for an excellent read on the human mind and evolution, you must read these:

1. How the Mind Works link

2. The Selfish Gene link

“I think he picked me because of my motivational skills. Everyone always says they have to work a lot harder when I’m around.” —Homer Simpson

The first in a series of critical looks into the modern day personal computer.

Sit, Roll Over, Beg—Good Boy

Since the majority of us have had (at least) a good solid decade of steady computer use under our belts, we’ve learned to act and behave just like the nerdy programmers have trained us to act and behave behind that keyboard and mouse. We’ve learned to be patient when watching that infernal hour glass or spinning beach ball, to wait for the images to painfully load or generate thumbnails, and to quietly suppress our anger, and just mutter and clinch our mice in frustration when things don’t go our way, instead of throwing them at the nearest geek with a pocket protector (which used to be far too often).

Let me take a page from history: The QWERTY keyboard. It was designed back in the late 1800′s for one sole purpose: Slow down the typist. Back in those days, they had bulky typewriters that would jam if two keys were pressed simultaneously. So the brilliant minds at the time laid the keys in a sequence that would prevent jamming. How? By slowing down the typist. Conceived theoretical limits were an abysmal 20-30 words per minute. That’s more than you could do by hand, and it wouldn’t jam your instrument. Win, win in their book. Yet, after a century of use, humans have pushed those theoretical limits to a blistering 150 wpm. (Mrs. Barbara Blackburn of Salem, Oregon can maintain 150 wpm for 50 min (37,500 key strokes) and attains a speed of 170 wpm using the Dvorak Simplified Keyboard (DSK) system. Her top speed was recorded at 212 wpm. Source: Norris McWhirter, ed. (1985), The Guinness Book of World Records, 23rd US Ed., New York: Sterling Publishing Co., Inc.)

The point is, humans always find a way. They tend to push the limits of the system, regardless of whether it’s a good one or a bad one. As you can see, QWERTY was designed to be a bad one (obviously at the time, it was required, but word processors do not have such physical limitations). So when people tell you computers work pretty damn well, citing case after case of successful digital achievements, you can turn an eyebrow and wonder just how much the computer is doing and just how much the user is doing. After all, people have dug themselves mile long tunnels with nothing but a rusty spoon, but spoons are far from optimal digging devices. Good devices become extensions of the user. With the current state of operating systems, I’d be hard pressed to want to graph an HP HDX to my arm.

In closing, developers, engineers, and designers must always be improving and fine tuning. This applies to not only future products, but past products as well. It’s not enough to make a file manager some two decades ago, add feature after feature, and think it’s reached the pinnacle of operating prowess. And that brings me nicely to my next point: Creeping Featurism.

Say When!

“Its eyes should be telescopes! No, periscopes! No, microscopes! Can you come back to me?” —Milhouse Van Houten

If the toy company executive drilling the elementary school kids for suggestions had any sense, he’d make its eyes have all three, and add a few more for good measure. Creeping featurism. I was introduced to this term long ago in one of my very first ergonomic courses. If you’ve ever travelled to Korea (who’s marketing VPs would love to shove a USB slot into your dog if they could—make that two USB slots, one Firewire800 slot, and a SATAII slot) and have seen firsthand some of their electronics, you’d understand just how bad things have become. Even if you’ve used a modern operating system, you’ll too understand the quagmire we are in. As each new iteration is loosed on the public, it comes with the promise of more features, more bang for your buck, more, more, more.

When you set out to accomplish everything, sadly, you successfully accomplish nothing. That’s why you take your dry cleaning to a dry cleaner, your car to a mechanic, and your kid to a day care. Today’s operating systems are truly Goliath’s in their undertakings. Their designers have shoved so many useless and pointless services, features, and trivial tasks down our throats that the simple things become truly aggravating. Viewing images, watching different media types, cataloging music, and organizing and sorting emails are multiple-click nightmares. Tasks often require 10x the mouse clicks needed (time and motion studies guys—get those tasks simplified already).

The problem here is engineers don’t have any clue how to implement a function. They don’t know how people’s minds work, just how computers work. They don’t get trained in the cognitive, just the processor. So when they lay out a string of buttons, or organize the sequencing of tasks, it’s often rudimentary at best. That is not to say that logic doesn’t exist, but an intuitive interface requires more than structural coding logic—it requires the subtleties of social scientists, people that understand the human mechanism.

What if I told you the average person can only remember 7 +/- 2 items (and this is why North American phone numbers are 7 digits—when digits are “chunked”, that is separated into smaller sections, they can be easier to remember and can extend the magical number 7). Would you limit the number of items placed in a drop down menu? If you answered in the affirmative, then you’d be committing the mistake done by many programmers that have exploited those findings. However, they were (and you would be too) wrong in doing so. Primarily because a user doesn’t need to memorize the items in a drop down menu. They are there, right in front of them. This example illustrates the need to diversify development teams, to include cognitive psychologists trained in interaction design. We need to change the paradigm of handing over systems to technicians trained in C++, Java, and some C.

Let’s take an example: The Windows Vista Start Menu. Microsoft developers probably conducted focus groups, had meetings at nauseum, conducted their own usability testing, and most likely turned to their beta testers to ultimately help design this convoluted mess of an interface. I imagine users wanted everything centralized into this menu. John probably wanted the ability to pin programs, so they would be persistently displayed. Clara probably wanted her user icon on the menu, so she would definitively know she was logged into her account and not her son’s. Bill probably wanted the Start Menu to list only a handful of programs, because he was sick of trying to find what he wanted.

So the MS team decided to revamp the menu. What they did was add so many ridiculous changes and “features” to it, that it became terrifying to use. (Microsoft does have an official position defending the changes. I find it disturbing they have abandoned so much reason because of one usability finding. Recall the use of 7 +/-2? Perhaps tweaking the nested fly-outs would have been a better route, I wonder.) Selecting items from a list became a 3-click event that had a user flipping through their sea of programs in a concatenated box (those that ran high resolution monitors or could guide their mice with pixel perfect accuracy, were the real victims). Rather than providing alternate solutions for the user by refining existing elements, developers decided instead to add new ones. And because they added so many “features” to the new menu, it often confused general users. That is not to say that it could not be set-up in an efficient manner, but the default layout was atrocious. And the default layout is what most of your user base is going to use. Sadly, many users either do not know, or care enough to spend the time fixing your poor design, and nor should they. As I said before, computers need to work for you, not the other way around.

Now I have to admit that the execution is just as important as the concept, and MS may have pulled off a better design if they implemented the changes in a much more elegant and refined manner, but let’s not beat a dead horse. The point is, marketing doesn’t make UIs usable. Adding feature after feature is not good design, it’s only good marketing.

The Future Holds

I would be remiss if this series was nothing but finger wagging and time outs. In upcoming episodes, we’ll not only look at what’s wrong, but what’s right. And how we can move past what’s wrong to make it right. But before we do that, I wanted to provide groundwork to hopefully get you to see your operating system, what it does for you, and what you do for it, in a different light.

Adobe: Addition through subtraction. I wrote on John Nack’s blog about the lack of care taken with Photoshop’s interface a while ago (surprisingly, he is quite the artist himself). Turns out, he didn’t like my comments all that much. Sure, I favour companies like Apple, who take great pride in pixel perfect interfaces, but that doesn’t mean you have to be just like them to impress me. Well, John took that as an insult. Adobe pushes out some really fine products too, he said. Yes, yes they sure do John. I contend that I live in Photoshop. But (there’s always a but) my problem is the changes that have been made over the years to the UI are far and few.

Sure, Adobe really loves modifying the actual shell of Photoshop (they’ve gone from transparency, to opaque in the least two iterations), but neglects to make any real UI changes. Take a look at the Preferences pane, still the same after how many iterations? The majority of filter options have also changed little over time. The layer effects have also stagnated. Hey, how about adding a “snapback to 100% view” feature to the Navigator? Because I’m always zooming in and out (to achieve pixel perfection), this would greatly increase my workflow (GIMP has already incorporated this wonderfully useful feature about a decade ago).

These (and many other) inherently poor design choices are crippling Photoshop. Actually, let me rephrase that, they are hindering its progress. The new facial and alignment features in CS4 are great. The GPU acceleration is also very welcome. But all in all, we need Adobe to start getting into the usability sector, and this means moving away from the awkward and sometimes convoluted ways they do things, to streamlining events and capabilities. Reducing a task by 3 mouse clicks is quite significant when you consider just how many tasks are accomplished and how long we designers sit behind photoshop. Adobe needs to invest in some time and motion studies.

And lastly, to kick their UI team in the ass. Pictured below (click on thumbnail to magnify) is a revision I quickly whipped up that took out several of the unneeded elements (separators, etc.) that currently exist. As you can see, it opens up the interface and makes things a lot less “cluttered.”

With a little bit of work, Photoshop can look quite good on Mac OS X. Again though, that is just the surface. Adobe really needs to dig deep and start retooling many of the underlying interface elements. From the Preferences pane, to the layer effects, to the various windows and options throughout PS. But to do that right, they need to hire some interaction design specialists. Deconstructing PS after some 12 iterations isn’t going to be easy (or cheap), but if they cared at all about designers, they would begin making the cheapest and easiest changes. Over the course of several iterations, they could progress quite extensively.

What do you say John? Loose a revolutionary version of PS by, say, CS8? One that streamlines workflow, increases productivity, and is a pleasure to look at? I think it can be done.

There is a strange phenomenon that grips the user when their first looking at a new piece of technology. Obviously, the first is the look of the item, taken in by those two orbs filled full of vitreous humor, called eyes. The second comes when they touch it and take it in at a closer level, and for those big on haptics, this can be quite pleasurable. This state constitutes the stage most often referred to as the “shill stage”, where the features are listed (e.g., bluetooth, EDGE, WiFi). The third state is the one that is rarely mentioned, and the one that seems to continually get it’s own focus, oddly enough apart from the first two states: The user interface.

The user interface (UI) often seems to run tight on the heels of functionality. By that, I mean a UI usually only goes as far as linking the user with the necessary hardware. You want to send an SMS? No problem, there is a program written that allows you to do just that. Trying to retrieve your mail? Got you covered with a program for that too. But for the most part, that seems to be as far as it goes. And while companies think most people will be quite happy with that, they are dead wrong. People want, nay, need stuff that works elegantly and beautifully. And why not? This doesn’t seem like an impossible feat. After all, the designers are humans themselves (or I should still hope so!).

So what can you do about it? Well, the first step is to recognize that hardware is not software. Sure we all get caught. I, myself, bought the Moto RAZR when it came out. I had to have it because, let’s face it, it was one heck of a sexy phone. But I quickly discovered how awful the interface was, and soon enough, I grew annoyed and then downright frustrated every time I used it. Hey, we all get hit sometimes. But we have to learn from our mistakes. So the next time you fall in love with that phone, or that computer, take a look at the interface. Try it. Use it. Because that should truly be your number one concern. We don’t just stare at our notebooks and mobile phones, we use them. When the software works, it usually increases the quality of our lives (Facebook is probably the exception), but when it’s poorly designed, confusing, or just plain unintuitive, life becomes a grind. So be critical. Demand usable interfaces, not just pretty hardware.

Usability and design are what jumps out at me. And I must admit, I relish using a system for the first time; be it a new ABM (automated banking machine) or a new pay parking system. These are the rare times I get to jump out of my shell and test a system without any advanced knowledge of its functionality. I get to follow the instructions and if I stumble, I have no one to turn to. I know many people in my life who don’t feel the same. A new system fills them with anxiety, tension, and the fear of failure. Not me, I love it; relish it in fact. So when I have the opportunity to beta test, I gladly accept.

I recently signed on to a few new projects to conduct preliminary usability analysis, and was shocked appalled at some of the UIs programmers wanted to put onto the general public (one program stood out as a monumental calamity). My professors (and professional ergonomists agree) have always told me the enemy of usability are the coders. The tech junkies and gurus that love a challenge, understand the integral parts of a system, and are so deeply immersed in their trade that even the largest niggle seems rudimentary to them (what, you couldn’t figure out that you needed to press the menu button three times, hold shift, and then toggle the left mouse button to pull up the context menu in the advanced options list?). And this fact I always keep in mind. Be wary of alphas and betas that have had no formal usability analysis (paper prototyping, what’s that?), or structural framework in the design phase (rapid iterative design? well we did work on the UI rather quickly!).

I love receptive customers and programmers who actually want to create a manageable and usable program. After all, it is in their benefit to drive up revenue and increase customer usage, is it not? But then you come across the dark side. The developer who insist that users will understand the arbitrarily located buttons. That the program will become intuitive over time. But this is all part of the job. It hones my skills and allows me to be flexible. To work with my clients and around the system itself. Sometimes a complete re-tooling just can’t be done (easily avoided if proper design principles are employed from day one, but let’s not go there). So I let it go and enjoy the ride. But what does burn me, and I’m not going to pull any punches, is when hard-nosed developers make glaring usability mistakes and turn around, publicizing their programs has having an “intuitive interface” that screams usable.

It seems usability has become another buzzword for the industry. Despite no true usability testing every being conducted, developers seem to feel the need to include that little, nine letter word in their program’s sales pitch. It makes me frustrated, angry, and a little sleepy. I understand that my trade is much more of an art than it is a hard science, and in that respect, I want the world to take ergonomists seriously, but if we do our job right, things are seamless. The interface is fluid. The connection between the man and the machine is effortless. So it only hurts us when poor programs are designed poorly and toted as having “usability.” These pieces of software are only as usable in that they can be run on your chosen platform and a user can interact with them. True usability is a synergy between you and the product. It requires extensive testing, change upon change, and may deviate from the developers vision in more ways that one. Sacrifices are made, much blood and sweat is put into it, but the final product is one the user never struggles with. It becomes an extension of the user. And this is much easier said than done (even for the best in the field). But you can see now why the word “usability” (if you ascribe to the above definition) is such a lucrative word to have in your sales pitch.

So please be wary as a user. If you see the term “usability” littered throughout a programs sales pitch, ask them just what they did to make it “usable.” There is more to usability than telling someone the program has it in spades.