When updates end
|Dave Beer||Feb 5|
Intermittent software updates are a common feature of our digital landscape. Our devices often pause to renew. We only really notice these updates when they cause us to have to wait for functionality to resume. Then a slightly altered normality returns - often the changes are so minor that they are barely visible, or they are tucked away somewhere in the back-end.
Two recent stories have highlighted what happens to our devices when the updates cease. The most recent is the case of WhatsApp updates no longer being provided to older operating systems. The result is that users of older devices will not have access to the app (estimated at millions of devices). Without the update the app will no longer function. This is itself a consequence of another set of updates drying up, with these older phones not receiving the required upgrade to their operating systems. Once the operating system stagnates, bits of their functionality fall away.
The prior story, from a couple of weeks ago, concerned Sonos speakers and the problems created by an impending lack of updates for older models. This, it was reported, had the potential to leave older speaker systems unable to operate. Without the software upgrade those older speakers were likely to become ornaments.
These two instances highlight how hardware can quickly become redundant or diminished if the updates dry up. For different reasons, both organisations point to the limitations of the older hardware for the functionality of their newly developed software. The hardware is seen to be holding back the software - restraining what it can do, constraining the options available to it. The older device fences in the software, which, it is envisioned, is lively and seeks to breach those limits (as I have described in The Data Gaze). The material boundaries of the hardware are pictured to be preventing the immaterial potential of the software. Compared to software, hardware, it would seem, lacks flexibility.
As well as suggesting the vulnerability of our devices, these two cases highlight this relationship between software and hardware. Both instances indicate the type of reliance they have on each other, and what happens when the software seemingly outgrows the hardware (this is the way it is being presented at least).
The approach taken to software often locks us into cycles of renewal. New hardware is needed to be able to cope with the frequently updated software. Mike Featherstone once wrote about how the creation of a ‘velocity of turnover’ was a defining feature of consumer capitalism. Here we have a velocity of turnover designed into our devices. The constant updating of software pushes the upgrading and disposal of devices.
There is a kind of digital atrophy going on here. This atrophy accelerates when the updates start to dry up. Hardware is given lifespan by the software that feeds it, or that fails to feed it. Devices deplete at different speeds as a result of their relations with software. These devices fall out of use as a consequence of the permeating ideals of constant updating in tech cultures and the rapid cycles of consumer capitalism.
When I was recently researching the Hadoop software project, I found that the legitimacy of the software is wrapped up in these ideas about the need to constantly revise, expand and upgrade. Software in general are expected to be the sites of ongoing movement and frequent honing - it is an expectation that is built into coding cultures. The result is that the hardware’s fixed nature means that it struggles to keep pace with the expectation of transformation that is placed upon the software.
And then there is ‘code/space'. Devised by Rob Kitchin and Martin Dodge, this term captures the reliance our environments now have upon software. Many aspects of our environment need code to operate. The social world is underpinned by software. From traffic signals to flight management, the spaces we occupy and the objects we use rely upon code to function: ‘code/space'. When the software updates end, the reliance on code is visible to us.
As the speaker goes quiet or the Whatsapp message remains unsent, we see the reliance of our devices upon code and the temporality of digital atrophy in action. Our devices wilt.
If you are reading this online and would like to receive future articles by email, you can sign up here…