Agile Software is an Immortal Jellyfish

VP of People, Opreto

4 minute read

Anyone who has ever purchased software is aware that it must be updated occasionally to a new release, with new features and security and performance updates. And anyone with a huge reliance on the work facilitated by that software is acquainted with reading changelogs to stay current with changes that have been made, as the changes may often impact the end user and how they use the tool. Software should never stop moving or be allowed to become static. The moment a codebase stops changing, it becomes vulnerable to software rot; a gradual decline in responsivity and updates with respect to the changing environment in which it resides. As the digital world becomes more complicated, and attack vectors become more nuanced and intricate, software needs to stay abreast of changes or it falls behind and develops new vulnerabilities. This is easily understood from a naturalistic viewpoint as being analogous to rot, although it is in fact standing still and not changing at the same rate as the world it exists inside of.

Under the hood, between the public releases that make their way onto the systems owned by users, healthy software should built to be immortal in order to resist this susceptibility to age and rot, and I would argue that it should follow templates for immortality seen in Nature.

I wrote previously about how agile software development is a horse. Well, a software application developed in an agile way might also be described as an “Immortal Jellyfish,” an organism spread throughout the world’s oceans which can reverse its growth to refactor and redeploy according to environmental factors, and by doing so achieves a kind of biological immortality. All software, especially software developed according to agile paradigms, should be continuously improved, but truly agile software should likewise be radically adaptive and be able to return to first principles before refined re-growth begins again, according to its changed contexts. This needs to be possible even (and despite) when the software code has evolved in a particular direction for such a long time that it has taken on a high sunk cost.

Take the Mozilla Application Suite, for example, which famously refactored itself into the leaner discrete components of Firefox and Thunderbird in the early aughts. The mature application was gauged to be too unwieldy as an omnibus package, and it was pared down to a simpler state and then schismed into focused and lean componentized parts, giving us the sleeker applications we have today.

This is exactly like the life cycle of one of the few biologically immortal organisms known to exist on this planet.

The “Immortal Jellyfish”, or Turritopsis dohrnii, has garnered a great deal of attention for its spectacular and unusual life cycle. It has captured the imagination of scientists and the general public in the past decade, as its deeply special natural life cycle has become better understood. When facing adverse conditions or aging, the jellyfish can transform its cells, using a biological mechanism known as transdifferentiation, to essentially rejuvenate itself and revert from an adult state to a juvenile one. It can then wait for favorable changes in its environment, and then divide and develop multiple adult organisms once more. This flexibility has allowed it to propagate throughout most of the world’s oceans, and make it effectively immortal. It can still be eaten or destroyed, but the organism never dies of age. This capability has given it the capability to navigate environmental challenges (and the ravages of time) quite effectively, and it has spread out across the world’s seas.

In a software codebase, transdifferentiation is akin to the adaptability and mutability of software components allowing for a change of structure or purpose. Certain modules may undergo a transformation in their functionality, or new ones introduced into the weave, much like cells and the organs produced by biological transdifferentiation. This adaptability ensures that the codebase remains dynamic and capable of meeting new requirements without a complete reset (which would effectively be a new organism or application), and allows it to reshuffle itself. This is what happened when the Mozilla Application Suite was felt to have too much bloat. Effectively, the software code was reverted to a more juvenile state and its objectives were fundamentally changed: from producing a monolithic suite, to producing discrete applications that did one thing, and did those one things well. It was able to accomplish this, not by discarding the mature application, but by travelling backwards to a simpler state and then evolving once more from there in the chosen direction.

Both a healthy software codebase and the “immortal jellyfish” showcase the power of adaptation and continuous improvement, as well as the benefits to being able to rewind time without unwinding it completely. It is at the level of the whole organism, and of organs therein, that reversals of the life cycle happen - purely cellular development, or changes to a particular software module, tend to follow the arrow of time in only one direction. In the case of the Turritopsis dohrnii, and in the case of agile and immortal software applications such as the Mozilla Application Suite - if the environmental conditions demand it, the entity will revert from an adult state to a juvenile one on a holistic basis, and perenially realign its narrative arc to achieve undying relevance.

Software should never fade away, and it should always stay relevant and current. This is how it should be built: like an immortal jellyfish.