Skip to main content

Ralsina.Me — Roberto Alsina's website

Interface Designers and Free Software: A Realistic Proposal

A lot has been said in the last cou­ple of years about HCI and UI de­sign in free soft­ware, most of it damn­ing.

While such crit­i­cism has ba­sis in fac­t, it has usu­al­ly been writ­ten from the de­sign­er's side. The pur­pose of this ar­ti­cle is to ex­plain the way I, see things, which is, of course, dif­fer­en­t.

First, since this is my per­spec­tive, let me ex­plain you where I come from.

  • I am an am­a­teur. I en­joy pro­gram­ming. That's what am­a­teur mean­s.
  • In a scale of pro­gram­ming pro­duc­tiv­i­ty, 0 be­ing no code, 9 be­ing Tor­ben Weis in 1997, I am a 4 at best.
  • In a scale of pro­gram­ming knowl­edge, 0 be­ing a lawyer, 9 be­ing Don­ald Knuth, I am maybe a 3.
  • In a scale of pro­gram­ming skill (ie: pro­duc­ing pret­ty code), 0 be­ing da­da po­et­ry, 8 be­ing Matthias Et­trich, I am a sol­id 2.5.

So, why would my opin­ion be worth it? Well, let's put it this way, those who have a greater mag­ni­tude in their pro­gram­ming vec­tor [1] are prob­a­bly not go­ing to both­er writ­ing some­thing like this, be­cause they are busy, and they as­sume it's ob­vi­ous [2].

My the­o­ry is that ba­si­cal­ly two groups of well mean­ing peo­ple are talk­ing past each oth­er and driv­ing both groups mad in the process.

So, with that out of the way, let's get down to busi­ness.

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.

[1] Nerdy way of saying: better programmers
[2] One of the most annoying habits of programmers is overestimating other people's knowledge of their mental process. It's because they understand themselves.
[3] The reason why a designer usually disagrees with that is pretty simple, they define better in different ways.
[4] I am the happy author of 4 apps that have no users whatsoever beyond me. Happy as a clam!
Roberto Alsina / 2006-04-04 16:26:

Comments for this story are here:

Contents © 2000-2023 Roberto Alsina