Skip to main content

From Scarcity to Excess: The economics of commodity software.

Posted by joshy on April 5, 2004 at 8:28 AM PDT

I don't want to talk about how Open Source technology changes the rules
by breaking up monopolies or giving you the freedom to reconfigure. I want
to talk about actual economic effects as the cost of software approaches
zero. It doesn't just save money, it produces new features by the way it's
used.

A non software example:

Let's start with a simple non-software example. Imagine I want a socket
set. I don't mean TCP/IP sockets, but actual metal wrenchs for turning bolts.
If I want to buy a new set I have two choices. I can get a nice expensive
set at home depot for 30$ or I can get one for 10$ at Big Lots. What are
the advantages? One set is better and will last longer. In fact, the set
from Home Depot will last at least three as long as the one from Big Lots,
so in monetary terms it worth spending more, assuming I will use sockets
for three lifetimes of the cheap set. Being a geekboy with a new house, I
probably will.

The economic choice is between buying three cheap sets or one nice one,
plus the overhead of purchasing a cheap set three times (three car trips,
three credit card transactions, etc).

Now suppose that the technology required to make socket sets, and the needs
of socket set users, becomes more mature. The cost of a same quality set at
Big Lots is now 5$ but the cost at HomeDepot hasn't changed. Instead the
quality went up. You now get a better set for 30$. Now I have to weigh the
cost of 6 sets vs one. I may not need to use sockets for the lifetime of
six sets, but the annoyance of them breaking all the time might still weigh
in Home Depot's favor.

Effects of Excess:

The economic choice appears to be the same, just with different numbers.
There's a few things we've overlooked though. Now that socket sets are so
cheap from Big Lots I could start to own more than one. How about keeping
one at my desk, one at home, and one in each of the cars? Now I've done
something that I couldn't do with the more expensive set. I've traded
quality for flexibility rather than quality for duration. No longer do I
spend 20 minutes searching the house for the socket set that I left in the
car. The economics have changed. Now my 30 dollars buys enough socket sets
that the overhead savings outweighs the quality advantage. The Big Lots
socket set still isn't as good as the Home Depot set, but it's good enough.
And being plentiful outweighs the benefits of quality.

Instead of carrying a set around with me, I just put one set everywhere I'm
likely to be: We could also call this: portability through redundancy.

Low per unit cost => portability through redundancy.

Imagine that socket sets get even cheaper. Say 50 cents per set. Instead of
reconfiguring each set I keep it setup in the appropriate manner for each
task. One handle and one socket, with only the sizes I'm going to need. My
car only uses 2 bolts, so I'd have two handles and two sockets. This cuts the
overhead and the space required, because the reduced per unit cost leads to
customization.

Low cost per unit => increased customization and lower configuration overhead.

The tipping point between the two scenarios was when the per unit cost of
the the cheap set became lower than the overhead of moving or reconfiguring
a single socket set. The lower cost not only increased cost savings, but
enabled new behavior.

Now lets come back to software:

For software the limiting factor is per unit licensing cost, the hardware
resources (cpu cycles, diskspace, networking, etc), and the difficulty of
configuration. As each of these gets cheaper, we should start to see new
effects beyond the dollar cost savings.

The per unit cost of software is an illusion. Since there is no
manufacturing cost (or at least very, very little), the per unit cost is a
way of hiding the fixed costs of advertising, product development, and
support. With open source software the per unit cost goes pretty much to
zero, though some of the other costs go up. Still this can enable new
behavior. Now everyone can have a word processor and webserver, not just
those with the money to buy it. This is the traditional savings from
lowered costs.

As processors speed up the cost of cycles goes down, but this goes down
across the board, for both open and closed software; so we won't see too
many new effects there. We should notice, though that it is now possible to
run more than one copy of software on the same computer due to excess
cycles. We should find ways to take advantage of this. In addition, as cycles
get cheaper we can put them into cheaper devices. Phones and PDAs can do tasks
previously restricted to desktops. The advantage doesn't come from doing the same
task on a smaller device, but that you can do the same task on more than one
device. This gives us portability through redundancy.

In the long run the configuration cost is the biggest one. Cycles will
continue to get cheaper, and software will cost less (both through
proliferation of free software, and due to larger markets for commercial
software), but software is still complex and costs configuration overhead.
For end user software this means GUI configuration and usage overhead (the
UI itself). For non-directly user-facing software (server processes and
libraries) this means the ability to reconfigure and integrate the software
with the rest of the system. Even if the dollar cost of a wiki is 0, the
integration cost in terms of time and supporting resources may not. If we
can lower this cost we can start to see lots of new behavior. (As recent
articles ( href="http://www.catb.org/~esr/writings/cups-horror.html">here, href="http://www.osnews.com/comment.php?news_id=6574">here, and
here)
attest, we have a long way to go on the usability front).

So as software gets cheaper, both through Moore's Law and the effects of
opensource, what can we expect to see?

  • SQL everywhere: Every program that stores data (which will be
    every program) will start to use a relational database. Increased
    reliablity, easier to exchange data between programs, easy to transform via
    XML exports.
  • Networks everywhere: Access anything from anywhere. email, documents,
    passwords, documentation, IM. Data at your finger tips.

  • VMWare, everywhere: Create a virtual computer to run a particular
    program. Run legacy apps. Test your website against 5 versions of Internet
    Explorer. One computer for secure programs and one for insecure. Move
    programs from one physical computer to another, while it's running.
  • Wiki's everywhere: Any topic up for discussion should have a Wiki. A
    new site under development. A piece of software. Even a song. Make it as
    easy to capture data (and metadata) as it is to recall it.
  • Web Browsers everywhere Embedding an html renderer in any program
    is getting easier. Pretty much any place there is styled text can use XHTML+CSS
    now. This gives us more usable interfaces, reliability, and network accessability
  • Visual editing everywhere: Right now making a visual editor is
    difficult and expensive. But if it was easy then we could put one anywhere,
    and make smaller customized applications. How about a program that just
    edits screenshots instead of opening (and learning) Photoshop just to do
    cropping and annotation. Or a good visual editor for Tomcat's server.xml file.
    (I am of the opinion that graphical config tools for things like webservers
    fall down because they hide the underlying model and they typically
    aren't generative. It doesn't have to be this way).

The underlying principle here is that as something becomes a commodity
it will enable new behavior, not just shrink profit margins. And this applies
to software just as much as it does to bandwidth and cotton

.

Of course, there is a downside to this rosy picture. The economics of
excess create pollution
. For physical items, like say cars, this means real
physical environmental pollution. But it affects software too. More data collected
equals more bad data mixed with the good. If disk space is cheap then it becomes
easy to back up everything instead of picking out what's important and dumping
the rest. Having two devices with address books makes it easy to get them out
of sync. Organization, synchronization, and pruning are areas of software that
we are just now starting to explore in detail.