Enough with the chatbots already
May 2024
Thinking at lightspeed
Some science fiction writers ignore relativity and don’t treat the speed of light as an absolute limit. This is understandable from a narrative perspective: it allows them to tell stories spanning many worlds, in which fleets of spaceships flit across the galaxy, and in which events that happen on one planet can meaningfully be said to happen at the same time as events on other planets.
However, I think that some of the more interesting stories are those which use the concept of relativity and the weird effects it produces. By allowing their fictional vessels to accelerate to near, but not beyond, the speed of light, they create stories in which time moves differently for different characters. In such stories, a character who travels a lot may live a normal human lifetime while millennia pass on the places they visit, and events ripple across the galaxy in lightspeed jumps.
(I realise that I’ve assumed that everyone reading this is familiar with the concept of relativity. Just in case you’re not, the TL;DR version is that, as object A approaches the speed of light relative to object B, then the rate at which time passes for A slows down from B’s perspective but not from A’s perspective, meaning that A could undertake a journey which takes weeks for them, but centuries for B. Many, many people have explained this much, much better than me: a quick Internet search will tell you more. And if you’re genuinely encountering these concepts for the first time, I envy you; you’re in for a fun ride!)
Grasping relativity takes an act of imagination, and crafting stories which follow the rules of relativity takes further acts of imagination. I believe that we need to exercise similar imagination when putting technology to work in our enterprises – and that we can experience our own time-dilation effects.
A science fiction story which ignores relativity often draws from a familiar mode of travel: spaceships are like ocean-going ships. They may take a while to reach their destination, but their journeys take place within human scale spans of time. Such spaceships have bridges, and captains, and other roles which resemble those of a normal ship (you may be thinking of a familiar television series).
Similarly, when we put technology to work in our enterprises, it can be tempting to treat computers as machines which behave like humans, and to organise our systems as if they are subject to the same constraints as humans. Some attempts at business process redesign fall prey to this temptation: I know that my process is inefficient; I am going to invest a large amount of money digitising this process; therefore, my money will be better spent if I redesign the process and remove the inefficiencies.
This is an understandable chain of reasoning, and I have followed it myself, many times, in many projects. However, it is often a mistake and fails to recognise the effects of computing time compression. Why is my process inefficient? If it is because it allows errors, and handles those errors badly, then I probably need to redesign it. But if it is because it has five steps rather than two, why do I care? When I implement the process as code, I will compress the time taken for those five steps from one hour each to a few milliseconds each. Relative to the computer, time stands still: I can take as many steps as I want.
For people who build software, this time dilation effect is particularly apparent when we build automated tests. I remember being shocked when I read a programming guide which said that, when building tests, it was okay to ignore some (but not all!) of the good coding practices that applied to my main code. I could cut and paste and I could repeat myself. The goal was not elegance, but coverage. As a result, some of my test code is not organised in a way that would make any sense to a human manually executing a test script. But no human could ever execute that test script manually: even a simple test script, executed frequently, can represent a level of manual effort that would exceed a human lifetime. The effects of inefficiencies in the script are negated by extreme time dilation.
I am not arguing for bad processes and inefficient code. But I am proposing that, when designing computer systems, and particularly when explaining those systems to people who don’t have a technical background, we emulate those science fiction authors who embrace the constraints of relativity. We should remember that, relative to computers, our world is at a virtual standstill, and that work which saves hours in our world may only save fractions of a second in a computer world. We’ve built a lightspeed engine: let’s use it.
