The UI designer's case, as well as I understand it:

• Free soft­­ware's UI de­sign is poor, be­­cause it does­n't fol­low mod­­ern or ad­e­quate UI de­sign guide­­lines.

  In oth­­er word­s, be­­cause the UI is not de­signed by skilled UI de­sign­er­s, but by skilled de­vel­op­er­s.

• Since UI de­sign has to be im­­ple­­men­t­ed in code some­where, the coder should fol­low the de­sign­er's in­­struc­­tions with­­out ar­gu­ing (at least not much), be­­cause it is­n't prac­t­ti­­cal to ar­gue ev­ery­thing, spe­­cial­­ly since the de­sign­er has a core of knowl­­edge on the is­­sue the coder lack­­s.

• When a UI de­sign­er tries to re­de­sign such UI, or post an ar­ti­­cle ex­­plain­ing the is­­sues he find­­s, he usu­al­­ly is ig­nored or flamed.

• Usu­al­­ly, this will lead to said de­sign­er ei­ther grow­ing in­­creas­ing­­ly bit­ter, or make him de­­cide that free soft­­ware coders just don't get it. In both cas­es, usu­al­­ly the de­sign­er goes away, or be­­comes a heck­­ler.

As far as I can see, that rea­son­ing is 100% cor­rec­t.

The coder's case, as well as I understand it:

• Writ­ing free soft­ware is an in­cred­i­ble amount of work, usu­al­ly for no ma­te­ri­al gain.
• A pro­gram with a poor UI is bet­ter than no pro­gram at al­l.
• A pro­gram can be hard to use and still be bet­ter than an easy one [3].
• Be­ing told what to do is no fun.
• So, when some­one tries to tell the coder what to do, he usu­al­ly snaps a lit­tle, or ig­nores the noise, and con­tin­ues to pro­duce his sub­op­ti­mal-in­ter­face pro­gram­s.

And, of course, that rea­son­ing iss 100% cor­rect as well.

So, what?

In the fa­mous word­s, what we have here is a fail­ure to com­mu­ni­cate. As well as two groups of peo­ple with larg­er than av­er­age egos.

The coders have large egos be­cause they cre­ate stuff out of noth­ing. That does that to you. I know it.

The de­sign­ers have large egos be­cause they usu­al­ly see oth­er peo­ple im­ple­ment what they think. It's al­most the same syn­drome.

So, how can we get around this? I will just say what I think, I am prob­a­bly coder-bi­ased, al­though I am try­ing to be fair. So, if you dis­agree, just com­men­t, and try to be civ­il.

On the coder's side

• We don't know as much about UI de­sign as the de­sign­er­s. It's true, live with it. At least for good de­sign­er­s. We on­ly have em­pir­i­cal data, they stud­ied the is­sue. Re­spect that. We are not lawyer­s, ac­coun­tants, and we are not de­sign­er­s.
• Ac­cept­ed in­dus­try prac­tice is usu­al­ly right. So, don't try to get too cre­ative on UI. Bland is good.
• When a de­sign­er tells you about what's wrong in your UI, it's not per­son­al. If he's be­ing po­lite, try to en­gage him in con­struc­tive ar­gu­men­t. If he is not, then all bets are of­f, of course ;-) Some­times sim­ple changes do a lot. Ask him to help you fix the easy parts first.
• UI im­prove­ment will make your app bet­ter.

On the designer's side

• You are a late­­com­er. The app has a his­­to­ry, the UI prob­a­bly re­flects some in­­ter­­nal stuff that can't be changed. So, don't ex­pect that you can change ev­ery­thing. Try the small stuff first.

• There is a big emo­­tion­al in­­vest­­ment in the ap­­pli­­ca­­tion. I know it's not per­­son­al, but please, be ex­treme­­ly po­lite and care­­ful! This has to be em­pha­­sized: you will spend maybe 40 hours check­­ing the ap­p, the guy who wrote it may have spent 4000.

  Don't put down his work, make it bet­ter! Be pos­i­­tive! say "the app is nice, but if this was changed to that, it would be bet­ter"

• Fun­­da­­men­t. re­mem­ber the coder is not a de­sign­er. He lacks a core of knowl­­edge you have. On com­mer­­cial code, that does­n't mat­ter be­­cause man­age­­ment says they ahve to fol­low your guide­­lines. Here, you should give re­f­er­ences, how­ev­er broad to ac­­cep­t­ed in­­­dus­try prac­tice when­ev­er you can.

  "Hey that's bad" is bad. "What you do there is bad be­­cause it does­n't fol­low prin­­ci­­ple X" is bet­ter.

• You don't know as much about cod­ing as the coder. Even if you know how to code, you know lit­­tle about this code. Re­spect that. You are not a lawyer or ac­­coun­­tant and you are not a coder.

• Start smal­l. Sug­­gest sim­­ple fix­es, not huge over­hauls. Grad­u­al­ism is good. Some­­times changes that would pro­­vide a bet­ter UI would make the code much worse, and that will hurt the ap­p's val­ue.

• Get in­­­volved. If it's a KDE or Qt-based ap­p, learn de­sign­er, get the .ui files, and try to hack it to look and work bet­ter with­­out chang­ing the el­e­­ments. then you can try to pro­­duce a bt­ter de­sign with few­er or dif­fer­­ent el­e­­ments. That will be on­­ly a mock­­up, but it can ex­­plain your point of view bet­ter than word­s.

  In a fu­­ture, per­haps you can help from the be­gin­n­ing of the ap­p, in­­stead of join­ing late. Since the de­sign­er work is less time in­­ten­­sive, you could be UI de­sign­er for a dozen ap­p­s, while a coder hard­­ly has more than three pro­jec­t­s.

• Be pa­­tien­t. The oth­­er guy has worked on that thing for five years, you can wait a cou­­ple of months for him to fol­low your lead­­s. Read a book in the mean­­time!

• Don't be bossy. You are not his boss. You are his helper.

  In the com­mer­­cial world, the de­sign­er rules. Here the coder rules, be­­cause you lack means of co­er­­cion. Not even stuff like "noone will use that UI" work­s. [4] If he goes away, who's go­ing to im­­ple­­ment your stuff?

Other related issues

It has been said that the rea­son why the dog wags the tail is be­cause the dog's smarter. That's on­ly part of the truth. The oth­er part is that the dog has about 50 times the mass of the tail.

In the free soft­ware world, de­vel­op­ers out­num­ber de­sign­ers prob­a­bly by three or­ders of mag­ni­tude. So, de­sign­ers some­times feel a need to be shrill in or­der to be heard. While com­pre­hen­si­ble, it's not some­thing that will lead where you want to go. De­vel­op­ers can be as shrill as any­one you know.

On the oth­er hand, coders per­ceive de­sign­ers as bossy, and tend to dis­miss them as un­pro­duc­tive fuzzy art­sy type­s. While un­der­stand­able, it's stupid. They are skilled in oth­er ways than us, and are wor­thy. In fac­t, be­cause of the rar­i­ty of the free-­soft­ware-in­volved de­sign­er, they are to be cared for.

Coders tend to see some de­sign­er sug­ges­tions as sim­ple be­cause they are easy to im­ple­men­t. How im­por­tant can it be if it on­ly takes chang­ing a con­stan­t? Well, if it's so easy, why not do it?

De­sign­ers tend to see some coders ret­i­cence to change as stub­bor­ness. Why does­n't he change that con­stan­t? Well, have you told him why he should? And no, "be­cause I say so and I am a de­sign­er" is not good enough.

Now, all this ar­ti­cle sounds sus­pi­cious­ly like "why can't we all just get along?", and that's part­ly true. How­ev­er, why can't we? re­al­ly? I think I men­tioned some of the rea­son­s. Hope­ful­ly we can.