Rules For The Application Of Rules
Response to a philosopher's question.
(DRAFT: Liable to change)

Aaron Sloman
School of Computer Science, University of Birmingham.
(Philosopher in a Computer Science department)

Installed: 18 Feb 2012 (But written 3 Dec 2009)
Last updated: 18 Feb 2012
This paper is
A PDF version may be added later.

A partial index of discussion notes is in

Response to a message posted on a philosophy list

Date: Thu, 3 Dec 2009 14:32:44 GMT
From: Aaron Sloman
Subject: Re: rules for the application of rules

This was posted to a philosophy list

    I'm looking for examples of rules for the application of rules. This isn't an
    anti-Wittgensteinian manoeuvre, it's an exploration of the place of "judgement"
    in decision-making.
This was my response, sent privately to the poster:
A very rich supply of examples of processes of application of rules, including rules
for application of rules (e.g. the definition of an interpreter or a compiler for a
programming language) can be found in computing systems (generally used every day by
philosophers and ignored every day by philosopers).

E.g. a difference between a compiler and an interpreter is that the former spells out
details of how to follow rules in advance of the process of following them (i.e. it
is 'ballistic'), whereas an interpreter takes decisions at "run time" about how to
follow rules and can therefore be more context sensitive and even change what rules
mean half way through applying them.

Closely related are polymorphic rule-schemas where a rule is only partially specified
and the rule interpreter (or something else) has to fill the gaps (subject to
constraints, usually) in order to generate a rule that can be applied. That's one of
the ways programmers extend the generality and flexibility of their programs (a
feature of poorly named 'object oriented programming').

There are also systems involving rules for the formulation of rules (e.g. using type
theories to exclude some combinations -- closely related to what philosophers have
called category mistakes).

There are other situations where some central authority specifies standards (e.g.
standards for email formats and how to interpret them, how to extend them, etc.) and
then if different developers produce rule sets that adhere to the standards those
systems can inter-operate (unlike many Microsoft systems!).

Some of the rules operate on physical systems (e.g. devices like screens) or disc
drives. Some operate on abstract digital systems (bit patterns). Others operate on a
whole variety of types of virtual machinery (e.g. pieces and board in a virtual game
of chess):


We can also distinguish systems that follow rules (or rules for applying rules)
without knowing that they are doing so from systems that do know that they are doing
it and can reason about what they are doing (e.g. take decisions about priorities, or
when to abandon a task, etc.).

That's just a tiny subset. Probably your local computer science department could
provide you with many more.

Biology is also full of examples. E.g. there are many fascinating examples (and
unsolved problems) in epigenesis. How does the evolutionary process produce rules for
building individuals that create or modify rules as a result of interactions with
their environment? Much of that seems to involve rules for applying rules in a
context-sensitive way.

I suspect that programmers have done more work producing, analysing, and debugging
rules in the last 50 years than all of humanity in its preceding history. But mostly
they are not taught to think philosophically about what they are doing.
Aaron Sloman

Maintained by Aaron Sloman
School of Computer Science
The University of Birmingham