From Scarcity to Excess: The economics of commodity software.
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.
Posted April 5th, 2004