
Open source needs designers - benwerd
http://benwerd.com/2011/06/open-source-needs-designers/
======
kolektiv
I think from the designers I know and from my distant former life as a
designer before I ended up as a CS guy, it only really comes down to one
thing:

What's in it for a designer?

* It's not scratching an itch that they have.

* It's not great promotion (design has worked on a portfolio system for generations, so they have them already - showing someone what you've built is new and revolutionary for development in relative terms, but for design that's just how it is).

* It's probably not much fun (it's a skill to work with designers and to manage a project such that it comes out well - one that most OS projects do not possess if I had to guess).

* It's probably quite thankless (by no means a universal attitude, but plenty of developers think of design as an add-on, or a nice to have - not much of a situation to be in with your work).

So why would designers volunteer for this when they could do work for
themselves and their portfolio that they may actually enjoy? How many projects
will provide enough exposure to make this a good use of time?

~~~
lovskogen
I do design for open source projects, I've started helping out on the Gnome
Project doing interface design.

• It's great for scratching an itch of 'I want to help other people'.

• It can be good promotion. The same way a good github account can help
developers, stating and showing how you have participated on a open source
project that is _real_ is good for showing you can pull through on projects
and deliver.

• It can be great fun to see something you designed being implemented and
working. Even more fun if people praise you for your great solution to a
problem. The thing with doing FOSS as a designer, you have to take alot of
control - and push for developers to code your design. It's not just
delivering a PSD, you have to _work_ with the developers.

• If you solve a real problem, people will thank you.

~~~
eropple
Everything in your post is the absolute best case.

It can easily go the other way and your contributions can be ignored and never
used, you will be reacted to with hostility by developers who think that
design is an "extra" feature, and that even if you do succeed and something
you do does hit a release, the overwhelming majority (nearly all) of people
who use the software won't know you exist.

There are two sides to open-source development (at least, when it's not with
people you know personally IRL) and one is, sad to say, generally not very
pretty. Institutional hostility toward non-programmers still lives in a lot of
open-source projects--usually the ones who need them the most!

(EDIT: Mind you, this isn't a reason to not at least try to contribute if you
feel it's important to you, but the results are often not as rosy as your post
suggests.)

~~~
gte910h
You are aware _absolutely_ everything you wrote is the same for developers
too, even the programmer part;I've seen hostility towards people offering
patches who are more users than programmers.

That's contributing to other people's projects period.

OSS is about scratching an itch, releasing code your business does but does
not need to protect, or about self-gratification. While it can be a showpiece,
you never get much in the way of fame out of it, no matter what you do.

~~~
eropple
Of course. Incidentally, Mono aside (and that was a special case), it's why my
own open-source projects are the ones I choose to contribute to.

------
iamcalledrob
Open source really doesn't want designers.

They want people to make things pretty, and there's a big difference.

Bringing a competent designer on board means bringing a strong opinion on
board.

Someone who'll probably decide to cut 90% of the features.

The problem with most open source projects is everyone involved has an opinion
that they'll fight for, so you end up with 1000 features, designed by a
committee of developers (see the Linux desktop)

~~~
tsuraan
You make it sounds like if Autocad had involved a designer in the process,
they would have wound up with google sketch. Sometimes things need to have
features, even features that 90% of users won't need 90% of the time. A good
designer shouldn't be the person who decides to cut features, he should be the
person who figures out how to keep the features, but in a manner that allows
new users to start with a minimum of pain, and expert users to keep growing
into the product. That's hard work, and it takes a lot of cleverness and
creativity, but I think anybody willing to do that work would be welcome in
any sane open source project.

EDIT: on re-reading my post, it looks like I'm saying Autocad didn't have
designers, which is completely the opposite of how I feel. What I was trying
to get it is that (IMO) Autocad is an amazingly approachable product with tons
of features, just presented in a way that isn't terribly daunting to a new
user.

~~~
iamcalledrob
The people who use AutoCad most likely use it for a living, and the time
investment in learning the UI is probably worth it.

I feel the same way about Photoshop. People spend time learning its quirks
because it's worth it.

However, realistically 90% of the features could be cut and it'd be for the
good of the product.

The problem in the software industry (and this is not limited to Open Source)
is that people like long feature lists.

This is especially important if you're a Photoshop or an AutoCad. You need new
things for the new version.

------
enra
I've been thinking of helping open source project as a designer but I don't 1)
which 2) how.

1) Most of the software I use is commercial or already well designed(OSX/iOS),
so I don't really have a personal itch to fix something I use.

2) I'm familiar with web technologies, git and development environments but I
think the problem is politics or communication. I imagine it's lot easier to
pull a repo, refactor a bunch of code and get it patched, than it is to submit
a remake of the UI and get it on the product. Somebody probably likes the old
one more and feels the 128 menu options where there for a reason.

I already have enough politics on my day job, so arguing on with developers on
open source projects doesn't sound that inviting. I might be wrong, but it
just doesn't seem like that designer friendly environments and maybe lacks the
process/tools to be that.

~~~
olalonde
How about you start your own open source project as a designer and try to
recruit developers to do the coding? Never seen this approach before but it
might be worth trying.

~~~
jerf
A common myth-let is that you start an open source project and people just
come streaming out of the woodwork to work on it. The reality is that you are
in stiff competition with thousands of projects for relatively rare resources.
The global outcome is good, the local outcome is generally developer
starvation. A developer with little more than mockups and no code to speak of
is not going to win this competition, even with a truly stellar mockup.

------
pseudonimble
Unfortunately design is best when it is totalitarian. Good design comes from a
core visionary entity, not a committee. This way of working seems incompatible
with open source, because developers volunteering their time don't want to be
told what to do.

~~~
tomaskafka
+1

------
tomaskafka
I tried helping the Wordpress comunity with this Google Summer of Code entry
for Android blogging app redesign:
[http://tomaskafka.wordpress.com/2011/04/08/wordpress-for-
and...](http://tomaskafka.wordpress.com/2011/04/08/wordpress-for-android-
concept-for-gsoc-2011/) . I based the design on taking the most common
requests and complaints from Android Market reviews, mixed with so successfull
'post anything fast' model of Posterous.

The mentors chose this joke of a buzzwords and a brainless copy of Facebook
(Facebook has dashboard with 9 buttons therefore my app will have 9 functions
and it is a good UX) instead:
[https://anirudhspider.wordpress.com/2011/04/01/version-2-wor...](https://anirudhspider.wordpress.com/2011/04/01/version-2-wordpress-
android-app-ui/)

The code of app was terrible - mashup of business and diplay logic organized
as 1 screen = 1 class. I recognized that to decouple business logic from view
and enable different screen flow, splitting into proper MVP layers would be
needed - and offered to do the refactoring as well.

I tried - never will again. Open source my ass.

------
monkbent
Open source doesn't (just) need visual or interaction designers. It needs
product designers. I.E. people who say no. Needless to say, given the reality
of FOSS, that's not going to happen.

~~~
sc68cal
You must have missed out on last weeks posts about PHP internals devs saying
no to practically every enhancement. Including enhancements with patches
ready.

------
lovamova
Designers like to come up with one piece of design, not working on different
little design changes wanted by an entire community of open source developers.

Designers like to design one product and expect developers to follow suit, not
the other way around. This doesn't happen in the open source world.

~~~
lovskogen
It's a great challenge to better the user experience on a small problem. Alot
of designers would love doing small 'papercuts'. I don't think your statment
that designers _just_ love redesigns or complete products holds true.

~~~
gte910h
I think many designers do not know how to be really collaborative. They don't
know how to bend their design to development realities and do cost-insensitive
things all the time.

I do professional iOS development all the time, and have had the pleasure of
working with some really good design teams while working, who are there the
entire process, but I've also had the occasion when a design is handed down by
"god" and they won't do a damn thing to adjust to what's actually possible or
doable.

The communication style of designers also irks the hell out of developers.
There is argument by emotion, argument by reputation and argument by logical
reasoning. Most devs do the latter as a default thing. Many (I'd probably not
say most) designers shoot at repuational argument overly quickly, relying on
inchoate notions of things they can't really verbalize well.

The fact one side is saying "Trust me, look at all the stuff I've done" and
the other is saying "But this is that way and that is this way" leads to a
horrid clash of communication style. This is only exacerbated via email, which
is how much OSS gets done, as email is exceedingly logic based.

~~~
lovskogen
You can't be a good designer without knowing your format. And working with
those would seem like hell, I guess.

~~~
gte910h
That's the issue though, you can't really learn the format without doing work
in it.

There needs to be a "Oh, pushback, let me listen then change things" that many
people lack when they're not experts in the area.

That said, there are people who listen exceedingly well when they're not
experts and are a pleasure to work with.

------
andos
_[W]hile NetBeans and Eclipse feel engineered, Coda feels designed._

The comparison between Eclipse/NetBeans to Coda is problematic. The OP
downplays the importance of who those apps were created for, when that is a
fundamental part of the design process. Both Eclipse and NetBeans are just as
designed as Coda, but not for web developers. Take the “Refactor” menu in
Eclipse, for example: it feels like someone is saying “We know how miserable
you feel that the code sucks right now and how hard it is to improve it. Here,
have these amazing tools and fix it.” For a Java developer, having a refactor
do in seconds what would take a whole day _definitely_ has emotional
implications in the visceral, behavioral and reflective levels. If that does
not resonate with the OP, well, that’s because he doesn’t have the same
sensibilities and issues a Java developer has, not a inherent fault of
Eclipse.

 _[O]ver 80% of Linux kernel contributions are made by corporations, so it’s
reasonable to infer that most open source software is built to feel an
internal corporate need. Consequently, interaction design is underrepresented
in open source._

While it’s certainly the case that open source has a lot of interaction design
issues, the who-what-why-how of the kernel are not the cause. The Linux kernel
is the least user-facing component of the typical OSS stack. As Linus points
out in an excellent chat with Greg Kroah-Hartman¹, there is very little left
the Kernel developers can do to help the typical user. The problem is in the
“userland”.

 _Part of the problem is market. To be blunt, commercial software needs to
sell, and usable interfaces are an integral part of that._

OSS needs to “sell,” too: it must be adopted by a community and, in some
cases, it must find a corporate sponsor. One may argue that OSS _projects_ are
started to solve the problems of a single person, but the ones that become
_products_ must have seen wide adoption. Good interaction design is, just as
for commercial software, another selling point. At the same time, terrible
user experience is democratic. There are loads of unusable commercial and open
source software available.

What open source really needs is not (just) designers, but _design_. Good
design can only happen when people with a strong hand, a vision and any kind
of design sensibility are in charge. And that’s true for any kind of software
product, not just OSS.

¹. <http://www.youtube.com/watch?v=__fALdvvcM0>

~~~
wpietri
I totally disagree with you on Eclipse. I've used both Eclipse and IntelliJ
IDEA extensively for Java work, and the user experience on IntelliJ IDEA is
way better and has been for years.

A couple times I've talked to Eclipse committers in detail about UI problems
and what I get is either denial that there's a problem or an answer like "Oh,
yeah, I guess we should do a UI sweep sometime." I'm sure Eclipse seems fine
to the people who make it, but that's true of almost any terrible UI. Most
people stop at "looks good to me," rather than going for, "tested to work well
with the target audience".

~~~
andos
My point was that Eclipse and Netbeans (and IntelliJ IDEA) cater to a specific
public with specific needs and that public is not the same as Coda’s. To
compare the experience of using Eclipse and Coda is questionable and to argue
that Eclipse does not “feel designed” is absurd.

I never said Eclipse had better or worse UX than IntelliJ IDEA. This is not
what the OP is about.

------
wpietri
Wow, I totally disagree with the thesis of this article. Open source doesn't
need designers, not in the sense of a job role.

At most companies, a "designer" is a person who by definition doesn't make
anything directly useful. They produce documents describing how they think
other people should make things. Much of the time their designs only get
executed because somebody with power over paychecks tells developers to obey.
But most open source doesn't work like that. Nobody can order a volunteer to
do things differently.

What open source needs is for developers to understand designing for people.
For user-facing apps, the point isn't to write code, it's to make something
that people use and love.

To aid in that, we could certainly use help from user researchers, so we get
feedback on what's working and what isn't, and get enough data help us think
about solutions. And maybe we can use help from consulting designers when we
need help with a problem. But I don't think we need designers as such, any
more than we need managers.

~~~
pessimizer
I feel like this is the attitude that drives good designers away from open
source projects - the attitude that they are swooping in after the fact to
destroy the hard work of intelligent programmers. If you instead see designers
as intelligent people who chose to specialize in understanding and translating
raw "feedback on what's working and what isn't, and [...] data" and time-
tested design concepts into a final product that ties the chops of programmers
with the actual human-centered goals of projects, it may result in better
software.

Are we really trying to, for random example, create a protocol for
individually and consistently addressing nodes securely within an ad-hoc mesh
network of inconsistent size which needs to route requests to one or more
gateways to the larger internet, OR are we trying to help average people
create their own neighborhood networks where they can share services?

I submit that we're doing the latter, and the hard problem in order for
programmers to facilitate it is the former. As a programmer, I stumble across
magnificent libraries bitrotting on various parts of the internet that
sometimes do things that I wouldn't even have imagined possible, yet no one
but hobbyist techs will ever use them until they are integrated onto the
backend of something that designers somewhere created to scratch a person's
itch, not a programmer's. The big problem: when will a designer ever be
meandering around the depths of CPAN or an aside on some obsessed functional
programmer's blog?

To be even more extreme, I'd like to see more projects primarily headed by
designers or end user types, ones with little to no technical knowledge and a
healthy respect for people who do. As a programmer, I pride myself on telling
people the best way that things can be done with a computer, not what people
should want a computer to do and how they would like the computer to do it.

Seriously, the less I have to think about ui, especially in the context of
projecting myself into the mind of somebody who isn't clear on the difference
between a directory and a file, the better. Background shit that automagically
runs with no interaction? Love it. Something that helps grammar school kids
collaboratively research their school projects in a transparently sourced way?
Somebody please draw me a picture, tell me where to put the buttons, and tell
me what they should do. And even though I've written an awesome algorithm to
realtime index and classify the contributions of the individual students and
make suggestions about who should be assigned to clarify a portion of the
outline based on keywords and library proximity - tell me where to put it, or
whether I've been wasting my time and that no one needs it. I don't have to
have a big red button on the toolbar. I'm smart, I can certainly use the
algorithm for something else.

Sorry for ranting:)

------
trustfundbaby
I've always wondered about this, and the conclusion I've reached is that we
don't have more designers contributing to open source because

a. we developers don't make it easy for them to do so.

b. designers don't care about our projects.

For example, look at wordpress ... you can go in and create a theme ... today,
if you'd like to, as a result there are tons of free themes out there, but how
would a developer go about creating a Netbeans theme?

Also, most open source projects are created because a developer wanted to
build something cool for themselves ... and it isn't often that designers find
those sorts of things cool as well so of course they're not going to be
designing cool ui for those things

The first is solvable ... devs need to make a concerted effort to reach out to
designers, outline a design process (send us a psd of your design, we'll go
over the details in basecamp/unfuddle/whatever and you can provide direction
as we go) ... I can't see much being done about the second.

~~~
jordank
I actually tried to contribute interaction design to to Elgg (referenced in
the post). I spent some hours on concepts and got almost no response on the
forums. Hindsight is 20/20 but I've found that some open source devs aren't
that excited about people who add scope but can't make huge contributions code
wise.

------
iambot
i agree, I’m a designer and have been offering to fork open source projects
here and there for a bit, but i think its a thing that the community has to
adopt. its getting there though. developers also need to come to terms with
the fact that just as a project needs great coding (by a dev) many projects
need great design (by a designer)

~~~
ThomPete
My experience from starting WeekendHacker is that developers do know they need
it.

In fact I have a lot of developers asking for design help (and luckily vice
versa)

The format I use is a little more free form and it's curated which I hear a
lot of people say help a lot.

Plus projects are fresh.

I have also tried to involve myself in OSP over the years.

The problem at least from my experience was that while developers have a clear
process on how to work together amongst themselves. While they have created
their own lingo. It doesn't really include the design process (unless they
like me want to learn how to use GitHub) and how that ties into development.

There is clearly a disconnect between the two disciplines and I have yet to
find a tool to allow for easy transcendence. You can't in my experience use
the github principles for versioning of design, since iteration works
completely different for most designers.

I have a couple of ideas of how that could be done, maybe I should start a WH
project :)

~~~
gte910h
Thom, I work with designers and git all the time (iOS dev)

Git does work for the design files (however less well than with the text the
programmers work with).

I'd say generally speaking, it works better if you do design and cutups for a
programmer who then implements a fork. He then submits the fork to the project
to be merged in to the main project if the rest of the implementors agree.

Gotta find a front end programmer who likes you and thinks you're doing the
right thing for that to pan out well.

~~~
ThomPete
It works when I have cut out the files and do the CSS/jQuery etc.

But my point is more about about design iterations within photoshop, fireworks
etc.

Obvious problem is file size. It's going to be interesting to see whether
LionOS will allow for some sort of integration with GitHub that allow for
this.

~~~
gte910h
The files are large, for sure, but not _that_ huge. Is there some file size
limit killing you or something at github in particular?

Or are you just referring to transit time (aka upload/download time)?

~~~
ThomPete
Not just that, although that is a problem IMO especially with PS where the
files can get very big.

But also just a problem of state.

A lot of designers who use PS use layers and groups to show different
scenarios within the same file.

But as I originally stated.

The reason why many designers don't joing these projects is because it doesn't
take their way to work into account.

Yes you can learn to use Github or other versioning tools but that's not good
enough if you ask me. Especially if you want to have more designers to
participate.

~~~
gte910h
Yeah, the everything in one giant file thing is a big problem for
collaboration in general (even among designers).

I thought the reason many designers don't join the projects is because many
technical people are surly when you try to tell them to put things here and
here and here... etc.

It's not like you can't share a dropbox folder then occasionally check into
the code base, or never check in the PSDs at all.

------
psweber
It might be helpful for developers to have a better idea of the type of design
they need for their project. In my experience, when most people talk about
designers, they are talking about visual designers. Open source needs help
with visual style, layout, graphic elements and branding, but I feel that
UX/interaction design is needed much more. Designers are rarely masters of
both disciplines.

------
sc68cal
The author states in the opening paragraph that he has slowly been migrating
off Eclipse, to Netbeans, now to Coda!!?

Seriously, what was he using Eclipse and Netbeans for if Coda is a migration
path. Stating the obvious: He clearly wasn't doing any heavy duty coding. Talk
about using a sledgehammer instead of a fly swatter.

------
tobylane
There are designers that make pretty interfaces (last I saw Xfce needed some
of them, and there are designers who make images (like OpenTTD replacement of
the original game files). Yes, both are needed, but most designers go towards
making websites or something else over-subscribed.

------
rch
This is a great topic, but who are the designers that developers really need?

I don't see any portfolio links in the comments yet...

