Tractatus
Computo-Philosophicus

A brief philosophical expression of software development, in the style of Wittgenstein's Tractatus.

1

Software is a logical construction.

1.1

A program is like a proposition. A proposition describes the world, and is true or not. A program realises the intention, and is correct or not.

1.11

A proposition asserts that something is true; a program asserts that some function is wanted.

1.2

Software is articulate. It is a combination of elements, and its elements stand in a determinate relation to one another.

1.3

Software reflects actual effects in a logical structure.

1.4

Software is a model of intention.

1.41

To give the essence of a program means to give the essence of all machines or constructions, and thus the essence of intention.

1.42

The limits of our programming-languages mean the limits of our imagination.

2

Software development is synthetic not analytic.

2.1

In developing a program, if each step is logical, the whole must be valid. But when the premises are uncertain, so must be the whole.

2.2

A program's consistency can be ensured or proved automatically, but its correctness must ultimately be left to human judgement.

2.21

Inconsistency is a confusion of intentions, it is intending more than one thing with one construction. We can automatically find where we are confused, but we cannot automatically choose not to be.

2.3

Consistency is soluble, correctness is not. (But neither alone is sufficient.)

2.31

There is an essential class of error that cannot be eradicated, cannot be avoided, cannot be designed out. We must not confuse those that can from those that cannot.

2.32

Software development is not a deduction.

3

Software design is indeterminate, so software design is iterative.

3.1

Design produces something new. What is not new can be simply copied, and copying is not design.

3.2

The user cannot entirely specify the premises, but instead judges what is eventually built, and then requests modifications to that. Those modifications are themselves also uncertain, so around again. (And even if the user can say exactly what they want, circumstances change and new wants arise.)

3.3

This synthesis and hence iteration percolates through all levels of the engineering process. Just as the user relates to specification and judgment of the whole product, so the engineer does with each part in building it.

3.4

Design is a novel decomposition into familiar parts. And a familiar iteration toward novel intentions.

4

Software engineering aims at the clarification of development.

4.1

Software engineering ensures what can be consistent is consistent, and enables what must be judged to be judged easily.

4.11

The best we can do is more clearly construct what we think we want, and more clearly show what we have actually built.

4.2

Software engineering does not make software, rather it makes a way to make software. Think of it as making a tool. — Its purpose is to make a tool that shows you where it is pointing and goes exactly where you point it.

4.21

But this is the essence of software; it is just what software does anyway. Software engineering merely tries to keep us from getting lost.

4.3

Software is clarity.

5

What can be designed at all can be designed precisely. What is unknown we must leave uncoded.

000
0 1
100
(TXON)
DC:`
   title:`Tractatus Computo-Philosophicus`
   creator:`Harrison Ainsworth`

   date:`2011-02-14`
   date:`2010-12-10`

   description:`A brief philosophical expression of software development, in the style of Wittgenstein's Tractatus.`
   subject:`software development, software engineering, philosophy, wittgenstein`

   language:`en-GB`
   type:`article`
   relation:`http://www.hxa.name/`
   identifier:`http://www.hxa.name/articles/content/tractatus-Computo-philosophicus_hxa7241_2010.html`
   rights:`Creative Commons BY-SA 3.0 License`
`