more on Open source IT a money pit? [TECH UPDATE]

["Dave Farber" <dave () farber net>]

------- Original message -------
From: Suresh Ramasubramanian  <suresh () hserus net>
Sent: 14/4/'05,  19:58

David Farber wrote:
> Philip Greenspun, MIT professor and serial entrepreneur, speaks
> eloquently about the economics of open source to two different
> audiences--those looking to make money at it and those thinking
> about building their IT around it. In an interview with Doug Kaye

As a possible counterpoint, please see this (rather old, but still good) 
article on open source economics

http://linuxtoday.com/infrastructure/2001041200620OPBZCY--

Ganesh Prasad: Open Source-onomics: Examining some pseudo-economic 
arguments about Open Source

By Ganesh Prasad <sashi at easy.com.au>

Synopsis:
While the technical arguments against Linux and Open Source are being 
gradually silenced, several unrefuted myths about the economics of Open 
Source continue to float about, confusing and scaring off people 
considering these alternative products. Worse, the Open Source community 
is itself divided on such issues, and is unable to provide a cogent 
rebuttal. This article is an attempt to set the record straight.
Contents

     * "The poor performance of Linux stocks proves that Linux is a failure"
     * "Open Source is not economically viable"
     * "Not paying for software will ultimately kill the industry"
     * "Why will programmers continue to contribute code if they can't 
make money from it?"
     * "Even Open Source development involves effort, so there has to be 
payment for that effort"
     * "Are Open Source programmers writing themselves out of their jobs?"
     * "But free isn't natural. There's no such thing as a free lunch."
     * "Is software a commodity?"
     * "Who will invest in software development if it doesn't yield a 
return?"
     * "Open Source may have a niche, but proprietary commercial 
products will continue to rule"
     * "Customers will never trust something that is free"
     * "Open Source may release value, but it doesn't create value"
     * God, Government, Market and Community
     * Conclusion
     * References
     * About the Author

"The poor performance of Linux stocks proves that Linux is a failure"

What's the relationship between the performance of Linux stocks and 
Linux's own prospects of success? When stocks of companies like Red Hat 
and VA Linux Systems skyrocketed in the wake of their IPOs, that was 
taken as an indication that Linux had arrived, and Linux advocates said 
nothing to counter the impression. Indeed, many gleefully used the 
stockmarket to show their peers that Linux was to be taken seriously. So 
now that the same stocks are trading far below those prices, doesn't it 
indicate that the Linux shine has worn off? Look at the number of Linux 
companies in the doldrums, that have laid off employees or closed down. 
That certainly seems to indicate the end of Linux. It was a great idea 
that failed to deliver on its promises, and we should now go back to 
software and companies that are more firmly grounded in economic 
realities, right?

Well, first of all, Linux is quite independent of Linux companies in a 
way that the market has never seen before. Windows means Microsoft, 
Netware means Novell, OS/390 means IBM. The fortunes of operating system 
and company are usually heavily intertwined. That's simply not the case 
with Linux. If Novell closes down, that pretty much means the end of 
Netware, unless another company sees fit to buy the product and keep it 
alive (On the other hand, Microsoft may simply choose to buy Netware and 
kill it!). Such things can't happen to Linux. As an Open Source 
operating system, Linux is teflon-coated against the commercial failures 
of the companies that try to build business models around it. Commercial 
entities are Johnnies-come-lately to Linux anyway. Linux managed without 
them for years, and will continue to exist even if they should all 
disappear.

In fact, companies that claim to support Linux are wrong -- Linux 
supports them!
"Open Source is not economically viable"

OK, so Linux as a technical product may continue to exist, but if 
companies cannot make money from it (as is seemingly evidenced by the 
woes of the Linux companies today), then it's another great technical 
success that is a commercial failure. History is littered with such 
examples. Linux will never go anywhere unless people can make money off it.

Now here's an argument even Open Source sympathisers have trouble with, 
-- the assumption that money must be made for Open Source to succeed. 
However, the argument is incomplete because it chooses to concentrate on 
the supply side alone, without regard to the demand side.

While it may well be true that no one can make money from Open Source, 
that should only serve to discourage suppliers of software. On the 
demand side, however, consumers are saving tons of money by using Open 
Source. Since a penny saved is a penny earned, there is a strong 
economic basis for the success of Open Source after all. Someone is 
saving money, and they will fight to keep those savings.

The demand side is the one that should drag the rest of the market, 
kicking and screaming, to a regime of drastically lower prices. Vendors 
will see their margins shrink, many will close down, newer, leaner ones 
will spring up, vendors in other market segments will provide software, 
and eventually, the market will adjust itself to the new reality. Dollar 
volumes will go down even as unit volumes go up. The transition could be 
quite painful for suppliers of software, but no law of economics says it 
cannot happen. It is not a law of nature that vendors must continue to 
make the revenues and profits they are used to.
"Not paying for software will ultimately kill the industry"

There are the long-term worriers who don't like this scenario at all, 
even as they accept that it may happen. Yes, they say, customers will 
save money in the short term, but they're eating their seed corn. 
Customers need financially healthy vendors to be around to support them 
and continually improve their offerings. A herd of gnu may be happy at 
the disappearance of the local lion population, but the herd needs 
predators to cull its ranks of the weak and the sick, and to keep its 
gene pool healthy. Saving money by starving your suppliers is not in 
your own long-term self-interest.

This is a strange suggestion from people who probably describe 
themselves as market capitalists. When customers make a purchase, should 
they think about their own savings or should they worry about the 
supplier or the economy? Is it reasonable to ask them to choose costlier 
products because that will ultimately and indirectly serve their own 
interests? The argument smacks more of Marx than Adam Smith, -- The 
State above the individual.

This was the convenient argument of horse-buggy manufacturers when the 
locomotive arrived, and of the railroad companies when the aeroplane 
appeared. We've seen this dozens of times in our history. A generation 
of suppliers is threatened, and they try to convince the rest that 
society as a whole is threatened. If history is any guide, consumers 
will make the decisions that suit their immediate interests, and vendors 
will have no choice but to adapt as best as they can. Those decisions 
may decimate them, but civilisation will survive, as it always has. 
L'Etat, c'est moi.
"Why will programmers continue to contribute code if they can't make 
money from it?"

Right. Given a choice between a free software product and a competitor 
with a price tag, it is understandable if customers choose the free one. 
But why should anyone write it for free in the first place? What would 
they gain?

The assumption behind this question is that there are only three types 
of transactions between parties: win-win, win-lose and lose-lose 
(Lose-lose transactions should never occur under conditions of rational 
decision-making). Win-lose transactions occur when the winning party is 
stronger than the other and can force a transaction through. All other 
transactions are willingly entered into by two parties and are win-win.

In the case of Open Source, the recipients of the software are obviously 
winners, but the writers of the software don't seem to be winning 
anything because the recipients don't have to pay them for it. 
Therefore, our assumption tells us that this not a win-win situation, 
and that there is no economic incentive for a programmer to write Open 
Source software.

For the moment, let us go along with the assumption that the only 
motivation for writing software is economic (which is not true). Even 
with such an assumption, the reasoning is flawed because there are other 
types of transactions which are not so obvious and which have not been 
considered: win-neutral, lose-neutral and neutral-neutral.

Under conditions of rational decision-making, lose-neutral and 
neutral-neutral transactions have no incentive to occur, but win-neutral 
transactions can and do occur quite frequently. Everyday examples 
include someone asking for directions, or asking for change. Here, the 
person asking certainly gains something from the transaction, but the 
other party neither gains nor loses from it. Therefore, the transaction 
can still take place.

Most Open Source programmers would probably not write software and give 
it away if it cost them something to do so. However, they don't perceive 
the effort of writing it to be a cost. Most of them write software to 
solve a specific problem that they happen to be facing, or to "scratch 
their personal itch", as Eric Raymond points out. The process of 
developing such software is actually quite pleasurable and energising to 
most good programmers. Once the software has been written, giving away 
copies of it does not deprive the programmer of the ability to continue 
to use it, and it costs them nothing extra to do so. It is a win-neutral 
transaction, and therefore there is no economic reason to prevent it 
from taking place.

(Economics purists would point out that there is indeed a cost to giving 
away the software -- the opportunity cost of not selling the software 
instead. However, for many programmers, the process of selling their 
software is more trouble than it is worth, so the effective opportunity 
cost is actually zero, and it is a win-neutral situation after all.)

If that was not sufficient reason, Open Source programmers also tend to 
work with others who share their interest and contribute code. They 
enjoy a multiplier effect from such cooperation. Metaphorically 
speaking, each programmer contributes a brick and each gets back a 
complete house in return. In software, unlike with physical goods, one 
person's gain does not come at the expense of another because a copy 
does not deplete the original in any way. Sharing software is not a 
zero-sum game, and there are tremendous efficiencies from participating 
in such a cooperative endeavour.

No, the absence of direct monetary reward does not really constitute a 
disincentive to writing Open Source software.
"Even Open Source development involves effort, so there has to be 
payment for that effort"

OK, Open Source programmers lose nothing by giving away the software 
that they have already written (and they may even gain in non-monetary 
terms). But some effort has gone into their products. Shouldn't such 
effort be compensated in cash as well? Programmers have families to 
support, and they need to put bread on the table. They can't live on 
software and satisfaction alone. To be viable in the long term, Open 
Source needs to evolve a mechanism to support its contributors 
financially. Without remuneration, over time, most of these volunteer 
programmers will simply wander away in search of food.

This argument appeals to equity as well as economic commonsense, and 
finds sympathisers even in the Open Source community. Certainly, we 
would all like to see programmers being compensated for their 
contributions. There are several business models that are being 
attempted. The SourceForge and Collab.Net method of raising 
contributions from users to pay developers is an innovative one, but its 
success is as yet unproven. Programmers could also try and make money by 
supporting their creations, maybe selling copies of it as well, 
providing consultancy and professional services, etc. But we still don't 
know of a foolproof business model for this sort of thing. There may not 
even be one. In the absence of a good system coming along pretty soon, 
Open Source will perhaps continue to be written by volunteer programmers 
who have day jobs writing commercial software. It could also expect 
contributions from hardware or services companies with a stake in its 
success.

But even in this worst case, does it mean that Open Source will stop 
being written? As long as Open Source programmers have alternative 
sources of income (i.e. day jobs), they lose nothing by working on Open 
Source projects in their spare time (a win-neutral transaction). With 
the increasing number of people being exposed to Open Source, the pool 
of contributors is in fact growing larger by the day.
"Are Open Source programmers writing themselves out of their jobs?"

But that leads to what may seem the ultimate argument against the 
economics of Open Source: How long can programmers work day jobs at 
commercial software companies and write software at night that puts 
those same companies out of business? Writing Open Source software is 
not just irrational, it is positively suicidal. 'Tis an ill bird that 
fouls its own nest, not to mention an extremely foolish one.

Indeed, this appears to be a very powerful argument. However, Eric 
Raymond comes to our rescue with this statistical nugget: Only 5% of all 
programmers are actually engaged in writing "for sale" commercial 
software. The other 95% actually write and maintain custom-built 
software for in-house use. Open Source doesn't threaten custom-built 
software at all. It only competes with packaged software that is sold as 
a product. And so, in the worst case, Open Source programmers are only 
going to put 5% of their own kind out of work. That's an acceptable 
level of collateral damage, as the generals might say.
"But free isn't natural. There's no such thing as a free lunch."

But this entire idea is crazy, somewhat like producing something out of 
nothing! How can one seriously expect an entire economy to be based on 
something that is absolutely free? Doesn't it violate some fundamental 
economic law, just as producing something out of nothing violates the 
Law of Conservation of Mass in physics?

Let's examine whether it does.

We realise it is not possible for any supplier to charge less for a 
product than it cost them to produce it. That would mean a loss. At the 
same time, if all products in a category are roughly alike in function, 
and there are plenty of suppliers for those products, it is not possible 
for any of them to charge significantly more than their competitors 
without pricing themselves out of the market. So they should all end up 
charging just slightly more than it cost them to make the product, 
making only modest profits in the process. The underlying assumption 
here, though, is that we have "pure competition".

"Pure competition" in economics means a buyers' market. Consumers love 
it and suppliers hate it (though, curiously, all suppliers claim to 
welcome it). A competitive market means that consumers can easily find 
any number of alternative suppliers for a product. It also means the 
product is a commodity.

A "commodity" product means that there is very little differentiation 
between the various versions of a product. They all do the same thing, 
with only minor, insignificant differences. Consumers don't bother about 
brands when buying commodities. Suppliers hate commoditisation for the 
same reason and try their best to create artificial differentiation. 
(The best example is the Vodka Paradox: Vodka, by definition, is a 
colourless, odourless and flavourless drink of a specific composition, 
so all vodkas should be the same! But we know of both premium and 
downmarket brands of vodka, so at least some of them are, by definition, 
not vodka at all!)

Look at the software market from these angles. Is it competitive? Is it 
a commodity market? Think about whether it would be easy for you to 
replace Windows on your PC with another operating system. Think about 
whether such a system would work the same way. Such an analysis may 
suggest that this is neither a competitive nor a commodity market. 
However, these aren't very straightforward questions to answer because 
some recent developments have impacted the market a great deal, but 
we'll come back to them a bit later.

The important point to note is, if the software market becomes a 
competitive commodity market, the price of software should be close to 
the cost of producing it. That's what economic commonsense says should 
happen.
"Is software a commodity?"

But why would the software market suddenly turn competitive and into a 
commodity market? The answers are standards, the Internet, and Open 
Source software itself.

The correct way to build an application using 1990s thinking is to grab 
a copy of Visual Basic or PowerBuilder, develop a Windows executable and 
install it on every user's PC. The larger the number of PCs to install 
the software on, the more you walk around. When you need to upgrade the 
software, you put on your sneakers again and take another walk.

Now fast-forward to today. The correct way to build an application using 
millennial thinking is to put the application on a website and get users 
to point their browsers at it. When you need to upgrade the software, 
you modify it once on the server and your users hit the Refresh button 
on their browsers.

Web technology, if you stop to think about it, is a predominantly 
server-side technology. True, there's the Java applet, but hardly anyone 
uses it. There's Javascript, but ever since the browser wars, when you 
couldn't be sure which browser would break your code, developers have 
been wary of coding a lot of Javascript. That leaves virtually all 
development on the server side. All that the user needs is a lowly browser.

At one stroke, the web has commoditised the server, because all a server 
needs to do is talk some standard "protocols". If it knows HTTP 
(HyperText Transfer Protocol), it can talk to a browser. If it spits out 
some HTML (HyperText Markup Language), the browser can actually render 
it for the user to read. Whither brand? Neither the browser nor the user 
sees the brand of the server software. The same goes for other Internet 
standards such as SMTP (Simple Mail Transfer Protocol) and LDAP 
(Lightweight Directory Access Protocol). They have completely 
commoditised the servers that implement them. Suddenly, standards are 
king, and anyone can play.

The favourite vendor tactic, -- differentiation, -- doesn't work very 
well in this situation. Differentiation breaks standards. More is less. 
A product that fails to comply with a standard is automatically 
incapable of surviving in the Internet ecosystem. Any superfluous 
features it boasts simply wither away through disuse. It's a 
self-perpetuating discipline. Internet protocols and standards rule with 
an iron fist. So it looks as if commoditisation is here to stay, however 
much vendors may hate it.

What's more, every such standard and protocol is faithfully implemented 
in at least one Open Source product. That keeps commercial implementers 
honest, too. No oligopoly is possible in the Internet-era software 
market, because any Open Source implementation pre-emptively breaks the 
cartel! (As an example, the nascent oligopoly among web application 
server vendors is coming under severe pressure from the Open Source 
JBoss and Enhydra. Expect to see prices tumble in this market).

And so, here we are, in a competitive and commodity market after all. We 
know that in such a market, the price of software will be close to the 
cost of producing it. So if we can show that the cost of producing 
software is zero, then the price tag of zero is justified.
"Who will invest in software development if it doesn't yield a return?"

It sounds a preposterous argument on the face of it. How can the cost of 
software ever be zero? Doesn't it take significant effort to develop 
software? Even Open Source software is not miraculously produced. 
Programmers spend many man-months of effort on it. So how can the price 
of software ever be zero?

Selling below cost is considered predatory pricing in many countries. In 
international trade, it's called "dumping". Is Open Source guilty of 
"dumping" or predatory pricing? If unchecked, this could destroy the 
commercial software industry. Who will invest in developing software if 
they cannot recoup their development costs?

The answer to this question may be surprising, because it overturns many 
of our fundamental assumptions about the way the world is run.

Let's start by observing that if Linux had been developed by a 
commercial organisation, it could never have been free. Commercial 
organisations, whether funded by debt or by equity, need to show a 
return on their investment. They cannot waste that investment by giving 
away their products. Therefore, even if it costs nothing to create 
additional copies of software (what's called the "marginal cost" of 
software), the initial costs of development must be spread over many 
copies, they must be priced in such a way that those costs can be 
recouped, and a positive return must be shown on the initial investment.

Of course, for this to work, software must be shoehorned into the mould 
of a physical product. Copying of software by anyone other than the 
producer must be made a crime. The infinite replicability inherent in 
software must be artificially curtailed through legislation. Only then 
can the model work. This is precisely what we have with commercial 
software today. It is important to understand that the commercial model 
works by imposing a system of artificial scarcity. It is physically 
possible and economically feasible to produce as many copies of software 
as the world needs, but that is however, legally punishable. That means 
that many people who need software but cannot pay the asking price must 
go without it. That is the only possible (legal) outcome. There are 
people who need a software product, and the product can be replicated at 
little cost, yet the transaction cannot take place. From society's 
viewpoint, this inefficiency is the price it pays for choosing a 
commercial vehicle for software development.

But now, consider an alternative to the investment model. If the cost of 
software development can somehow be treated as an expense, and simply 
written off, then the software is freed from the requirement to show a 
return on investment. There will be no need to artificially constrain 
its natural replicability. The world can have as many copies of it as it 
needs. There will be no need for restrictive legislation. From society's 
point of view, what could be more efficient?

Large expenses, however, cannot readily be written off. They need to be 
"amortised" over a sufficiently large number of units. This is where 
another property of software becomes invaluable. Software can quite 
practicably be developed by hundreds, even thousands of programmers. 
Other intellectual works, such as books, music or movies, while sharing 
software's trait of infinite replicability, cannot be produced by a cast 
of thousands. Of all the works of mankind, physical and intellectual, 
software stands alone in its twin characteristics of infinite 
replicability and amortisability of effort.

Looked at this way, Open Source seems the more natural and efficient way 
to build software. Get a large number of interested developers to work 
on a piece of software. Most of them spend less than a couple of hours a 
day on it, so they don't mind "writing off" the effort in terms of 
expecting a monetary return. That is why Open Source operating systems 
and associated software are free for every man, woman and child on earth 
to copy. By keeping important software like Linux out of the ambit of 
commercial interests, society has benefitted handsomely.

Software, like wealth itself, is potentially limitless. Capitalism 
correctly views wealth as potentially infinite, and fuels global growth 
to increase the overall size of the economic pie. However, the current 
structure of the commercial software market is not capitalistic at all, 
but mercantile. It sees software as a limited good that needs to be 
hoarded and released sparingly. It is therefore incapable of being an 
engine of growth.

Lest our current "capitalistic" mileu should give anyone the wrong idea, 
it must be note

-------------------------------------
You are subscribed as lists-ip () insecure org
To manage your subscription, go to
  http://v2.listbox.com/member/?listname=ip

Archives at: http://www.interesting-people.org/archives/interesting-people/