Recently in User Interface Category

Yammer 2.0 for iPhone is a huge improvement over 1.0. Local caching. Improved performance. Way better usability. Excellent.

One gripe. After composing and sending a new message to yammer, I am greeted with the following alert:

Which requires me to press "OK" in order to proceed with my quest of wading through a morning's list of messages while waiting for the car in front of me to move another inch through morning traffic jam.

In order to avoid the alert dialog / message, I would suggest to insert the new message into my list of messages, probably marked with a special badge or color in order to let the user know that the message was sent.

Lesson to be learned:

Avoid alerts at all cost. They get in the way of the user. Most of the time, users don't read them, anyway. There's almost always a way to achieve same goal without an alert dialog.

(...stepping down from soapbox)

Great post by David Weiss: Painted on the inside.

If there's only one thing you need to read today, than this is it.

Simplicity.

...received an e-mail with a Word document attached. Downloaded and read the Word file on my iPhone while my little daughter was busy climbing on the local playground.

I'm impressed (both by my daughters's climbing skills and the fact the downloading & reading a 3MB word file worked flawlessly).

...GrabFS. The Screenshot File System.

Even if you are not into .NET, WinForms etc. this series by Jeremy D. Miller is a great one to follow. Posts so far:

• Preamble
• The Humble Dialog Box
• Supervising Controller
• Passive View
• Presentation Model
• View to Presenter Communication
• Answering some questions
• What's the Model?
• Assigning Responsibilities in a Model View Presenter Architecture
• Domain Centric Validation with the Notification Pattern
• Unit Testing the UI with NUnitForms
• Event Aggregator

Plus, as a bonus, you will notice that Jeremy is not afraid of using really long function names:

void CloseTheScreenWhenTheScreenIsDirtyAndTheUserDecidesNOTToDiscardTheChanges()

And I'm mentioning this not to make fun of Jeremy.

Another great post from Creating Passionate Users: Don't make the Demo look Done.

But you have them in your reading list already, don't you?

Excellent post by Joel Spolsky:

This highlights a style of software design...driven by a desire for consensus and for "Making Everybody Happy," but it's based on the misconceived notion that lots of choices make people happy, which we really need to rethink.

Creating Passionate Users: Ease-of-use should not mean neuter-the-software.

Brown.

I'm speechless.

Please note that I'm not bashing neither the features nor the capabilities of the device. Not at all.

Excellent read: Logic Versus Usage: The Case for Activity-Centered Design.

Creating passionate users:

Make the right things easy and the wrong things hard.

I applaud the courage of the Office 12 UI team to take the risk and introduce a new UI (the "Ribbon" being the most prominent feature of the new UI) to deal with making Office more accessible, discoverable and in the very end, usable.

This is great stuff and worth looking into in great detail. Here are some great resources on the new Office 12 UI:

• BayCHI session video & audio
• Jensen Harris' Blog

There's a new book out there by 37signals called Getting Real. True to their philosophy of less features, it's PDF only.

Not enough features, folks.

If they would have a dead-tree edition of the PDF, I would buy it right away.

• Reading a book on the screen sucks
• Printing out 171 pages on an aging, constantly-paper-jamming laser printer sucks even more
• Reading a stack of 171 (or 171 / 2) DIN A4 / US letter sized sheets of paper while sitting on the, uhm, well, "throne" sucks royally (*).

There's no alternative to the clean, user-friendly UI of a book.

(*) Hey, I'm a married man & dad of two wonderful daughters. Sitting on the, uhm, well, "throne" is the only time I have left to read a book in peace & quiet)

[Update: No, I don't want to bind my own paperback book]

Watch this: Dabble DB Demo.

Database stuff still is cool.

Coding Horror:

Web Forms: Death By a Thousand Textboxes

Interesting thoughts on reducing the number of textboxes & text entry controls in a UI.

Cem Basman: Simplicity is about staying simple.

Another great post on Coding Horror: Error Codes Must Die.

Excellent post: Making technology simple.

Kind of resonates with my thoughts on lacking advances in UI design.

I had the pleasure to read "The Humane Interface" of the late Jeff Raskin over the christmas break.

Raskin very much focusses on techniques to make a touch-typing, text-processing power-user more efficient using the computer. While these techniques are definitely worth pondering, I was hoping for some insight on how to make the casual, non-touch-typing, non-power-user more efficient in using the computer to accomplish a task. That's a much harder task than improving a power-users efficiency.

Here's an interesting podcast of Brian Ferren's speech at Web 2.0.

He makes quite a compelling argument for specialized user interfaces to empower users instead of creating standard GUIs using a keyboard, mouse & monitor for computing tasks.

Although his thoughts are probably not applicable for us working in standard Web/PC-UI Environment, they resonate with the end of consistency in GUIs. Maybe those of us doing traditional desktop apps should think "out-of-the-box" when creating a GUI.

Sometimes standard Windows / MacOS controls don't cut it.

Tilman wonders about 37signals "Less software" approach and concludes that “Less” sometimes is - less!.

Here are a few unstructured thoughts of mine on this very topic:

• The need to integrate a software product in a complex workflow with different, heterogeneous components makes it hard to build "less software". Interfacing with different machines, different ERP-systems is hard. And complex. Which translates into more, not less software.

• The software 37signals creates is great stuff. The apps work beautifully. However, these are not "mission-critical" apps used by companies to run their core business processes. Plus these apps are very much targeting the "knowledge worker" who's used to work all day long in front of his/her computer. There are many users out there who don't want to spend a lot of time in front of their computer & who don't have the time to play around on their computer. Because they aren't interested in computers at all plus - more importantly - they get paid to run a business, build real products and face real-world problems. These types of users tend to expect a lot of features with minimum intervention on their behalf.

• You may get away with less features by creating a product which appeals to both tourists & sailors as outlined in Guy Kawasaki's The Macintosh Way. However, most likely you'll end up with powerful software with a great, easy-to-use multi-level UI. To my understanding, that's not the "less software" approach 37signals is advocating.

However, I still think a lot of the "less software" concepts which came up in the context of 37signals are worth pondering and worth pursuing. Especially if you think about them as related to the well-known YAGNI principle used in XP style software development:

It's not about anticipating and building what may be needed tomorrow, it's about building great software for what is needed today.

[Update: Another twist to the topic is that the type of customer I described above wants to pay for features he/she most likely will never use, but doesn't want to pay for simplicity or ease-of-use]

Looks like Don Park is wondering about document-centric computing.

Don, read this first before following this road any further.

Don Park makes an interesting observation on the average computer user, and Dave Winer agrees.

I've rambled about this topic quite a while ago: 95% of the UI improvements in Windows Vista or MacOS X are irrelevant to 95% of the computer users out there. Why? Because they don't address the fundamental challenges these 95% face.

I would even go farther and say that 99% of all past improvements to the Windows Explorer or Macintosh Finder (remember the spatial orientation discussion?) were irrelevant to 99% of the users.

[Update: And I don't subscribe to the theory that the Web is a fundamental advance for these 95% of the users, as David Berlind notes. It's not that the desktop (OS) is flawed and the Web-based UIs change that. Web-based UIs just have different kinds of fundamental problems.]

Michael Mahemoff on Error Messages We’d Rather Not See.

Pop-up Potpourri: Arcade Edition.

I like

If you choose to continue, do you wish to continue? [OK]

Here's the essence what Apple's all about:

(Screen Capture taken (without permission) from QuickTime stream of the Apple Special Event on Oct, 13 2005).

Hint: It's not about the size.

ColorBlender - Very cool.

(Via Lifehacker.)

Interesting thoughts on Avoiding "Blank Page Syndrome".

The first question our users asked when confronted with a non-blank document was:

"How do I remove this stuff?"

So the jury is still out on that one. Labelling the "default" sample content as "Example" plus describing that this is only default sample content and will go away requires the users to read (quite a lot) & understand what's written.

Judging from my experience, this spells trouble.

Interesting post on Configuration Hell- The Case for the Plug and Play User Experience.

Jason Fried notes that The days of consistency are over. It sure looks like. Today Microsoft previewed Office 12 with a totally new UI - while some components of Office 12 (OneNote comes to my mind) seem to stick to the "old-fashioned" Look & Feel.

Here are some rambling thoughts of mine on the whole topic viewed from the humble perspective of software developer working on a cross-platform desktop application.

This is really cool: A web application built as a desktop application.

I wonder if this is the dawn of web applications taking over desktop applications for creating cool GUI apps.

Draw with friends.

(Via Loic Le Meur Blog.)

Very cool calculator UI - watch the movie.

Inspiring.

Via stevenf.

Brent Simmons, Michael McCracken, Dan Wood, Michael Dupuis, Sven S. Porst and others have been taking up with the latest "advances" of MacOS X's UI, as found in its latest incarnation "Tiger".

Back in the old System 7/8/9 days, the MacOS had a pretty limited but system-wide consistently used set of UI widgets. Apple wasn't (that much) into the software applications business, and third-party developers (both big shops and one-man shows) were forced to advance the state of the art in terms of UI widgets. Remember, those were the days when there was no tab-control, no combo-box control, no multi-column list control etc. (Come to think of it, some of it holds true today for Carbon- and Resource-based MacOS X applications - sic). In order to come up with a great MacOS application in those days, you had to invest substantial resources into widget/UI development.

Fast-forward to 2005. Cocoa/HIViews provide a set of reasonably powerful UI widgets. Apple is cranking out software applications like mad. And still third-party developers and Apple itself regularily come up with new UI widgets & styles.

Why is that?

IMHO, a major suspect are web applications/pages. No User Interface Guidelines. No limits. Web applications don't have strong ties in platform specific UI frameworks and widgets. It's pretty straightforward to come up with a new look for a button control - in fact, it's way easier to create a new button or list control style for use in a web app than for any desktop applications. This is putting an enormous pressure on desktop applications to advance their UI.

Traditionally, desktop UI frameworks and widget sets haven't been able to keep up with the state of the art. Most likely, they never will.

What third-party developers should be advocating is a UI framework which makes it as straightforward as possible to come up with new UI styles and widgets. Because UI development is damned hard. It shouldn't be that way.

Excellent read.

Undeveloped thoughts of the week:

"UI development is like painting the faces of a thousand army men with a little brush. Enterprise server development is like painting a stadium with a roller in the dark."

Let me add that each soldier of the thousand army men is made out of different materials, requiring you to change your brush & color technology constantly. And some of them move while getting painted.

Adobe's Adam & Eve (Via Lambda The Ultimate)

Cool stuff (but it sure has a smell of over-engineering).

Macworld: News: 'LinkBack' brings embedded objects to Mac OS X.

I smell OpenDoc. Yeeeha!

A good introduction to the Model-View-Presenter Pattern, also known as the Humble Dialog Box. Required reading.

More patterns by Martin Fowler related to rich client user interfaces can be found here.

Bartelme Design — CSS, XHTML, Design, Icons, Desktops

Including some nice Photoshop-Tutorials.

Evolving the UI.

Although I don't agree with the authors conclusion on "Fat client UI frameworks", there are lots of great thoughts in this article. Forget visual forms designers is one of them. Read for yourself.

Dave Heller:

As IT systems finally make their way into the non-info service sector such as health care practices, blue collar e-learning, etc. we are starting to really see that our notions of “(GUI) conventions” even the most basic are just totally bogus. People can’t even use a mouse, let alone know that a blue under lined piece of text means something that will show me something else.

...on agile software development here. Here's one of them: The Humble Dialog Box.