Let me say it directly:

Improving on this does not begin with guidelines. It begins with reframing how you think about software.

Most hardcore developers have practically zero empathy with users of their software. They have no clue how users think, how users build models of software they use and how they use a computer in general.

It is a typical problem when an expert collides with a laymen: How on earth could a normal person be so dumb not to understand what the expert understood 10 years ago?

One of the first facts to acknowledge that is unbelievably difficult to grasp for almost all experienced developers is this:

Normal people have a vastly different concept of software than you have. They have no clue whatsoever of programming. None. Zero. And they don't even care. They don't even think they have to care. If you force them to, they will delete your program.

Now that's unbelievably harsh for a developer. He is proud of the software he produces. He loves every single feature. He can tell you exactly how the code behind it works. Maybe he even invented an unbelievable clever algorithm that made it work 50% faster than before.

And the user doesn't care.

What an idiot.

Many developers can't stand working with normal users. They get depressed by their non-existing knowledge of technology. And that's why most developers shy away and think users must be idiots.

They are not.

If a software developer buys a car, he expects it to run smoothly. He usually does not care about tire pressures, the mechanical fine-tuning that was important to make it run that way. Here he is not the expert. And if he buys a car that does not have the fine-tuning, he gives it back and buys one that does what he wants.

Many software developers like movies. Well-done movies that spark their imagination. But they are not experts in producing movies, in producing visual effects or in writing good movie scripts. Most nerds are very, very, very bad at acting because it is all about displaying complex emotions and little about analytics. If a developer watches a bad film, he just notices that it is bad as a whole. Nerds have even built up IMDB to collect information about good and bad movies so they know which ones to watch and which to avoid. But they are not experts in creating movies. If a movie is bad, they'll not go to the movies (or not download it from BitTorrent ;)

So it boils down to: Shunning normal users as an expert is ignorance. Because in those areas (and there are so many) where they are not experts, they expect the experts of other areas to have already thought about normal people who use their products or services.

What can you do to remedy it? The more hardcore you are as a programmer, the less open you will be to normal user thinking. It will be alien and clueless to you. You will think: I can't imagine how people could ever use a computer with this lack of knowledge. But they can. For every UI element, think about: Is it necessary? Does it fit to the concept a user has of my tool? How can I make him understand? Please read up on usability for this, there are many good books. It's a whole area of science, too.

Ah and before you say it, yes, I'm an Apple fan ;)

UI design is hard

To the question:

why is UI design so hard for most developers?

Try asking the inverse question:

why is programming so hard for most UI designers?

Coding a UI and designing a UI require different skills and a different mindset. UI design is hard for most developers, not some developers, just as writing code is hard for most designers, not some designers.

Coding is hard. Design is hard too. Few people do both well. Good UI designers rarely write code. They may not even know how, yet they are still good designers. So why do good developers feel responsible for UI design?

Knowing more about UI design will make you a better developer, but that doesn't mean you should be responsible for UI design. The reverse is true for designers: knowing how to write code will make them better designers, but that doesn't mean they should be responsible for coding the UI.

How to get better at UI design

For developers wanting to get better at UI design I have 3 basic pieces of advice:

1. Recognize design as a separate skill. Coding and design are separate but related. UI design is not a subset of coding. It requires a different mindset, knowledge base, and skill group. There are people out there who focus on UI design.
2. Learn about design. At least a little bit. Try to learn a few of the design concepts and techniques from the long list below. If you are more ambitious, read some books, attend a conference, take a class, get a degree. There are lot of ways to learn about design. Joel Spolky's book on UI design ^[1] is a good primer for developers, but there's a lot more to it and that's where designers come into the picture.
3. Work with designers. Good designers, if you can. People who do this work go by various titles. Today, the most common titles are User Experience Designer (UXD), Information Architect (IA), Interaction Designer(ID), and Usability Engineer. They think about design as much as you think about code. You can learn a lot from them, and they from you. Work with them however you can. Find people with these skills in your company. Maybe you need to hire someone. Or go to some conferences, attend webinars, and spend time in the UXD/IA/ID world.

Here are some specific things you can learn. Don't try to learn everything. If you knew everything below you could call yourself an interaction designer or an information architect. Start with things near the top of the list. Focus on specific concepts and skills. Then move down and branch out. If you really like this stuff, consider it as a career path. Many developers move into managements, but UX design is another option.

• Learn fundamental design concepts. You should know about affordances, visibility, feedback, mappings, Fitt's law, poka-yokes, and more. I recommend reading The Design of Everyday Things ^[2] (Don Norman) and Universal Principles of Design ^[3] (Lidwell, Holden, & Butler)
• Learn about user experience. This is becoming the umbrella term for the human-centered design of web sites, applications, and any other digital artifact. The classic primer here is The elements of User Experience ^[4] (Jesse James Garrett). You can get an overview and the first few chapters from the author's site ^[5].
• Learn to sketch designs. Sketching is fast way to explore design options and find the right design, whereas usability testing is about getting the design right. Paper prototyping is fast, cheap, and effective during the early design stages. Much faster than coding a digital prototype. The key text here is Sketching User Experience: Getting the design right and the right design ^[6] ( Bill Buxton ^[7]). Sketching is a particularly useful skill when working with IA/ID/UX designers. Your collaboration will be more effective. For a good primer on how and why designers sketch, watch the presentation How to be a UX team of one ^[8] by Leah Buley from the 2008 IA Summit ^[9].
• Learn paper prototyping. The fastest way to iteratively test an interface before you write code. Different from sketching and usability testing. The definitive book here is Paper Prototyping ^[10] (Carolyn Snyder). You can get a good DVD on this from the Nielsen Norman Group ^[11].
• Learn usability testing. Discount testing is easy and effective. But for many UIs, usability is hard to do well. You can learn the basics quickly, but good usability people are invaluable. If you want a book, the classic is The Handbook of Usability Testing ^[12] (Jeffrey Rubin). It's older but offers thorough coverage of lab-based testing. The famous starter book is Don't Make Me Think (2nd Ed) ^[13] (Steve Krug). I caution people about this one: Krug makes it sound easier than it is. But it is a good starting point. The user research books listed in the next point also cover this topic. And you can find piles about it online.
• Learn about information architecture. The main book here is Information Architecture for the World Wide Web (3rd) ^[14] (Louis Rosenfeld & Peter Morville). A good starter book is Information Architecture: Blueprints for the Web ^[15] (Christina Wodtke). For more, visit the Information Architecture Institute ^[16] or attend the annual Information Architecture Summit ^[17].
• Learn about interaction design. The main book here is The Essentials of Interaction Design (3rd) ^[18] (Alan Cooper, et al). A good starter book is Designing for interaction ^[19] (Dan Saffer). For more, visit the Interaction Design Association (IxDA) ^[20] or attend the annual Interaction Design conference ^[21].
• Learn fundamentals of graphic design. Graphic design is not UI design, but concepts from graphic design can improve an interface. Graphic design introduces design principles for the visual presentation of information, such as proximity, alignment, and small multiples. I recommend reading The non-designer's design book ^[22] (Robin Williams) and Envisioning Information ^[23] (Edward Tufte)
• Learn to do user research. Where usability tests an interface, user research tries to model users and their tasks through personas, scenarios, user journeys, and other documents. It's about understanding users and what they do, then using that to inform the design instead of guessing. Some techniques are interviews, surveys, diary studies, and cart sorting. Good books on this are Observing the User Experience ^[24] (Mike Kuniavsky) and Understanding Your Users ^[25] (Courage & Baxter)
• Learn to do field research. Watching people in the lab under artificial conditions helps (ie: usability), but there is nothing like watching people use your code in context: their home, their office, or wherever they use it. Goes by various names, including ethnography, field studies, and contextual inquiry. Here is a good primer on field research ^[26]. Two of the better known books here are Rapid Contextual Design ^[27] (Karen Holtzblatt et al) and User and task analysis for interface design ^[28] (Hackos & Redish).
• Read UX design web sites. Some of the big ones are Boxes & Arrows ^[29], UX Mag ^[30], UX Matters ^[31], and Digital Web magazine ^[32].
• Use UI pattern libraries. There are patterns for interfaces. For web sites, I recommend The Design of Sites, 2nd ed ^[33] (Van Duyne, et al) and Homepage usability: 50 websites deconstructed ^[34] (Jakob Nielsen & Marie Tahir). For desktop applications I recommend Designing interfaces ^[35] (Jennifer Tidwell), and for web applications I recommend Designing Web Interfaces: Principles and Patterns for Rich Interactions ^[36] (Bill Scott & Theresa Neil). Online you should check Welie pattern library ^[37], UI patterns ^[38], and Web UI patterns ^[39].
• Attend UX design conferences. Some good annual conferences are: Information Architecture Summit ^[40], Interaction '09 (IxDA) ^[41], User Interface ^[42], and UX week ^[43].
• Attend a workshop or webinar. You can take workshops, webinars, and online courses. This is far from a comprehensive list, but you might try the UIE virtual seminars ^[44], Adaptive Path virtual seminars ^[45], and UX webinars from Rosenfeld Media ^[46].
• Get a degree. A graduate degree in HCI is one approach, but these programs are mostly about writing coding. If you want to learn about the design of digital artifacts and devices, then you want a graduate program that's not in CS. Some options include Interaction Design at Carnegie Mellon ^[47], the d-School at Stanford ^[48], the ITP program at NYU ^[49], and Information Architecture & Knowledge Management ^[50] at Kent State (disclosure: I'm on faculty at Kent; we are seeing more and more people with CS degrees moving into UX design instead of management, which is interesting, because management is the traditional path for developers who want to move away from writing code while staying in their field). There are many more programs. Each has their own perspective, areas of emphasis, and technical expectations. Some come out of the arts and visual design, others out of library and information science, and some from CS. Most are hybrids, but every hybrid has deeper roots in one or more fields. If this interests you, look around and try to understand the differences between these programs. Some offer online courses and certificate programs in addition to full-fledged degrees.

Why UI design is hard

Good UI design is hard because it involves 2 vastly different skills:

• A deep understanding of the machine. People in this group worry about code first, people second. They have deep technological knowledge and skill. We call them developers, programmers, engineers, and so forth.
• A deep understanding of people and design: People in this group worry about people first, code second. They have deep knowledge of how people interact with information, computers, and the world around them. We call them user experience designers, information architects, interaction designers, usability engineers, and so forth.

This is the essential difference between these 2 groups—between developers and designers:

• Developers make it work. They implement the functionality on your TiVo, your iPhone, your favorite website, etc. They make sure it actually does what it is supposed to do. Their highest priority is making it work.
• Designers make people love it. They figure out how to interact with it, how it should look, and how it should feel. They design the experience of using the application, the web site, the device. Their highest priority is making you fall in love with what developers make. This is what is meant by user experience, and it's not the same as brand experience.

Moreover, programming and design require different mindsets, not just different knowledge and different skills. Good UI design requires both mindsets, both knowledge bases, both skill groups. And it takes years to master either one.

Developers should expect to find UI design hard, just as UI designers should expect to find writing code hard.

What really helps me improve my design is to grab a fellow developer, one the QA guys, the PM, or anyone who happens to walk by and have them try out a particular widget or screen.

Its amazing what you will realize when you watch someone else use your software for the first time

Ultimately, it's really about empathy -- can you put yourself in the shoes of your user?

One thing that helps, of course, is "eating your own dogfood" -- using your applications as a real user yourself, and seeing what's annoying.

Another good idea is to find a way to watch a real user using your application, which may be as complicated as a usability lab with one-way mirrors, screen video capture, video cameras on the users, etc., or can be as simple as paper prototyping using the next person who happens to walk down the hall.

If all else fails, remember that it's almost always better for the UI to be too simple than too complicated. It's very very easy to say "oh, I know how to solve that, I'll just add a checkbox so the user can decide which mode they prefer". Soon your UI is too complicated. Pick a default mode and make the preference setting an advanced configuration option. Or just leave it out.

If you read a lot about design you can easily get hung up on dropped shadows and rounded corners and so forth. That's not the important stuff. Simplicity and discoverability are the important stuff.

Contrary to popular myth there are literally no soft aspects in UI design, at least no more than needed to design a good back end.

Consider the following; good back end design is based upon fairly solid principles and elements any good developer is familiar with:

• low coupling

• high cohesion

• architectural patterns

• industry best practices

• etc

Good back end design is usually born through a number of interactions, where based on the measurable feedback obtained during tests or actual use the initial blueprint is gradually improved. Sometimes you need to prototype smaller aspects of back end and trial them in isolation etc.

Good UI design is based on the sound principles of:

• visibility

• affordance

• feedback

• tolerance

• simplicity

• consistency

• structure

UI is also born through test and trial, through iterations but not with compiler + automated test suit, but people. Similarly to back end there are industry best practises, measurement and evaluation techniques, ways to think of UI and set goals in terms of user model, system image, designer model, structural model, functional model etc.

The skill set needed for designing UI is quite different from designing back-end and hence don’t expect to be able to do good UI without doing some learning first. However that both these activities have in common is the process of design. I believe that anyone who can design good software is capable of designing good UI as long as they spend some time learning how.

I recommend taking a course in Human Computer Interaction, check MIT and Yale site for example for online materials:

• MIT User Interface Design and Implementation Course ^[1]

Structural vs Functional Model in Understanding and Usage

The excellent earlier post by Thorsten79 ^[2] brings up the topic of software development experts vs users and how their understanding of software differ. Human learning experts distinguish between functional and structural mental models. Finding way to your friend's house can be an excellent example of the difference between the two:

• First approach includes a set of detailed instructions: take the first exit of the motorway, then after 100 yards turn left etc. This is an example of functional model: list of concrete steps necessary to achieve a certain goal. Functional models are easy to use, they do not require much thinking just a straight forward execution. Obviously there is a penalty for the simplicity: it might not be the most efficient route and any any exceptional situation (i.e. a traffic diversion) can easilly lead to a complete failure.

• A different way to cope with the task is to build a structural mental model. In our example that would be a map that conveyes a lot of information about the internal structure of the "task object". From understanding the map and relative locations of our and friend's house we can deduct the functional model (the route). Obviously it's requires more effort, but much more reliable way of completing the task in spite of the possible deviations.

The choice between conveying functional or structural model through UI (for example, wizard vs advanced mode) is not that straight forward as it might seem from Thorsten79's post. Advanced and frequent users might well prefer the structural model, whereas occassional or less expirienced users — functional.

Google maps is a great example: they include both functional and structural model, so do many sat navs.

Another dimension of the problem is that the structural model presented through UI must not map to the structure of software, but rather naturally map to structure of the user task at hand or task object involved.

The difficulty here is that many developers will have a good structural model of their software internals, but only functional model of the user task the software aims to assist at. To build good UI one needs to understand the task/task object structure and map UI to that structure.

Anyway, I still can't recommend taking a formal HCI course strongly enough. There's a lot of stuff involved such as heuristics ^[3], principles derived from Gestalt phychology ^[4], ways humans learn etc.

I suggest you start by doing all your UI in the same way as you are doing now, with no focus on usability and stuff.

alt text http://www.stricken.org/uploaded_images/WordToolbars-718376.jpg ^[1]

Now think of this:

A designer knows he has achieved perfection not when there is nothing left to add, but when there is nothing left to take away. — Saint-Exupéry

And apply this in your design.

A lot of developers think that because they can write code, they can do it all. Designing an interface is a completely different skill, and it was not taught at all when I attended college. It's not just something that just comes naturally.

Another good book is The Design of Everyday Things ^[1] by Donald Norman.

There's a huge difference between design and aesthetics, and they are often confused.

A beautiful UI requires artistic or at least aesthetic skills that many, including myself, are incapable of producing. Unfortunately, it is not enough and does not make the UI usable, as we can see in many heavyweight flash-based APIs.

Producing usable UIs requires an understanding of how humans interact with computers, some issues in psychology (e.g., Fitt's law, Hick's law), and other topics. Very few CS programs train for this. Very few developers that I know will pick a user-testing book over a JUnit book, etc.

Many of us are also "core programmers", tending to think of UIs as the facade rather than as a factor that could make or break the success of our project.

In addition, most UI development experience is extremely frustrating. We can either use toy GUI builders like old VB and have to deal with ugly glue code, or we use APIs that frustrate us to no end, like trying to sort out layouts in Swing.

Go over to Slashdot, and read the comments on any article dealing with Apple. You'll find a large number of people talking about how Apple products are nothing special, and ascribing the success of the iPod and iPhone to people trying to be trendy or hip. They will typically go through feature lists, and point out that they do nothing earlier MP3 players or smart phones didn't do.

Then there are people who like the iPod and iPhone because they do what the users want simply and easily, without reference to manuals. The interfaces are about as intuitive as interfaces get, memorable, and discoverable. I'm not as fond of the UI on MacOSX as I was on earlier versions, I think they've given up some usefulness in favor of glitz, but the iPod and iPhone are examples of superb design.

If you are in the first camp, you don't think the way the average person does, and therefore you are likely to make bad user interfaces because you can't tell them from good ones. This doesn't mean you're hopeless, but rather that you have to explicitly learn good interface design principles, and how to recognize a good UI (much as somebody with Asperger's might need to learn social skills explicitly). Obviously, just having a sense of a good UI doesn't mean you can make one; my appreciation for literature, for example, doesn't seem to extend to the ability (currently) to write publishable stories.

So, try to develop a sense for good UI design. This extends to more than just software. Don Norman's "The Design of Everyday Things" is a classic, and there's other books out there. Get examples of successful UI designs, and play with them enough to get a feel for the difference. Recognize that you may be having to learn a new way of thinking abou things, and enjoy it.

The main rule of thumb I hold to, is never try to do both at once. If I'm working on back-end code, I'll finish up doing that, take a break, and return with my UI hat on. If you try to work it in whilst you're doing code, you'll approach it with the wrong mindset, and end up with some horrible interfaces as a result.

I think it's definitely possible to be both a good back-end developer and a good UI designer, you just have to work at it, do some reading and research on the topic (everything from Miller's #7, to Nielsen's archives), and make sure you understand why UI design is of the utmost importance.

I don't think it's a case of needing to be creative but rather, like back-end development, it is a very methodical, very structured thing that needs to be learned. It's people getting 'creative' with UIs that creates some of the biggest usability monstrosities... I mean, take a look at 100% Flash websites, for a start...

Edit: Krug's book is really good... do take a read of it, especially if you're going to be designing for the Web.

There are many reasons for this.

(1) Developer fails to see things from the point of view of the user. This is the usual suspect: lack of empathy. But it is not usually true since developers are not as alien as people make them out to be.

(2) Another, more common reason is that the developer being so close to his own stuff, having stayed with his stuff for so long, fails to realize that his stuff may not be so familiar(a term better than intuitive) to other people.

(3) Still another reason is the developer lacks techniques.

MY BIG CLAIM: read any UI, human interection design, prototyping book. e.g. Designing the Obvious: A Common Sense Approach to Web Application Design, Don't Make Me Think: A Common Sense Approach to Web Usability, Designing the moment, whatever.

How do they discuss task flows? How do they describe decision points? That is, in any use case, there are at least 3 paths: success, failure/exception, alternative.

Thus, from point A, you can go to A.1, A.2, A.3. From point A.1, you can get to A.1.1, A.1.2, A.1.3, and so on.

How do they show such drill-down task flow? They don't. They just gloss over it.

Since even UI experst don't have a technique, developers have no chance. He thinks it is clear in his head. But it is not even clear on paper, let alone clear in software implementation.

I have to use my own hand-made techniques for this.

I try to keep in touch with design-specific websites and texts. I found also the excellent Robin Williams book The Non-Designer's Design Book ^[1] to be very interesting in these studies.

I believe that design and usability is a very important part of software engineering and we should learn it more and stop giving excuses that we are not supposed to do design.

Everyone can be a designer once in a while, as also everyone can be a programmer.

When approaching UI design, here are a few of the things I keep in mind throughout (by far not a complete list):

• Communicating a model. The UI is a narrative that explains a mental model to the user. This model may be a business object, a set of relationships, what have you. The visual prominence, spatial placement, and workflow ordering all play a part in communicating this model to the user. For example, a certain kind of list vs another implies different things, as well as the relationship of what's in the list to the rest of the model. In general I find it best to make sure only one model is communicated at a time. Programmers frequently try to communicate more than one model, or parts of several, in the same UI space.

• Consistency. Re-using popular UI metaphors helps a lot. Internal consistency is also very important.

• Grouping of tasks. Users should not have to move the mouse all the way across the screen to verify or complete a related sequence of commands. Modal dialogs and flyout-menus can be especially bad in this area.

• Knowing your audience. If your users will be doing the same activities over and over, they will quickly become power users at those tasks and be frustrated by attempts to lower the initial entry barrier. If your users do many different kinds of activities infrequently, it's best to ensure the UI holds their hand the whole time.

Read Apple Human Interface Guidelines ^[1].

I find the best tool in UI design is to watch a first-time User attempt to use the software. Take loads of notes and ask them some questions. Never direct them or attempt to explain how the software works. This is the job of the UI (and well written documentation).

We consistently adopt this approach in all projects. It is always fascinating to watch a User deal with software in a manner that you never considered before.

Why is UI design so hard? Well generally because the Developer and User never meet.

duffymo just reminded me why: Many Programmers think "*Design" == "Art".

Good UI design is absolutely not artistic. It follows solid principles, that can be backed up with data if you've got the time to do the research.

I think all programmers need to do is take the time to learn the principles. I think it's in our nature to apply best practice whenever we can, be it in code or in layout. All we need to do is make ourselves aware of what the best practices are for this aspect of our job.

What have I done to become better at UI design?
Pay attention to it!

It's like how ever time you see a chart on the news or an electronic bus sign and you wonder 'How did they get that data? Did they do that with raw sql or are they using LINQ?' (or insert your own common geek curiosity here).

You need to start doing that but with visual elements of all kinds.

But just like learning a new language, if you don't really throw yourself into it, you won't ever learn it.

Taken from another answer ^[1] I wrote:

Learn to look, really look, at the world around you. Why do I like that UI but hate this one? Why is it so hard to find the noodle dishes in this restaurant menu? Wow, I knew what that sign meant before I even read the words. Why was that? How come that book cover looks so wrong? Learn to take the time to think about why you react the way you do to visual elements of all kinds, and then apply this to your work.

However you do it (and there are some great points above), it really helped me once I accepted that there is NO SUCH THING AS INTUITIVE....

I can hear the arguments rumbling on the horizon... so let me explain a little.

Intuitive: using what one feels to be right or true based on an unconscious method or feeling.

If (as Carl Sagan postulated) you accept that you cannot comprehend things that are absolutely unlike anything you have ever encountered then how could you possibly "know" how to use something if you have never used anything remotely like it?

Think about it: kids try to open doors not because they "know" how a doorknob works, but because they have seen someone else do it... often they turn the knob in the wrong direction, or pull too soon. They have to LEARN how a doorknob works. This knowledge then gets applied in different but similar instances: opening a window, opening a drawer, opening almost anything big with a big, knob-looking handle.

Even simple things that seem intuitive to us will not be intuitive at all to people from other cultures. If someone held their arm out in front of them and waived their hand up-and-down at the wrist while keeping the arm still.... are they waiving you away? Probably, unless you are in Japan. There, this hand signal can mean "come here". So who is right? Both, of course, in their own context. But if you travel to both, you need to know both... UI design.

I try to find the things that are already "familiar" to the potential users of my project and then build the UI around them: user-centric design.

Take a look at Apple's iPhone. Even if you hate it, you have to respect the amount of thought that went into it. Is it perfect? Of course not. Over time an object's perceived "intuitiveness" can grow or even fade away completely.

For example. Most everyone knows that a strip of black with two rows of holes along the top and bottom looks like a film strip... or do they?

Ask your average 9 or 10 year old what they think it is. You may be surprised how many kids right now will have a hard time identifying it as a film strip, even though it is something that is still used to represent Hollywood, or anything film (movie) related. Most movies for the past 20 years have been digitally shot. And when was the last time any of us held a piece of film of ANY kind, photos or film?

So, what it all boils down to for me is: Know your audience and constantly research to keep up with trends and changes in things that are "intuitive", target your main users and try not to do things that punish the inexperienced in favor of the advanced users or slow down the advanced users in order to hand-hold the novices.

Ultimately, every program will require a certain amount of training on the user's part to use it. How much training and for which level of user is part of the decisions that need to be made.

Some things are more or less familiar based on your target user's past experience level as a human being, or computer user, or student, or whatever.

I just shoot for the fattest part of the bell curve and try to get as many people as I can but realizing that I will never please everyone....

I know that Microsoft is rather inconsistent with their own guidelines, but I have found that reading their Windows design guidelines have really helped me. I have a copy on my website here ^[1], just scroll down a little the the Vista UX Guide. It has helped me with things such as colors, spacing, layouts, and more.

I believe the main problem has nothing to do with different talents or skillsets. The main problem is that as a developer, you know too much about what the application does and how it does it, and you automatically design your UI from the point of view of someone who has that knowledge.

Whereas a user typically starts out knowing absolutely nothing about the application and should never need to learn anything about its inner workings.

It is very hard, almost impossible, to not use knowledge that you have - and that's why an UI should not be designed by someone who's developing the app behind it.

"Designing from both sides of the screen" presents a very simple but profound reason as to why programmers find UI design hard: programmers are trained to think in terms of edge cases while UI designers are trained to think in terms of common cases or usage.

So going from one world to the other is certainly difficult if the default traning in either is the exact opposite of the other.

To say that programms suck at UI design is to miss the point. The point of the problem is that the formal training that most developers get go indepth with the technology. Human - Computer Interaction is not a simple topic. It is not something that I can "mind-meld" to you by providing a simple one line statement that makes you realize "oh the users will use this application more effectively if I do x instead of y."

This is because there is one part of UI design that you are missing. The human brain. In order to understand how to design a UI, you have to understand how the human mind interacts with machinery. There is an excellent course I took at the University of Minnesota on this topic taught by a professor of Psychology. It is named "Human - Machine Interaction". This describes many of the reasons of why UI design is so complicated.

Since Psychology is based on Correlations and not Causality you can never prove that a method of UI design will always work in any given situation. You can correlate that many users will find a particular UI design appealing or efficient, but you cannot prove that it will always generalize.

Additionally, there are two parts to UI design that many people seem to miss. There is the aesthetical appeal, and the functional workflow. If you go for a 100% aesthetical appeal, sure people will but your product. I highly doubt that aesthetics will ever reduce user frustration though.

There are several good books on this topic and course to take (like Bill Buxton's Sketching User Experiences ^[1], and Cognition in the Wild ^[2] by Edwin Hutchins). There are graduate programs on Human - Computer Interaction at many universities.

The overall answer to this question though lies in how individuals are taught computer science. It is all math based, logic based and not based on the user experience. To get that, you need more than a generic 4 year computer science degree (unless your 4 year computer science degree had a minor in psychology and was emphasized in Human - Computer Interaction).

You mentioned the Don't make me think ^[1] book. I highly recommend reading this.

Let's turn your question around -

Are "ui designers" doomed to only design information architecture and presentation layers? Is there something they can do to retrain their brains to be more effective at designing pleasing and efficient system layers?

Seems like them "ui designers" would have to take a completely different perspective - they'd have to look from the inside of the box outwards; instead of looking in from outside the box.

Alan Cooper's "The Inmates are Running the Asylum" ^[1] opinion is that we can't successfully take both perspectives - we can learn to wear one hat well but we can't just switch hats.

I think its because a good UI is not logical. A good UI is intuitive.

Software developers typically do bad on 'intuitive'

A useful framing is to actively consider what you're doing as designing a process of communication. In a very real sense, your interface is a language that the user must use to tell the computer what to do. This leads to considering a number of points:

1. Does the user already speak this language? Using a highly idiosyncratic interface is like communicating in a language you've never spoken before. So if your interface must be idiosyncratic at all, it had best introduce itself with the simplest of terms and few distractions. On the other hand, if your interface uses idioms that the user is accustomed to, they'll gain confidence from the start.
2. The enemy of communication is noise. Auditory noise interferes with spoken communication; visual noise interferes with visual communication. The more noise you can cut out of your interface, the easier communicating with it will be.
3. As in human conversation, it's often not what you say, it's how you say it. The way most software communicates is rude to a degree that would get it punched in the face if it were a person. How would you feel if you asked someone a question and they sat there and stared at you for several minutes, refusing to respond in any other way, before answering? Many interface elements, like progress bars and automatic focus selection, have the fundamental function of politeness. Ask yourself how you can make the user's day a little more pleasant.

Really, it's somewhat hard to determine what programmers think of interface interaction as being, other than a process of communication, but maybe the problem is that it doesn't get thought of as being anything at all.

There are a lot o good comments already, so I am not sure there is much I can add. But still...

• Why would a developer expect to be able to design good UI?
• How much training did he had in that field?
• How many books did he read?
• How many things did he designed over how many years?
• Did he had the opportunity to see the reaction of it's users?

We don't expect that a random "Joe the plumber" to be able to write good code. So why would we expect the random "Joe the programmer" to design good UI?

Empathy helps. Separating the UI design and the programming helps. Usability testing helps.

But UI design is a craft that has to be learned, and practiced, like any other.

I think they are very different skill-sets. Good designers know about human behaviour, the psychology of colors and fonts, etc. I think it's like trying to be a marketing person and a developer at the same time. Very challenging but not necessarily impossible.

I'd try to find some UI experts and see what their study recommendations would be. Unless you are designing something very minimalist like google, if it is a significant project it is probably best to hire someone who has studied the art of UI as their main thing.

That said, if you are designing a very practical app, I think you could try to focus on simplicity and clarity in the interface -- I think this is at least half the key to google's success (and stack-overflow) -- i.e. it is intuitive and a pleasure to use.

Developers are not (necessarily) good at UI design for the same reason they aren't (necessarily) good at knitting; it's hard, it takes practice, and it doesn't hurt to have someone show you how in the first place.

Most developers (me included) started "designing" UIs because it was a necessary part of writing software. Until a developer puts in the effort to get good at it, s/he won't be.

To improve just look around at existing sites. In addition to the books already suggested, you might like to have a look at Robin Williams's excellent book "The Non-designers Design Book" ( sanitised Amazon link ^[1])

Have a look at what's possible in visual design by taking a look at the various submissions over at The Zen Garden ^[2] as well.

UI design is definitely an art though, like pointers in C, some people get it and some people don't.

But at least we can have a chuckle at their attempts ^[3]. BTW Thanks OK/Cancel for a funny comic and thanks Joel for putting it in your book "The Best Software Writing I" ( sanitised Amazon link ^[4]).

User interface isn't something that can be applied after the fact, like a thin coat of paint. It is something that needs to be there at the start, and based on real research. There's tons of Usability research available of course. It needs to not just be there at the start, it needs to form the core of the very reason you're making the software in the first place: There's some gap in the world out there, some problem, and it needs to be made more usable and more efficient.

Software is not there for its own sake. The reason for a peice of software to exist is FOR PEOPLE. It's absolutely ludicrous to even try to come up with an idea for a new peice of software, without understanding why anyone would need it. Yet this happens all the time.

Before a single line of code is written, you should go through paper versions of the interface, and test it on real people. This is kind of weird and silly, it works best with kids, and someone entertaining acting as "the computer".

The interface needs to take advantage of our natural cognitive facilities. How would a caveman use your program? For instance, we've evolved to be really good at tracking moving objects. That's why interfaces that use physics simulations, like the iphone, work better than interfaces where changes occur instantaneously.

We are good at certain kinds of abstraction, but not others. As programmers, we're trained to do mental gymnastics and backflips to understand some of the weirdest abstractions. For instance, we understand that a sequence of arcane text can represent and be translated into a pattern of electromagnetic state on a metal platter, which when encountered by a carefully designed device, leads to a sequence of invisible events that occur at lightspeed on an electronic circuit, and these events can be directed to produce a useful outcome. This is an incredibly unnatural thing to have to understand. Understand that while it's got a perfectly rational explanation to us, to the outside world, it looks like we're writing incomprehensible incantations to summon invisible sentient spirits to do our bidding.

The sorts of abstractions that normal humans understand are things like maps, diagrams, and symbols. Beware of symbols, because symbols are a very fragile human concept that take conscious mental effort to decode, until the symbol is learned.

The trick with symbols is that there has to be a clear relationship between the symbol, and the thing it represents. The thing it represents either has to be a noun, in which case the symbol should look VERY MUCH like the thing it represents. If a symbol is representing a more abstract concept, that has to be explained IN ADVANCE. See the inscrutable unlabled icons in msword's, or photoshop's toolbar, and the abstract concepts they represent. It has to be LEARNED that the crop tool icon in photoshop means CROP TOOL. it has to be understood what CROP even means. These are prerequisites to correctly using that software. Which brings up an important point, beware of ASSUMED knowledge.

We only gain the ability to understand maps around the age of 4. I think I read somewhere once that chimpanzees gain the ability to understand maps around the age of 6 or 7.

The reason that guis have been so successful to begin with, is that they changed a landscape of mostly textual interfaces to computers, to something that mapped the computer concepts to something that resembled a physical place. Where guis fail in terms of usability, is where they stop resembling something you'd see in real life. There are invisible, unpredictable, incomprehensible things that happen in a computer that bare no resemblance to anything you'd ever see in the physical world. Some of this is necessary, since there'd be no point in just making a reality simulator- The idea is to save work, so there has to be a bit of magic. But that magic has to make sense, and be grounded in an abstraction that human beings are well adapted to understanding. It's when our abstractions start getting deep, and layered, and mismatched with the task at hand that things break down. In other words, the interface doesn't function as a good map for the underlying software.

There are lots of books. The two I've read, and can therefore reccomend, are "The Design of Everyday Things" by donald norman, and "The Human Interface" by Jef Raskin.

I also reccomend a course in psychology. "The Design of Every day Things" talks about this a bit. A lot of interfaces break down because of a developer's "folk understanding" of psychology. This is similar to "folk physics". An object in motion stays in motion doesn't make any sense to most people. "You have to keep pushing it to keep it in motion!" thinks the physics novice. User testing doesn't make sense to most developers. "You can just ask the users what they want, and that should be good enough!" thinks the psychology novice.

I reccomend Discovering Psychology, a PBS documentary series, hosted by Philip Zimbardo. Failing that, try and find a good physics textbook. The expensive kind. Not the pulp fiction self help crap that you find in Borders, but the thick hardbound stuff you can only find in a university library. This is a necesesary foundation. You can do good design without it, but you'll only have an intuitive understanding of what's going on. Reading some good books will give you a good perspective.

If you read the book "Why software sucks" you would have seen Platt's answer, which is a simple one:

1. Developers prefere control over user-friendliness
2. Average people prefere user-friendliness over control

But another another answer to your question would be "why is dentistry so hard for some developers?" - UI design is best done by a UI designer.

http://dotmad.net/blog/2007/11/david-platt-on-why-software-sucks/

UX Design and software development are by no means mutually exclusive skills. On the contrary, they both require common sense and logic, attention to detail and being able to see the big picture. So, if you are a good developer chances are you can become a good UX designer!

They might appear mutually exclusive because many developers don't have experience in UX Design and vice versa. Also, if you start thinking of the architecture, framework or language before you think of the UX Design it might steer you in the wrong direction.

Left brain versus right brain. Some people don't have an artistic sense.

I would bet that anyone could get better at designing interfaces by study and diligence. That doesn't mean you'll become a first-rank artist or designer.

I think it's always possible to improve.

UI design is more art than science, and requires an understanding of your users and an ability to empathise with them.

This is very different to talking to a computer all day.

I don't think that people always realise this.

Here's a little self-test: Have a look at the FamFamFam silk icons ^[1]. Think about which icon you'd choose to represent various functions in the last application you wrote. If spending more than ten minutes doing this makes you eyes start to glaze over then UI design probably isn't for you.

It is all about practice, a bit of training and retrospective. But most back-end developers work in an environment where good UI-design is not really valued by management.

Organize a few coding dojo's around UI design after you've read a bit of literature on it.

I know that when I produce a crappy UI, it's almost always because I get too "zoned in" on particular parts of it.

During developing and testing a given feature, I'll almost always be using it lots of times.

After I've checked it out a dozen times, I'm in a frame of mind where I know exactly what I am trying to do and exactly what I need to do to make the program do what I want. I also and viewing this particular piece functionality all by itself, over and over until it's "done". I quickly blast past the rest of the app/menus/workflow/whatever while I am testing.

The user is not in the same situation at all. They are are not viewing this piece of the software as an independent "chunk". They are not always doing it lots of times, and when they are doing it often, they certainly aren't doing it by ITSELF often. They are not "skipping" the rest of the process and focusing on this piece the way the developer does.

It's important to try to look at a UI, then think "what am I supposed to do with this?". If it's not clear, you're doing it wrong. We are in a situation where we KNOW what input the software wants, and we just figure out a way to get that input. The user is in a situation where they want some result, and they want to know what they have to do it to get that result.

users think top-down, while programmers often think bottom-up when they get to the step of creating the UI.

We (programmers) are thinking so hard about creating a datamodel that will do the job, that will hold the needed data etc. We create the UI to map neatly to the underlying model. So much that we often we forget to look at how our users aproach the same task, and not getting into their flow and way of thinking.

It comes natural to us to expect the users of our system to think about the problem in the same way as us, how we store and process their data, and so also understand how the UI is expected to work.

This is often a mismatch to their view of (and expectations for) the task.

How to solve it? I think one way is to actually ask a (potential) user how they expect the program to work before ever showing anything to them. Never give them any hints on how we'd implement a feature. Prototype the UI on paper with them, let them tell you what they expect and need every step of the way. Never take anything for granted.

The palm pilot was designed in a more top-down way:

Before starting development of the Pilot, Hawkins is said to have carried a block of wood, the size of the potential pilot, in his pocket for a week. ( From this article ^[1])

He'd simulate what to do on the piece of wood, not thinking about how it needed to be implemented as code. Every time a new idea came along, he would "try" it out on is piece of wood.

Of course you'll need some guidelines on how to deal with some of the ideas you come up with, and maybe not all of it needs to be addressed, even if we technically can...

See bulletpoint 1 (Eliminate options) and 3 (Underpromise, overdeliver) here. ^[2]

A decade ago, I really sucked at UI design... I guess what helped me become better with the years was a healthy combination of humility and striving for perfection.

Bottom line: Never become too satisfied with your past or present achievements. Learn from your own and others' mistakes.

I use what I call the Grandmaw test.

• If your dear old Grandmaw can't use it, there's a problem.
• Presupposing she knows what the program's about, e.g., knows how to do taxes and is trying to use Quicken.

Just like with music: Sometimes people can be technically great musicians, but not be artists. My rule of thumb is always present the user with only the UI they need at the time. I notice a lot of back end developers flooding the screen with every option imaginable when they do a UI. While those type minds like to have all the details first and slowly ignore what they don't need, that doesnt work for most end users.

A good book that provides lots of thoughts on user interface and its importance is In the Beginning was the Commandline ^[1] by Neal Stephenson. Not everyone needs a GUI, just a lot of people who don't program. It's like the difference between DisneyWorld's Animal Kingdom and the actual Amazon.

"good ui design" is actually two problems ^[1]:

1. getting the right design
2. getting the design right

both are hard problems. in my experience the two things should be explored in parallel, as to not get ugly surprises late in the project ("why is our sexy drag&droping ultra-slow in IE8?? what do you mean it's not fixable???")

to get the right design you will have to explore posibilites. books can guide you towards trying out things that make most sense for your cicumstance - experience is even better, of course. also you absolutly need feedback from real users - how else would you find out that the design is already right? (you certainly can't tell.. read on!)

"getting the design right" then is the next problem, as it means the design you found appropriate must be implemented.

those "user experience / gui" things are so hard, because finding the right answer involves understanding what humans want - which they can't objectivly tell you and you on the other hand can't find out from "the outside". this means an (experience-) guided trial&error approach is the only way to go.

to more clearly answer your question:

why is good ui design so hard for some devels

for hardcore developers a big problem is, that their understanding of how the software works is so very different from how the users think it works (for example the URL "www.stackoverflow.com" should be written as "com.stackoverflow.com", if you know anything about how DNS works. but try selling a browser that expects URLs it like that :)).

as a sidenote: I would suggest you look into "experience design" rather then "user interface design", but that's another story.

Eating your own dogfood is actually not quite the best way. The lack of focus on user concerns while true is not the whole story either. The same with growing distant from normal user concerns as your expertise grows. Most developers I know want to do a good job in creating software that solves problems.

Where the disconnect occurs is in failure of imagination. The inability for us as human being to think of all the possibilities and combination. Sure we try to overcome this with "better" methodologies.

The only way I found that works is putting myself in line of fire in receiving user feedback. This way I LEARN about the problem I am solving, not just once but on a continuing basis as users use my software.

This is not easy solution. You have to not only be a good programmer but also good at X with X being whatever problem you are trying to solve. By being good at X you can the needed experience to understand the possibilities and limitations. You can start accounting for that in your code resulting in more polished software both in the features you offer and the in the design of the UI.

It not about retraining your brain but gaining the experience needed to effectively solve the problem. This especially true if you going something brand new like Stack Overflow where the experience can only be gained if you are the line of user feedback.

Design it for your Mother.

Part of the answer is that UI design is much harder than it looks, just as coding is much harder than it looks to designers. The two worry to very different degrees about very different things, and this, apart from the obvious differences in approach and skills needed, causes them to focus on problems that are invisible to each other.

I've found that it helps to describe my app and how to use it to someone without any visual tools whatsoever. It helps focus on what is actually necessary and important and feeds back what can be comprehended quickly by another person. I can do this even before I have a line of code, so it's very cheap to do and doesn't require any artistic skills. The other advantage is that verbalizing the app gets parts of my brain working that otherwise would remain dormant while coding and I can start to "see" the app work (or not work) as I talk.

"Is there something we can do to retrain our brain to be more effective at designing pleasing and useful presentation layers?"

Yes - use an interface driven architecture. First design a user flow from your business requirements --- then design your programming logic and databases based on your user flow. If you structure the mid-tiers and back-end as something designed to serve the front-end, then you'll have a user-centered app.

Programmers in general suck at UI design. There are designers that specialize in usability and UI design and they should be respected when it comes time to developing commercial software/websites/entertainment etc.

The problem most programmers have is that they can not look past their own noses and realize what makes things easier to understand and digest.

One of the best UI design principles is to always have an interface designed to be simple and accessible to your target.

A great and simple example is an elevator. Generally you press buttons to open/close the doors as well as traverse the floors of the building. Could you imagine if instead you had knobs and switches you had to flip to get from floor 1 to say floor 2? What if you had to slide a panel back to access three key switches with three colored keys you have to turn in a certain order to get to a certain floor?

You can quickly see how difficult a bad interface can be and how simple and usable a good interface is.

I believe that all CS programmers have the ability to produce good usable designs, because Usability Design requires developers to think along certain paths and rules. Whereas developing a good 'attractive' design can be near impossible for a some programmers. This does not mean that both are inexorably linked. Its like Mozart being able to write a beautiful piece of music and not being very good at football.

On the note of user feedback, Silverback ( http://silverbackapp.com/ ) is a great tool if you're on a Mac. I suggest creating a list of things to do (find this film, watch the trailer, find this film with this actor, purchase it, etc) and having the users sit there and go down the list.

The most important thing is to not tell them HOW to do it but to see how they accomplish the tasks (for the second scene, do they browse by actor or do they find the scene alphabetically?). You can start with non-tech-savvy people at your company and then get on Craigslist or hit the street and pay random people to test it.

I'll start by saying that I have similar deficiencies to those voiced by the question. Nevertheless, I think the only reason anyone would suck at doing anything is because:

• They didn't understand it and had never studied theory of how and why to do it
• They never practiced it enough to become an expert

So my advice is to first get the books and web pages you need that describe the subject and study them. Lots of good answers here on these, I would add Tog On Interface ^[1] to the list. Also look at those UIs that are considered great ^[2] like the Mac, IPhone and Google.

The second step is to just start creating UIs. This sounds easy, but if this is not part of your job description you may need to do this on your own time. Get involved in a web development project as the UI developer. Maybe its your own project or someone else's but getting good at creating web pages can give you the experience you need and should not be to hard to do. Good luck!

"What others have done to remove their deficiencies in this area?"
— Chris Ballance

1. Work with the least computer-savy-end-user you can find.
   (A fresh one, that's never seen your software).
   
2. Get feedback from them about what makes it suck for them.
   
3. fix those problems, take it to another computer-unsavy-user,
4. Repeat the process again..

When enough fresh-unsavy-users can use your product, you know you've done your job.

(Also your software will probably look alot like Microsoft's, and you'll probably not enjoy using it...)

But that isn't the point! The point is that the end-users can use it, and enjoy using it!

Not the developers!

Also read this post ^[1] I found it helpful in this arena. It basically states that you should give in to what the users seem to be wanting.

To put it another way...

You have to look at what the users are already trying to do...

The Sidewalk and the Students

There was a trail that was created by students walking to and from class on the campus where I went to college. When the school noticed the trail, they put up a fence where the people already walked. The school did the wrong thing. You want to put up a sidewalk where the students already walk instead!

Video Stores and Netflix

To give another example, think about recent video store history: A long time ago there were alot of video stores: Block Buster Video, etc...what did people not like about those video stores? Late Fees of course. So Netflix came along and removed late fees, since it was more of what the client/end-user wanted.

Now Block Buster is busting for bankrupcy along with all the other fee charing video stores.

Is it more difficult to do this? To turn your brain off and give the people what they want? Of course it is...it's bending your will to theirs...that's always more difficult, but in the end it's reaching the goal of giving the end-users what they want.

Is there something we can do to retrain our brain to be more effective at designing pleasing and useful presentation layers?

Yes. Watch users trying to use your software and don't help them. Also known as usability testing.

The basic idea of usability testing is that you take someone with a similar background to your target audience, who hasn’t seen your software before and ask them to perform a typical series of tasks. Ideally they should try to speak out loud what they are thinking to give you more insight into their thought processes. You then watch what they do. Critically, you do not assist them, no matter how irresistible the urge. The results can be quite surprising and highly revealing. Usability testing can be very fancy with one way mirrors, video cameras etc, but that really isn’t necessary to get most of the benefits. There is a good description of how to carry out usability tests in Krug’s excellent book Don’t make me think: a common sense guide to web usability ^[1]. Most of his advice is equally applicable to testing desktop applications.

I think the reason we can't design UIs is because we are perfectionists and just cant decide when good enough is good enough. I know I personally can't stand designing UI because I am always doubting myself and saying, "no, that's not good enough."

Something no one else has suggested but which help you immensely is to take a course (usually graduate level) in Human factors engineering. If you don't want to take the course at least go find the textbooks and read them.

I think part of it is because UI design and program design often have conflicting goals. When I program I often think "What is the easiest way to do this?". When designing a UI the easiest way is not always the most user friendly. If you do both you might have a tendency to choose the easiest implementation which negatively affects user friendliness.

I also believe programmers are too close to the product to see it from a user's perspective. What seems very easy and intuitive to the person programming the application may not be to a user. It's necessary to get a user's input.

UI design is also not something that is always right or wrong. Different people will evaluate a UI differently. For example some people hate the new "Ribbon" UI in Office, some people love it. Some people think Apple's OSX UI is great, others don't care for it and find it difficult to use. No matter what UI you come up with you will have people who don't like it.

Easy.

Developers aren't designers. They haven't trained or attempted to learn about design, so why should they be good at something like UI design? It's almost the same as saying "why is accounting so hard for some developers?"

UI Design is essentially Design and Design is a visual representation of rules. Being good at design means that you understand why something should look, act and behave in a certain way (e.g. why links should be highlighted or why a header should be at the top of a page).

Design and Development are two entirely different beasts, but both require background knowledge and practical work. If you're not willing to put in time with one of these subjects then you simply won't be very good at it, no matter how well you fluked one of your programs/websites into looking good.

Why is UI design so hard for some Developers?

That's a bit like asking why basketball is hard for footballplayers.

When developers think UI, they usually think the perfect widget they could use for this or this task (by widget I mean text area, combo box, so interactive Ajax search field...). UI, and more especially HCI, should be thought at a lower level. It is interesting to split the reflexion about the UI into 4 steps:

• Task and concept model: this is the most difficult to understand at a developer point of view. You must abstract from your reflexion all the idea you could have about the future platform, the language you could use. [ Paterno, 97 ^[1]] is the reference in this domain. You define your tasks as a tree, where tasks have sub tasks. Here an example for an export task.

• Then you define the abstract UI: this is about group tasks and subtasks into workspaces.
• Concrete UI: you can now decide which interactors use. You should now think about the platform (large screen, PDA, mobile phone...). Here is the key. Your task model and abstract UI can be factorized among several platforms.
• And the final UI, implemented in a chosen programming language.

Maybe because some developer start from Dos, and continue to partially work on command line OS.
Or because some of us writing software, because computer have some normal logic, not like human been. :-)

Because generally they are not UI Designers. Its a different skill. Thats it.

Because Its a different set of skill. Skills required to be a Web designer IS NOT the same as skills required to be a programmer. Yes few skills might overlap, like HTML, CSS, Javascript, but by nature Programmers know nothing of what makes a web design a good web design, and vice versa.

RWendi

UI design is a completely different skill. It is one closely related to visual art - being able to appreciate and create visual symmetry and beauty. And for WHATEVER reason, typically coders are NOT good with visual arts. I know there are exceptions - but as a general rule - it holds.

So really (unless you are the exception to this odd rule) - it should be dealt with like any other area where you are not naturally talented. You should evaluate if you can get along well enough with the chops ya' got - or maybe even spend a little energy improving, when you have a chance. However, you'd be better served developing the areas where you have ability and maybe seeking to work with people that are strong in the area where you do not..

A good book covering this idea is: Now, Discover Your Strengths by Marcus Buckingham ... it's an easy read.

ui design and software development work on two different sides of the brain. it isnt that a designer sucks at developing and vice versa, its just that they are trying to do it with the wrong side of the brain. no serious person would disagree.

I designed a program for people outside my social circle and observed their behavior. In doing this, I was no longer subject to the bias of my friends, and my own pride and ego. In improving the app, I became more humble and sensitive to the design issues. I learned the importance of task-oriented design, of simplicity. I learned the cost of having too many features. With experience, so will you.

Some references I highly recommend:

• joelonsoftware jef raskin's "the humane interface"
• robin william's "a non-designer's guide to design"
• most of the ui articles on alistapart
• jwz's blog on programming
• the apple human interface guidelines

Some references and philosophy I highly advise you to ignore:

• "themes"
• desktop applications in general, unless you need driver/filesystem access
• the idea that "more is better"