Rule-following and software development

(permalink: note 2013-06-09T09:17Z)

“This was our paradox: no course of action could be determined by a rule, because any course of action can be made out to accord with the rule.” – Philosophical Investigations 201a.

The ‘rule following’ ‘puzzle’ is soluble by appreciating what ‘rule’ means. It is really just this: rules are not exact.

And how could they be? The meaning of ‘rule’ is that it applies in various circumstances to various items. Essential to the very concept of ‘rule’ is some leeway. Rules are not wholly determined – it is not a puzzle, it is just what they are. Every ‘puzzle’ that might seem to appear is just an elaboration of misunderstanding that.

Rules might be nested: we might follow rules to decide how to apply rules, and maybe rules for them in turn – like “a complicated network of similarities, overlapping and criss-crossing”. That does not mean we have nothing, nor does it mean there is a puzzle: it means we have rules. And the whole sophisticated system just behaves with the essence of all rules: there is something fixed, and there is something flexible, open-ended.

(Crispin Wright: “How and when is it settled . . .” – it is never settled. “How is the once-and-for-all division . . .” – there is no once-and-for-all division.)

A rule is an abstraction.

———

To learn a rule is not to learn exactly every possible detail, it is to ‘find’ a groove that is already there.

———

To worry about ‘interpreting’ a rule, and that there seems an endless regress is to misunderstand what a rule is. It is not about specifying absolutely precisely. Rules essentially apply to various cases: if everything were exactly specified it would no longer be a rule.

It is like the question of, if every atom in your body is continually in flux, what is your identity?

But going down that route does not work. To suggest it would only make sense if everything were precisely atomically specified is really to say there is no regularity, no pattern, no structure, in the universe – that is, no way to understand.

There is regularity (in various, elaborate, nested ways). And that is what gives personal identity, and allows rules to be followed.

———

Whether you know you are following/applying the rule correctly is a separate question. The answer is, of course, you do not absolutely know. You can feel confident, for various circumstantial reasons, but some rules are defined by having external authority.

———

Rules can always be re-interpreted, so what is rule-following? Rule-following is just what you do until you re-interpret.

In software a program is a rule. We know from experience that software is never final. someone can always find a new reinterpretation of the requirements at some point and want something else.

Rules are not eternal. Rules are incremental, like software development. That is what rule-following means: following until it changes, then following in a new way. Following a rule is not ‘tuning-in’ to some platonic form, it is just using an abstraction at some moment.

Abstractions are not eternal. They suggest infinite extent – because the fixed part encompasses unlimited variations/instances – but that should not lead us to think they exist in some transcendent realm.

———

Software is a good explanation of rule-following; it can help resolve the perplexity. (Because software is made of nothing but rules – abstractions – that is all it is.)

Software is never finished, there is no final definition for some particular software, no final decision of what is wanted that could never be reconsidered. But this does not mean we cannot build any software at all; we simply build a version, then later change it, and so on again. We do not see the unfixedness, the lack of a final definition, as a fundamental block, a deep problem that must be solved. It is just software work.

Requirements here are language-games or rule-following, and software-development is philosophy or trying to understand what we do. Perhaps the difference is that software-development is closer to simply accepting what it is really doing. (Well, except the delusion tries to re-assert itself whenever someone wants to design an ‘extendable’ component: the feeling that it might be possible to make an abstraction that will never need changing.)

———

Related:

• ‘Distinguishing abstraction and change’
• ‘Wittgenstein for programmers (part 1)’
• ‘OO modelling and the real-world’

archive

How to approach designing an economic system – 2013-02-03T10:36Z

De-focus from currency; orient with independent knowledge; imagine cellular automata; base on supply and demand; think in software; discretise, distribute.

GITI – Electric guitar music text format – 2013-01-27T11:24Z

GITI is a new music text notation for electric guitar: a bit like a specialised kind of abc (another non-traditional notation)

Debt is a bad cooperative structure – 2013-01-20T10:53Z

When you look at debt as an abstract informational/cooperative structure you find it is a dysfunctional one. And a quick check for any rational moral basis turns up nothing either. Debt is unwise and we should stop doing it.

SBNF – BNF in S-Exprs – 2013-01-13T11:07Z

S-Expressions seem particularly well-suited to BNF formulations, giving a simple, regular, and memorable format.

Compensation for work is wrong – 2013-01-06T10:19Z

Compensation is a faulty notion; it does not actually happen, and indeed cannot happen. It is misguided as a basic concept of economic systems.

Money definitions are teleological and tautological – 2012-12-30T11:23Z

The dominant features of thinking about money are teleology and tautology. This is bad both for understanding and coming up with new ideas. We should think of it more computationally.

Credit for info-goods – 2012-09-16T09:56Z

Info-goods should include proper credit/acknowledgement should they not? Maybe that default intention is archaic and narrow, and it is now generally better to decouple description and associate it by hash.

Your next project? Design a new economic system! – 2012-09-09T09:26Z

We are surprisingly close to complete economic revolution. And this is a very interesting thing to ponder and imagine from a software view. Does that seem crazy? The reasoning is, however, straightforward: 1, the economic system works on money; 2, money is really information; 3, information technology is revolutionary.

Evolving global software – 2012-09-01T10:34Z

How should we develop software globally? Is it possible to say what kind of basic process and features, what broad strategies, are preferable? Here are three suggestions.

On Pagel's 'Infinite Stupidity', and what new information is – 2012-08-18T09:24Z

The article ‘Infinite Stupidity’ makes a novel and interesting point. But it does not quite seem to stand up, and examination of why begins to unravel what information is and where it comes from.

Names are wrong, tacit/point-free is right – 2012-07-08T09:07Z

In software, are names not a curiosity? They are like a mini embedded comment – nothing else is like that. But furthermore they seem structurally poor too. ‘Tacit-programming’ is the remedy.

Marxist efficiency – 2012-06-24T11:24Z

Marx's famous slogan of communism, considered purely in itself, seems wholly consistent with the core of (neo-)classical economics, but leads to a much more general perspective.

Artificial intelligence and the future – 2012-06-17T09:42Z

Is strong AI not very far away now? That is not the right question.

The internet, Kickstarter, and the obsolescence of markets – 2012-06-10T09:29Z

How much is the idea of markets obsoleted by digital networks ?

Why is information a string of digits? – 2012-05-13T11:16Z

The fundamental form of information seems to be a string of digits, e.g. DNA, text, bits. Why? This appears to be a peculiarly intriguing question. It is about something apparently very simple, yet it seems somehow profound.

Parsing wrongness and language value – 2012-05-06T09:07Z

Parsing is a poor choice of problem. Programming languages should help us see and help us move.

On VPRI STEPS – 2012-04-29T10:19Z

They seem to be producing a ‘second-draft’ of current practice, and making some good abstractions, not a revolutionary general technique. Perhaps because no general revolutionary technique seems possible for programming as such.

Money as a cooperative mechanism – 2012-05-08T11:21Z

What is money? It is a mechanism that supports/induces a particular framework of cooperation. And it is outdated.

Comparing natural language and software – 2012-01-22T12:07Z

Natural language is very different to software, but what is similar? what makes them seem related? They seem to focus on abstractions of different character.

Living software and dead software – 2012-01-15T11:41Z

What kind of software do you really want to make?

Software as thought – 2012-01-08T12:48Z

Chaitin's little quote about software is interesting but somehow seems not quite on target. So here is a new version, modified and expanded.

A copyright economy is a ‘waterfall’ economy – 2012-01-03T10:08Z

Copyright has deep intrinsic inefficiency and makes the economy like a weak software development process.

Software's economic basics – 2011-12-18T11:51Z

Software is about: designing the right(-est) thing, and letting anyone create benefit from it.

Why an information economy is not an IP economy – 2011-12-04T12:57Z

This is a prompt to think differently about information, IP, and their economic arrangement.

A logical analysis of copyright orthodoxy – 2011-11-27T11:47Z

There is a kind of rhetorical trick in copyright theory. The orthodox model appears to give a rational solidity to copyright, but as an argument for it it is unsound, and proves nothing of what it appears to want to.

Power, predictability, and regularity – 2011-11-13T12:41Z

At the deepest level, software seems to have an essential trade-off of power against predictability. And the problem there is not a matter of conformance but of clarity. That means perhaps the best we can do is design programming languages to have a kind of ‘regularity’.

Enduring software – 2011-09-25T10:06Z

Making ‘enduring software’ looks more like a requirements/product-design problem than an engineering problem.

The insoluble pragmatism of types – 2011-09-18T10:16Z

What one might think of as the problem of type systems looks, in a deep sense, actually insoluble. A useful module cannot be completely specified.

What part of design is possible? – 2011-09-11T09:48Z

Two of the underlying skills possible in engineering design must be part of the grounding of programming languages.

‘Long Now’ of software? – 2011-08-28T10:06Z

Is it possible to have a software equivalent to the ‘Long Now’ project? Can we imagine a software system that would last for 10000 years? (or even just 1000) This means both running and adapting/reusing – both of the two fundamental aspects of software.

The ‘ideology’ of software engineering – 2011-08-21T11:32Z

The theoretical ‘ideology’ of software engineering seems to be logical, mathematical – this is how we implicitly think of software, that is what computer science leads us toward. But is this a little misleading?

Reconsidering a Scheme formatting convention – 2011-08-14T09:44Z

A hugely important matter of getting source-code just right.

The embarrassment of copyright policy – 2011-08-07T11:13Z

Simply acknowledging the facts, or lack of them, leaves copyright in a surprisingly troubling position.

What is metadata? – 2011-08-01T10:44Z

It is usually described as ‘data about data’. But there is a slightly different angle to see it from – not so much ‘above’ but ‘beside’.

Defined rating systems, and Google +i – 2011-07-17T09:08Z

Rating systems – like up-voting buttons for news-blogs – have a problem: what do they really mean? They seem too vague. Rating probably ought to be more clear and articulated.

On Dijkstra on software's radical novelties – 2011-07-10T08:53Z

In ‘On the cruelty of really teaching computing science’ EWD1036, Dijkstra captures some deep truths of software – but seems to give them a somewhat gloomy cast. Software has radical novelties, but we should not see them in a negative way.

Distinguishing abstraction and change – 2011-07-04T11:25Z

Abstraction and change overlap in some way, and maybe it is worth thinking a little about what that means and how they are separate.

The aim of software engineering – 2011-06-27T08:42Z

What, as a discipline, is software engineering trying to do? – One could begin to answer that its purpose is to be an optimal intermediary between requirement and material: a tool that goes where you point it, and shows you where it is pointing.

A fault in blogs – 2011-06-19T09:09Z

We ought not to be using blogs so much.

The second basic question of software engineering – 2011-06-12T08:55Z

Saying we want to improve how software engineering is done seems OK, but can that be clarified? We understand what kinds of computation are efficient by formalising the idea of what computation is. We can perhaps understand what development is efficient by formalising what development is.

The functional/representational division in software – 2011-06-05T07:23Z

The division of software engineering into ‘functional’ and ‘representational’ aspects/structures can be expressed with a simple (if a little archaic) metaphor, and backed with some basic theoretical definition.

A comment on: ‘The Carrying-Cost of Code: Taking Lean Seriously’ – 2011-05-29T07:14Z

The original article seems, on analysis, contradictory to agile. But maybe some resolution is possible, by building more general knowledge from more general investigation.

Software engineering and philosophy – 2011-05-22T09:35Z

Software engineering and philosophy are in a sense (with a little imagination) twin subjects.

In Lisp, should lists be replaced with trees? – 2011-05-15T09:07Z

Conses/pairs/lists are rather low-level when you think about it. Would we not appreciate something just a little more powerful, a little more modern? A tree primitive is here casually and heretically proposed as a better alternative.

Machine philosophy rudiments – 2011-05-08T09:13Z

What is a machine? It is not a sort of complex mechanism. It is not a physical object. Or rather, it is not just those, or essentially those.

IT-farming (or not) – 2011-05-01T09:35Z

Why do IT people like to use the word ‘farm’? – e.g. ‘server-farm’, ‘render-farm’. It does not really make sense. What they really mean is factory.

Considering the limits of DRY(‘dont repeat yourself’) / factoring – 2011-04-24T08:26Z

Factoring is good, but it has to be limited by what you really know. Otherwise adding more abstractions obstructs change more than necessary. But it is not really a trade-off: getting one aspect right makes the other right too.

Surgical registries for software development? – 2011-04-17T09:13Z

Surgical practice has developed an alternative to scientific trials to build knowledge. Perhaps this approach could benefit software development.

Definition of ‘abstract’ – 2011-04-10T09:10Z

Abstraction is definable in a nice discrete way. And abstraction is a fundamental law of reality! maybe.

Licenses are not polite agreements – 2011-04-03T10:29Z

There is a quasi-meme-let around that proposes that software shrink-wrap copy-restriction licenses etc. are just honourable agreements. This is irritatingly spurious, and ought to be exposed. Here is a rebuttal – or inoculation.

Stone cathedrals, structure-preserving-transformations, and software development – 2011-03-27T10:46Z

This note stems from two sources: ‘How To Build A Cathedral’ (BBC; 2008) – a TV documentary; and ‘structure-preserving-transformation’ – a phrase from Christopher Alexander. And it leads to a seeming weakness in sofware development – how we systemetise ‘construction’.

Dependent types are about consistency – 2011-03-20T10:27Z

Dependent types allow constraints to be defined with (almost) full algorithmic richness. Thinking about what this is doing illustrates the distinction between ‘consistency’ and ‘verification’.

Software as web – 2011-03-14T20:11Z

wbcvsn-expansion:http://axisofeval.blogspot.com/2011/02/browsers-will-let-pls-break-free-from.html seems right, and worth considering more, on something of a tangent.

A small trick to Xor – 2011-03-10T21:08Z

An arithmetic way to perform exclusive-or – something that might have a small use somewhere.

Typing and visibility – 2011-02-27T08:33Z

Strong typing is better than visibility, but neither is quite what is wanted.

Wittgenstein for programmers (part 1) – 2011-02-19T11:13Z

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

Imagining ‘dynamic macros’ for Scheme – 2011-02-13T09:41Z

It seems possible to merge macros with lambdas, making a smoother single language feature. (At least, as far as a quick casual pondering will take you.)

Reflections on using Scheme – 2011-02-06T22:36Z

The Scheme (R5RS) translation of the MiniLight renderer has just been finished (the latest of 12 translations, 8 by the author). So now is a good time for some reflections on the language.

Testing: thoughts on improving it – 2011-01-30T09:17Z

What does testing really do? And how can it be improved? Thinking beyond the surface seems to lead away from testing and toward automation and ergonomics.

Corporation vs. internet – 2011-01-23T10:31Z

(It is not really just Facebook, it is a general problem.)

OO modelling and the real-world – 2011-01-16T09:49Z

A philosophical answer to a post at Lambda The Ultimate (wbcvsn-answer:http://lambda-the-ultimate.org/node/3265) (pointed out by axisofeval) which asks: “Why are objects that we use in programming so vastly different from real-world objects?”

Programming is probabilistic – 2011-01-09T10:23Z

In common programming, we use abstractions in a particular kind of probabilistic way. It is normally in the background, but is fairly well-defined, and deserves more examination.

Normalised comment rating – 2011-01-02T09:55Z

News-‘forum’ sites, like Hacker News, seem to rate comments just by counting votes: is that sophisticated enough as a measure?

Code style and patterns – 2010-12-27T10:08Z

Code style is open to the same criticism as software patterns – they are indicative of a lack – but they may also be unavoidable

A comment adding to Dijkstra on natural language programming – 2010-12-18T21:58Z

To add to Dijkstra's note ‘On the foolishness of “natural language programming”’: language and program are not even properly comparable

The attribution ingredient in IP justification – 2010-12-11T13:31Z

Mere claim of authorship is insufficient for ownership rights

Implicit code – what makes it good or bad – 2010-12-04T17:16Z

To make a software structure implicit you should adhere to a clear abstraction – then being implicit is good and not bad

Should there be hard limits on program part sizes? – 2010-11-24T19:27Z

There is cause to, based on complexity, but a better solution seems to be to adopt a different structuring – one with different scaling behaviour

‘Incentive’ in intellectual monopoly – 2010-11-16T18:14Z

IP does not give incentive, but a fix for market inadequacy

Designed software will never be substantially higher quality – 2010-11-09T21:02Z

There is a myth in software, that if we could somehow find the magic knowledge, all our software could be built to some future ideal. This cannot be right

What is a 'strong' or 'weak' standard? – 2010-11-01T19:47Z

Here is one possible measure of standards, and abstractions generally, by seeing the gaps in them

The big fault in OO – 2010-10-26T20:52Z

OO's central abstraction – the class – is too weakly, loosely defined.

The software engineering equation – 2010-10-06T20:11Z

If there were a single equation summarising all software development and use – a ‘law of infodynamics’ – what would it be like? – Here is a quick imagination of one.

A conversational convention for the web – 2010-08-11T22:47Z

A simple ad-hoc ‘semanticised web’ idea for making structures of related texts.

Why economists like copyright; but shouldn't so much now – 2010-08-02T22:52Z

A perspective on the basic connections of copyright, industry, and internet.

A Comment On: ‘Why writing software is not like engineering’ – 2010-07-20T18:42Z

Seeing the kernel of engineering in software development.

Alternatives To Design-Construction-Maintenance – 2010-07-13T21:23Z

A possible model of development based on software's own particular ‘material’.

A Core Of Programming – 2010-07-06T22:16Z

A few key structures that most programming languages share.

Copyright ‘Losses’ And Public Gains – 2010-04-25T21:49Z

How a common corporate message of copyright and the internet is the complete upside-down of truth.

The ‘Important First’ naming rule for software things – 2010-04-20T20:46Z

A small but valuable rule for naming things, that seems less considered than perhaps it ought to be.

‘Getting Things Done’ and software architecture – 2010-03-30T19:17Z

There is an interesting characteristic of ‘Getting Things Done’: it seems algorithmic, computational.

Future software engineering's three bases – 2010-03-17T21:04Z

The future of software engineering is in combining less deliberate design with more automated generation and evolution.

Design should be backward-looking – 2010-03-13T17:25

Good engineering design rests essentially on good knowledge – not prediction.

There is only one program – 2010-03-02T21:57

Software tends toward a continual global ecosystem.

The simple rule of why copyright is now broken – 2010-02-21T11:00

Internet benefit is inversely related to copyright strength.

An outline map of software development – 2010-02-15T21:41

A way of dividing up and placing the parts of software development, in terms of other established fields.

Keeping your new ideas secret is probably wrong – 2010-02-09T20:01

A simple rational demonstration.

The illusion in up-front design – 2010-02-01T20:38

There is an illusion in the idea of up-front design in software (that is, code arrangement, not algorithm), that makes it seem more plausible than it really is.

The essential weakness at the core of Google search – 2010-01-22T20:23

. . . and a related problem in user-moderated comment systems.

Paying For Information, Asymmetrically – 2010-01-13T19:17

The most reasonable way to pay for information is right in front of us.

Software Engineering Materialism – 2009-11-16T19:12

It is good to think of software engineering as ‘the design of structures in a special abstract material’.

The morality of copying: a simple Kantian evaluation – 2009-11-10T21:54

A simple, solid argument for the moral goodness of copying.

Vitruvius - 'Firmitas, Utilitas, Venustas' - In Software – 2009-10-25T21:23

Vitruvius' ancient principles of architecture can be used to view software.

Genome Versus Programming Language – 2009-10-19T20:52

Genomes have an extra means of code expression/expansion compared to artificial software.

Genomes As Software – 2009-08-31T20:06

A genome is a digital object, and the way it works as a system may be significantly like software.

A Comment On ‘A Conversation with Alan Kay’ – 2009-08-06T11:42

An observation on an interesting software development analogy.

‘Software Design’ Is Not Design – 2009-05-23T10:24

Software engineering should not be obsessed with representation.

The Missing Principle Of Programming Languages – 2009-05-12T17:48

Languages should support data/computation mechanics (mostly known as performance evaluation/analysis).

The Third Principle Of Programming Languages – 2009-05-05T11:32

A main driver of language design must be the extended design process.

Better HTML fragment referencing, and RDFa – 2009-04-26T21:36

A look at the relation of HTML fragment identifiers and the joining of the GGG with the WWW.

Why Data-‘Piracy’ Is Morally Good – 2009-04-19T10:43

An ethical way to understand and deal with intellectual monopoly and data-'piracy'.

Philosophy Of Software Development – 2009-04-10T16:36

A proposal for a philosophy of software development.

Structured Object-Oriented Programming – 2009-04-07T12:28

Inconclusive consideration of Structured Programming and Object-Orientation.

Determinate Knowledge In Software Engineering – 2009-03-25T17:09

A brief overview of software engineering's principal parts.

The Problem With More Web JavaScript – 2009-03-14T17:38

An extra abstraction might be now needed for web-app engineering.

Logical Structure And Software Architecture – 2009-02-26T11:14

A brief adumbration of software architecture and its underlying realm.

Software ‘Mass-Production’ – 2009-02-19T15:18

A quick formulation of mass-production for software.

Software Development In A Nutshell – 2009-02-18T09:34

An attempt at a minimal 'well-founded' or 'historically-informed' conception of software development.