---- Original message ----
>Date: Tue, 6 Nov 2007 14:16:05 -0500
>From: Tim McGeary <[log in to unmask]>
>Subject: Re: [CODE4LIB] Library Software Manifesto
>To: [log in to unmask]
>I think this depends entirely on what type of developer we are talking
>about.  Let's say it is a large ILS vendor who promises that their
>software will do all things for all types of library.  When a promised
>feature or a discovered bug that only applies to a small subset of their
>customer base (let's say academic or public or government) is found, the
>reason that is does not benefit a large enough community to put the
>expense is simply bogus.

At some point there simply isn't enough time/money etc.
I think the flaw here isn't in priorities, but in the vendor
being too broad in the first place.

The drive of my point is more is that it's bothersome when a
developer honestly decides that they cannot do the feature
with their given resources.  Then a customer pulls some
strings and the manager tells them they have to get it done
anyhow.  Do this consistently and you start seeing things like
training, support, and internal organization slip as you have
developers waiting for the "next sign from above".  It's too
dangerous to try to stick to schedules because of the
likelihood of disruptions.  I've had to deal with similar
situations from several sides of the issue and it can be
extremely frustrating.

I'm not advocating that the number of people always be the
sole basis of adding a feature of fixing a bug.  I'd
advocate a more complicated algorithm, similar to ones I've
seen advocated by most software design  books.

This would count a couple of factors
* Number of people affected
* Severity of problem
* resources required to solve problem
* risk of not solving problem

I've seen some differentiate this from severity, usually
taking a more business like approach.

So, maybe there's issues with screen readers.  This affects a
very small group of users.  However, the impact on those
users is quite severe.  On top of that, it's likely an
indicator of bad design since other tools.  The risk of not
solving the problem is also quite high from a legal

Compare this with some feature request that might really only
apply to a small group, but has a workaround, even if
uncomfortable.  The severity is low, since they have an
existing workaround.  They're the only ones who want the
feature.  The cost of fixing it might be high, since it
requires some redesign.

>The end result is that type of library essentially sitting on a product
>for years because there is no commitment to improve their service in
>their future.  This is happening frequently with "new" products that are
>introduced (at least in my ILS community) which, while are sold as
>usable to all types of libraries, are clearly designed for one specific
>or their largest base in mind only.

This is a huge issue.  The library vendors are trying to be
too many things to too many people.  That's a deeper issue
than customer responsibilities  and a failing of the vendor.
I just sent Roy some suggestions of vendor responsibilities,
and that would have been a good one to add.  (As well as the
vendor has a responsibility to be open on decisions on these
types of requests and future software development plans).

There's an excellent chapter on this exact phenomenon in
Alan Cooper's "The Inmates are Running The Asylum".

>A smaller development company or cooperative team is a bit different.
>Hopefully they have communicated their product specifically for what it
>does, and communicated their organizational size, strength, and focus so
>that the consumer understands that going in.  Large library software
>corporations should really be doing the same, but that doesn't happen.

Yeah, I think we're talking about the same thing here.  The
issue is with the communication process.  It's the
responsibility of the vendor to be open and clear in it's
communication process.  The customer should respect this.  The
clear communication should hopefully give the customer an idea
too of what measures they have to take.  Devote time to a
workaround, try to revise their case for the fix, or simply
accept it.

Right now we're seeing the large library vendors having a host
of features, including not doing things a long-term look at
their software.  This is leading to software created largely
by political maneuvering and consensus.  That's not the quite
the same as evaluating needed features and bugs.

Tim, the response I'm sending to the list is a bit different
from the one I sent to you earlier.  Some minor improvements
and hopefully clarified a bit more, but the general thrust is
the same.

Jon Gorman