Software as an autopoietic entity - or: Survival of the fittest

What´s software anyway? Code, software is code, right? Well, I´d say, software is more than that. And to realize that is important for the whole software production process.

Lets step back and take the big picture into view: Software is an entity "sitting" in an environment; you could even say, it´s living in an environment, because it´s struggling to survive. Software comes into existence and from then on is trying be liked by users and customers, to be kept alive by them through usage. As long as it is used, it lives. As soon as users or customers start favoring another software for whatever reason, it runs the danger to be dumped, i.e. to be killed. So, I guess we can say, software has to be fit, to survive.

But what does "fittness" mean? It´s the right balance between efficiency and flexibility. If an organism would only strive for efficiency, it can easily be killed, if the environment changes. If, on the other hand, it strives for flexibility, it can be killed because it´s not fast enough or has a too weak armor, meaning it´s lacking efficiency with regard to a particular survival relevant aspect.

During a single livetime, an organisms efficiency-flexibility-balance is pretty much set. However it´s highly variable over the lifetime of a whole species. But how does a species attain this variability, how can it adapt? By constantly re-creating itself as a continuous stream of new "versions". A species thus is surviving through autopoiesis.

Back to software: If software is struggling to survive like any organisms, can´t we then also view it as an organism? What about MS-Word and OpenOffice and WordPerfect and Wordstar as specieses with particular versions as instances or organisms? Well, as the extinction of Wordstar and the rivalry between MS-Word and OpenOffice show, it´s a jungle out there and not every software or software species survives indefinitely. The better always is the enemy of the good.

But how could software be capable of autopoiesis? If software equals code, then there is no self re-creation. Software does not modify itself, it cannot evolve itself. (Lets leave genetic programming aside for the moment ;-)

So what´s wrong? I´d say, our picture of software=code is wrong. Software is not just code. There´s more to software than code, otherwise there would be no way to evolve.

I think we need to switch from software=code to software=code+developer. We need to take the developer (or development team) into the picture to arrive at autopoietic systems which can evolve in the face of an ever hostile environment.

The whole, software, consists of two inseparable parts. And only if the whole finds a balance between efficiency and flexibility it is going to survive.

That means, fiddling with properties and qualities of either part always affects the whole. That means, whenever talking about functional or non-functional requirements, the whole has to be taken into account. How does tweaking performance affect the whole´s ability to survive? How does neglecting architecture affect the whole´s ability to survive? How does testing, documentation, GUI-design, code readability etc. affect the whole´s ability to survive?

High performance and scaleability are efficiency concerns; good design and coding standards on the other hand support flexibility. Tight schedules: efficiency. Collective code ownership: flexibility. O/R Mapper: flexibility. Socket programming: efficiency.

My conclusion from this new view on software: We need to step back more often, when planning a software project and take into account not only code, but the union of code and developer. We need to take into account the whole of software when talking about optimizations, schedule, design, documentation, project organization etc.

Software is more than code!