Open Source Developer Exchange (Economics)

Thank you to everyone for the great comments.

Earlier comments hint at a possible real need in the community.
Comments:
	If I'm going to spend money on something, I want some assurance
that
	the thing I purchase is what I want.  I don't get that if I
don't even
	know who is going to be the developer on the project I want
done.

	If I really want something done, I'll hire a contract
programmer.  If
	I want a particular feature in a program, but I don't want to
spend
	what it takes to implement that feature, I'll talk to the
maintainers
	of the program and try to convince them to implement it, perhaps
with
	some cash contribution.  I won't chip in to hire some random
person.

	So, why would I use an exchange?  I see the disadvantages; what
are
	the advantages?

A few points could be summarized as:
*	We want to know what we are going to get for our dollars.
*	In general people who aren't developers don't think about
software and "what's missing", i.e. features. Of course, a competitor
will often point that out so it's not that the consumer doesn't care.
*	Most consumers are willing to pay a fee for software as long as
they aren't the only one's paying. For example, many will pay a 49.00
fee for a software package, but only if that didn't represent the total
cost of developing the software (otherwise the burden isn't shared).
*	Consumers care about who the developer is doing the work as a
way of guaging the eventual quality when they can't see the finished
product.

Proprietary software works because a company is willing to take a risk
that they have a product consumers will pay for. They incur all expenses
for creating that product. They then sell that product
"feature-complete" for a proportional fee of the total cost of
development to consumers. They do so by creating an artificial supply
restriction (you have to have a license to use their product).

Open software works because developers (or companies) are willing to
donate expertise to the product. Thus the cost and consequently risk are
low for the startup. This cost is further reduced by facilities such as
SourceForge. In exchange for this, they are free to operate the startup
as they want (including not producing any user documentation or support
if they feel like it). And, they are free to only work on the features
they want to (they don't have consumers or business leaders telling them
what to do).

These two models will continue to exist - perhaps indefinitely.

A third model is being used by companies such as Jboss. The consulting
group is taking a risk but believe that their product is going to be a
hit and thus they do the development for free and give it away. Then,
the consumers are expected to pay for documentation, support, and
consulting services. This possibly works well in situations where the
software is complicated or costly to create (the barrier to entry is the
software creation itself). However, this documentation and support must
be priced at a higher cost than the production cost. In other words, the
software is being given away, but artificial supply of documentation and
support is created (I realize this is a simplification).

Finally, I believe there is at least a fourth business model. That is to
allow projects to be funded by consumers with the results to be shared
by everyone. Thus cosource, and sourcexchange, and others? In these
models, the risk to the developer is kept low (the only real risk is
that the consumer will default on payment). However, the risk to the
consumer is high (the developer may not finish, might not do a good job,
might take longer than expected, the consumer's interest may change by
the time it is finished, etc.) To date, it appears that these models
ignored the risk to the consumer and focused on the risk for the
developer. In other words, it appears that they ignored the fact that
reducing the risk to the consumer is what makes the first three business
models successful.

So what does this fourth model have to do?
*	The consumer must be protected from most forms of risk. That is
they need to know accurately three things: the work to be performed,
cost, quality, and schedule.
*	The developer's risk must be kept fairly low (otherwise they
might be better off adopting proprietary licensing). This side is easier
(in comparison) as they need only to be assured of payment if they
deliver the work as described, at the cost, quality, and schedule
described.

However, this only answers what to do to make the consumer comfortable
with using the exchange, not with why they would use it. Why they would
use it is because a feature has been deemed worthwhile and it is only
obtainable through this exchange (ransom uses this model). In short
order, we are now back to artificial supply. It is true, that a
contractor could be hired to do the work, but the person funding it
would fund the whole effort. Additionally, there is no real advantage
for holding that feature hostage to the other consumers excepting if the
consumer is going to resell that feature. If you can get the project
leader to commit the work for free, then they really didn't have a good
reason to put it on the exchange in the first place.

The advantages to the consumer is that their risk is greatly reduced.
The exchange verifies the work to be performed, publicly identifies the
cost, provides a way for consumers to share the burden of cost, verifies
the quality of the final product, and reduces the cost of the project in
the form of penalties if the schedule is not met.

The advantages to the developers of the project are that they receive
monetary benefit from their efforts at a fair market price. 

So, in short, this type of exchange is probably costly to do if done to
protect consumer risk. And, it is not very costly if the risk to the
consumer is ignored. But, I would argue that it won't be very successful
either.

I'm interested in a thoughtful discussion on these points and if my
opinions are shared by others.

Sincerely,
Ron Lancaster