Navneet Kumar's Library tagged UX → View Popular

Filter:
All
Annotated

23 Feb 09

Performance Matters: The Miller Response-Time Test

humor and human_computer_interaction

performancematters.blogspot.com/...miller-response-time-test.html - Preview

Performance ResponseTime HCI UX UI human_computer_interaction

Only half the test subjects abandoned after 8.5 seconds, and site feedback (like animated cursors or progress bars) kept them around for much longer.
Robert B. Miller’s classic paper on Response Time in Man-Computer Conversational Transactions

12 Feb 09

User Interface Design for Programmers - Chapter 2

www.joelonsoftware.com/...fog0000000058.html - Preview

ebook hci joel ui UX UI user_interface_design

user model: it is their mental understanding of what the program is doing for them.
The program, too, has a "mental model," only this one is encoded in bits and will be executed faithfully by the CPU. This is called the program model,
9 more annotations...
- if the program model corresponds to the user model, you have a successful user interface.
- user model inertia
- unhappy conflict of user model (the picture will be embedded) versus program model
- You can try to change the user model. This turns out to be remarkably hard. You could explain things in the manual, but everybody knows that users don't read manuals,
- it's annoying to sophisticated users, and users don't read dialog boxes, either
- The popular choice is the best user model, and it's up to you to make the program model match it.
- Next, you have to test your theories. Build a model or prototype of your user interface and give some people tasks to accomplish.
- five or six users is enough. After that, you start seeing the same results again and again, and any additional users are just a waste of time.
- It's a nice way to toggle between two applications, but almost nobody figures it out, because it's a slightly more complicated model than the rotate-among-available-windows model.

User Interface Design for Programmers - Chapter 1

www.joelonsoftware.com/...fog0000000057.html - Preview

article book design joel online ui uidesign user_interface UX

Programmers see themselves as analytic, logical thinkers: strong at reasoning, weak on artistic judgment.
The more you feel that you can control your environment, and that the things you do are actually working, the happier you are
6 more annotations...
- When you're thinking about user interfaces, it helps to keep imaginary users in mind. The more realistic the imaginary user is, the better you'll do thinking about how they use your product.
- When he tries to control things, they don't respond. The space bar and the Alt+F4 key "don't work" -- for all intents and purposes, it's as if those keys were broken. The window disobeys him when he tries to make it wider, playing a little prank where it just moves over instead of widening. Bad window. Even if the whole thing is subconscious, the subtle feeling of being out of control translates into helplessness, which translates into unhappiness.
- does the UI respond to the user in the way in which the user expected it to respond? If it didn't, the user is going to feel helpless and out of control
- UI is important because it affects the feelings, the emotions, and the mood of your users. If the UI is wrong and the user feels like they can't control your software, they literally won't be happy and they'll blame it on your software.
- To make people happy, you have to let them feel like they are in control of their environment. To do this, you need to correctly interpret their actions. The interface needs to behave in the way they are expecting it to behave.
- A user interface is well-designed when the program behaves exactly how the user thought it would.

Choices - Joel on Software

www.joelonsoftware.com/...fog0000000059.html - Preview

UX UI user_interface_design joel

Options dialog box and you will see a history of arguments that the software designers had about the design of the product
The problem comes when you ask them to make a choice that they don't care about.
8 more annotations...
- They are using your software to accomplish a task. They care about the task.
- hey don't care about a lot of things, and it is the designers' responsibility to make these choices for them so that they don't have to
- design is the art of making choices.
- When you are designing, and you try to abdicate your responsibility by forcing the user to decide something, you're probably not doing your job. Someone else will make an easier program that accomplishes the same task with less intrusions, and most users will love it.
- when you accidentally reconfigure one of the options in your program, you don't know how to re-reconfigure it.
- The trouble with customizing your environment is that it just doesn't propagate, so it's not even worth the trouble.
- Every time you provide an option, you're asking the user to make a decision. That means they will have to think about something and decide about it. It's not necessarily a bad thing, but, in general, you should always try to minimize the number of decisions that people have to make.
- it's great to give people choices: by all means, the more the merrier. And there's another category of choice that people like: the ability to change the visual look of things, without really changing the behavior.

Designing for People Who Have Better Things To Do With Their Lives, Part Three - Joel on Software

www.joelonsoftware.com/...fog0000000064.html - Preview

UX HCI User_Interface Iser_Interface_Design Joel

Users don't read stuff
Users can't use the mouse
2 more annotations...
- Users can't remember anything
- The effect of this sharp drop-off is that whenever you "lower the bar" by even a small amount, making your program, say, 10% easier to use, you dramatically increase the number of people who can use it, say, by 50%.