Complex software packages need ever gruntier specs. and Koomey’s Law awaits
Comment A few months back, I wrote that buying software is a big lie. All lies have consequences, of course. The worst kind of consequences are the ones you didn’t see coming. So let’s look at some of those, and some other lies they conceal.
As we said last time, you can’t really buy software. Commercial software is mostly – but as some readers pointed out, not always – proprietary. Proprietary software has both pros and cons, but so does FOSS. It’s not always all about money. Last time, we argued that convenience – minimizing expenditure of work, time, and effort – can be even more important than simple financial cost.
The differences between commercial software and FOSS also have lots of important consequences when it comes to hardware, too, though. With commercial software, the relationships are generally easy to follow. With FOSS, it’s more complicated, with contradictory and conflicting effects. That’s what I want to look at this time.
Software vendors, whether of FOSS or proprietary software, don’t work in isolation. Anyone selling operating systems, especially, must work closely with hardware vendors.
In some important ways, the goals of these two camps are aligned. Both need you to pay for their products, but more importantly, they need to find ways to make you keep on paying. For hardware vendors, it’s relatively easy: just keep making the product faster and more capacious. Ideally, newer versions should use less power and be more manageable.
For software vendors, it’s trickier. As a general rule, newer versions of established software products tend to be bigger, which makes them slower and more demanding of hardware resources. That means users will want, or better still need, newer, better-specified hardware to run the software they favor. That’s good for the hardware vendors. However, it’s not just one way: the newer software has additional features, to tempt users to upgrade, and if their new computer runs it faster, that’s good for the software vendors.
As we pointed out last time, this pushes software companies toward tactics such as licensing, keys, product activation, support contracts and more. File-format lock-in is by no means limited to proprietary vendors: you could also describe .DEB format versus .RPM format, or Ansible versus Salt, in much the same terms. You pick one, and after you invest in it, changing to another means costs: in effort, in monetary value, in downtime, and so on.
When you link the need to sell newer software to the need to sell newer computers, you get things like OEM software bundling, and product-compatibility labelling. Software and hardware vendors give each other incentives to promote and support each others’ products, and both gain.
The result is a feedback loop. As former Microsoft CTO Nathan Myhrvold described it:
Whatever container you put it in, it expands to fill it. This can seem as inevitable as physics, and maybe that’s why people often describe it in terms of « laws ». One example is « Andy and Bill’s Law »:
Harsher still is Wirth’s Law:
There are laws about that, too. Computers are no longer getting so much faster every year or two. Moore’s Law has been losing impetus for well over a decade, supplanted by Koomey’s Law. Computers are getting smaller, cheaper, cooler-running, and last longer on battery power. That’s good. It’s led to the rise in inexpensive phones and tablets, which is helping more people get online. That’s also good.
Secondly, when large complex software packages get mature, vendors start to run out of new features to drive big-bang releases. One alternative is sofware subscriptions. Pay a fee, and continually get a trickle of new features, plus certification that you’re up to date and so a little more secure.
