A user interface is a mechanism for the user to communicate their intention; in this case, to a computer. When I sit down to search for airfare on Kayak.com, I have a certain intent: I want to find a plane ticket that meets my schedule and budget.
When I first open Kayak.com, the site has no knowledge of my intent, beyond my basic interest in airfare. Between this initial state and the end state - my purchase of the appropriate airfare - I need to communicate my intent to the site in a mutually understandable format. Something the machine can easily understand, and I can easily provide.
This is the goal for the entire user interaction, as well as each individual action within that process. Each button click or form filled out is a microcosm of the larger goal of communicating my intention to buy airfare. And inside this Russian doll of interactions is where context plays a key role.
Good design maximizes context
A goal of good user interface design should be to maximize the communicated intent, while minimizing the user’s effort to communicate it. In other words, good design maximizes context.
Context refers to the user’s past interactions with the user interface. At the most basic level, it allows intent to be “stored” by the application, and reused later. The user interface can manifest this “stored intent” in a variety of ways (or not at all).
A simple example of context is logging in to a website. Rather than continually providing identity details with every transaction, the website allows the user to “login”. That identity then becomes part of the “context” of the user’s future actions, which are associated to that identity via context.
A less obvious example is the “Customer’s Also Bought” section on Amazon. Here, the user has communicated their intention to search for and possibly purchase a particular item. Amazon leverages this communicated intent to proactively meet the user’s additional potential needs.
potential needs including everything bacon, I presume
Context means state
Those observant programmers reading this may notice that context seems to involve maintaining state. That is because, either via a logged in session, or the browser DOM, context is state.
Unfortunately, state is hard. Any good programmer can tell you that introducing state opens the door to all sorts of problems. The same is true of a user interface. Suddenly, the design needs to consider every possible contextual state and the transitions between them.
In the worst case, this has the potential of becoming an exponentially difficult problem - each additional state may need to transition to every other state. Complexity increases, and edge cases abound.
Hard problems are good problems
But I suspect this is a good thing. At Kinvey, we relish finding a tough technical problem. Partly because we are a bunch of geeks who love a good puzzle, but also because it represents a potential market opportunity: if it’s a tough problem we can solve, we can provide a solution and deliver value to others. In the same sense, the user interface designer that embraces context has the potential to greatly improve the user experience. By leveraging the stored intent of the user, the interface can drastically reduce the user’s work and provide a smoother, simpler experience.
Note: this was cross posted on the Kinvey blog