What does an early 20th century philosopher have to say about software engineering?

The roots of software are in the early 20th century: this was when Lambda Calculus and Combinatory Logic were invented. But it was also the time of significant philosophical work in and around logic. Perhaps the most prominent was Wittgenstein's Tractatus Logico-Philosophicus.

And there is something particularly interesting for us: the Tractatus can be translated almost directly into the software domain.

In this light, Wittgenstein is talking about language and our relationship to the world in a mechanical, or rather, ‘digital’ way: as if it were like software. It is like a pre-echo of the software world in a time when no such now-familiar concepts yet existed to describe it. (Maybe it is notable that Wittgenstein studied engineering at university . . .)

The ‘propositional model’ of software

Central in the Tractatus is the concept of the ‘proposition’: a statement about the world that can be true or false. It is a logical artifact used to describe the world (and so links logic and world together). This maps straightforwardly to software: a proposition becomes a program. Where a proposition describes the world, a program constructs the imagination, or intended-world – an artifact. A program is like an executable proposition.

In terms of the so-called picture-theory: a propositional ‘picture’ depicts, by its logical structure, a state of affairs – and software computes, by its digital structure, a set of effects.

The propositional-model also says that:

programs are built up from primitives,

programs have an articulate structure that is the basis of their sense or meaning,

a program's sense can be understood independently from knowing if it does what is wanted or not,

the most elementary programs simply set a group of bits to be be output and DAC-ed as a primitive effect,

the ultimate primitves – the outputs – have no logical structure, just effect.

Translated back into the domain of propositions and human language, these are an interesting, controversial thesis. But for software, they seem readily acceptable if not self-evident. The model does seem to fit rather well – better than its original purpose.

This ‘propositional model’ captures a fundamental encompassing abstraction of what software is and does.

Implications of the model

A set of interrelated notions emerge from the propositional model:

Software is a logical construction – it realises intent, in a logical structure. Software is not really a ‘language’ but a machine (more fully, a stack of progressively narrower abstractions of machines).

Software is determinate, limited – what can be constructed at all can be constructed precisely. It is contradictory to try to design software to meet truly unknown future needs. You can only design for what you know.

Software is made of two orthogonal relations – its logical structure is wholly ‘internal’, but its correctness is ‘externally’ fixed. There is a kind of error that is soluble, and there is a kind of error that is not soluble.

Software is produced by design – design produces something new and dependent on human judgement. We can build things, but we can never say determinately, completely, finally, what we want: development is essentially iterative.

Software does just what we ask it to – with an unparalleled fidelity and fluidity. The best we can aim for is just to do exactly what we want to do. Software engineering does not tell us what to do, it just helps us be clear about what we are doing. Software engineering is about clarity.

These are all things we might already half-know, but the propositional model gives them a coherent foundation.

See the whole project

It was said the Tractatus could be translated into the software domain. Well, the above was merely an introduction. Now be intrigued and provoked by the whole presentation: