Benjamin Geer on Sat, 20 May 2000 23:56:24 +0200 (CEST)

[Date Prev] [Date Next] [Thread Prev] [Thread Next] [Date Index] [Thread Index]

[Nettime-bold] Re: <nettime> OFSS01: First Orbiten Free Software Survey]

On Fri, May 19, 2000 at 06:18:18PM -0700, Amy Alexander wrote:
> The project mailing lists are generally populated by programmers,
> not end users, with rare, apologetic posts from non-technical
> end-users.

A sad state of affairs, I agree, but one that could be remedied if
more end-users joined in.

> More than once I've written to the author of an open source program
> or posted to the mailing list, and said, "I've read the docs and
> haven't figured out - can it do so-and-so?" and had them respond,
> "Hey, great idea, why don't you write the code for that?"

True, this is the standard response, but there's a reason for that.
Since there are so few non-programmers on those lists, if you post
something, it's assumed (however rashly) that you're a programmer and
could therefore probably contribute the feature, if you were willing
to do so.  Many programmers are accustomed to seeing software as a
consumer product, rather than as the work of a community of which they
are a part.  When they encounter open source, they view it as being
exactly like commercial software, only free of charge.  And when the
software doesn't do what they want, they post messages to the list
asking the developers to add features, just as they do with commercial
software.  Since they don't have the reflex of thinking, `Could I add
this feature myself?', the standard response, `Please go ahead and add
it,' exists as an attempt to snap them out of their consumer mindset.

> Many open source apps seem to be written with little expectation
> that there *is* an end-user, except that the end-user him/herself
> might program something useful out of the source code. Maybe the
> end-user should be renamed the "end-programmer". :-) ...

It's true that a lot of effort has gone into writing software building
blocks (libraries, toolkits, etc.) in the past few years.  I think
there's one main reason for this.  People want massively distributed,
highly fault-tolerant systems that handle immense numbers of
concurrent users; they want this on slow, unreliable networks; and
they want it in three months.  To accomplish this, you need a high
level of cooperation between many different types of systems.  At the
same time, operating-system vendors and others have been selling
similar but incompatible tools in an effort to exclude one another
from the market.  This has made a difficult job nearly impossible.
The current widespread movement to create standards via consensus can
be seen as a revolt against this situation.  Once you have a standard,
you then have to spend a while writing tools that implement it.

> but, with the open-source stuff, there seems to be an inordinate
> percentage of apps that seem to be end-user apps on the surface, but
> which then turn out to be "some-assembly-required" sorts of things.

I can see a few reasons for this:

* A lot of projects never get finished, because the authors have to
  put them aside in order to do paid work.

* Most programmers are terrible at writing documentation, so a lot of
  projects are documented poorly, if at all.  (I'd say that the most
  frequent item in lists of `Things you could do to contribute' is
  `Write documentation').

* For some people, the fun ends when they've solved the basic problem
  involved in getting something to work.  Polishing it up so that it's
  easy for others to use doesn't interest them.  With luck, these
  projects sometimes get passed on to people who want to finish them.

> But another part of the problem may be cultural - meaning, geek
> culture.  Many a slashdot, et al, discussion has centered on true,
> pure, geekdom as meaning that one codes for the pure love of coding,
> not to achieve a goal.

Perhaps, but hacker culture also has the idea that programs should
`just work', that they should do the Right Thing, that they should
work `out of the box'.  Perl, one of the most worshipped open-source
programs, is permeated with this idea.  It's also expressed in the
efforts that have gone into creating ways for programs to adapt
themselves to the environment in which they find themselves (autoconf,
automake, etc.)

> one thing that's very significant here is that there is quite a bit
> of incentive in terms of ego gratification (and potential for career
> enhancement through reputation-building) for people who code things
> that are *not* for end-users, and not so much for people who code
> things *for* end-users.

I suspect that this is simply because there is a widespread (though
rarely stated) sense that operating systems and libraries involve (and
perhaps should involve) greater technical challenges than desktop
applications.  My own instinct tends to be that if an end-user program
contains a component that's very challenging to write, that component
should be moved into a library so it can be reused.

> All that said, the open-source movement seems to be waking up,
> albeit slowly, to the needs of the end-user. The article at
> entitled "It's the
> User, Stupid", was interesting.... It was ironically, posted on the
> website of sendmail, one of the most notoriously difficult-to-use
> open source programs....  c) The article, addressing basic usability
> issues, appeared in January 2000. Just curious - what took them so
> long?

They were probably avoiding the issue because they know that, in the
case of sendmail, user-friendliness is a lost cause. :)

But why not consider KDE or GNOME, two high-profile projects that have
made huge efforts to appeal to non-technical users?


Nettime-bold mailing list