Building terminological consensus, part 1: Foundations

Hash: SHA1

I'm going to try a new tack on the terminology discussion, drawing as
best I can on all the useful work that's been done in the preceding
Terminology thread [1], which has been very helpful in teasing out the
issues with the TAG's terminology, particularly as manifested in
WebArch [2].

This is the first in a series of messages in which I want to try to
synthesise and summarise, without necessarily explicitly following up
on specific previous posts, trying to build up slowly, checking that
we have common ground at each step.

My basic goal is to set out my understanding of the relevant words and
phrases from the philosophy of language and related disciplines, and
explore their application to the Web.  Along the way, I'll try to
connect up with the specific terms and usages of WebArch.

Aside from the obvious point that people, particularly people with
familiarity with the philosophical terminology in this area, have had
problems with WebArch's usage, and we should try to fix this, I have
another reason for stepping back and attempting this review: there is
something special about computational systems (including, but not
limited to, the Web) in this space, as pointed out by Noah Mendelsohn
in his contribution to this thread: such systems not only
manipulate symbols which function as names, they often actually get
behind the names in a way which is pretty much unprecedented.  I'm
curious to see how this stresses the traditional philosophical

Consider a computer program which simulates an automobile engine.
Stipulate that it has a variable named 'waterTemp', which, we might
say, denotes the (simulated) water temperature in the (simulated)
radiator of the (simulated) engine.  We might find in such a program
some such statement as

   waterTemp = ( waterTemp + engineBlockTemp ) / 2 ;

which we can understand as saying that at each step in the simulation,
the water temperature is updated by averaging it with the temperature
of the engine block.  So far, so good -- the symbols in the program
are being used just about exactly the same way that the phrases "water
temperature" and "temperature of the engine block" are in ordinary
language, that is, they are being used as referring expressions, or

But in the case of the computer program, they are actual something
more -- when the program actually _runs_, they are causally connected
to the actual (binary representations of) the (simulated)
temperatures.  The above program statement, when exectuted, actually
_changes_ the (simulated) water temperature.

And this sort of thing is not restricted to simulations -- when I go
online to my bank and pay my electricity bill, there is,
oversimplifying of course, a statement in a program which reads

   balance = balance - billPayment ;

When _that_ statement is executed, my _real_ bank balance changes,
courtesy of a change in the (binary representation of) the number
named by the symbol 'balance' in the context of that program.

(I said above that this causal connection between name and denotation
is pretty much unprecedented in natural language -- there is at least
_one_ precedent, namely what speech act theory calls 'performative'
utterances.  When the registering officer says "I pronounce you man
and wife", the world changes.  I'm not sure to what extent this
illuminates the issues at hand.)

OK, back to the beginning.  Following the informal precedent of this
discussion so far, I'll use prefixes to mark technical terms with
their owners, so, e.g. pl:denote for 'denote' per Philosophy of
Language, webarch:identify for 'identify' per WebArch,
la:depict for 'depict' per Goodman's _Languages of Art_ [3] and
vsr:expression for 'expression' per Cantwell Smith's "Varieties of
Self-Reference" [4].

pl:referring_expressions, in particular pl:names, pl:denote
pl:referents.  pl:proper_names approximate pl:rigid designators, which
have exactly one pl:referent.  Some pl:referring_expressions, known as
pl:indexicals, may have different referents depending on the context
of use, for example 'I', 'over there', 'next Thursday'.  One response
to this is to distinguish pl:meaning from pl:interpretation,
describing pl:meaning as a mapping from pl:context to
pl:interpretation, where it is pl:interpretations (of names
respectively sentences) which are pl:referents or have truth values.
Thus when two disputants each say "I'm right, you're wrong", their
utterances have the same pl:meaning, but distinct pl:interpretations,
of which at most one is true.

How the relation between pl:proper_names and their pl:referents is
established, transmitted and maintained is the subject of considerable
debate, but one currently popular position associated with Kripke [5]
distinguishes categorically between pl:proper_names and other
pl:referring_expressions, appealing to a notion of original pl:baptism
for the former alone.

So far so good -- I think we can establish some uncontroversial

  pl:proper_name == webarch:URI
  pl:denote == webarch:identify
  pl:referent == webarch:resource

Both sides of this set of equations gloss over the
pl:meaning/pl:interpretation distinction, although in slightly
different ways.  "John Smith" is actually a pl:indexical, and needs a
context to uniquely determine a pl:referent, whereas webarch:resources
can themselves _be_ pl:indexical -- WebArch would say that _the_
webarch:resource webarch:identified by is
something like "the current front page of the Manchester Guardian".

So wherea the pl:meaning of a pl:referring_expression is a function,
and thus something quite different in kind from most pl:referents,
webarch:resource does double duty, corresponding to both pl:meaning
_and_ pl:interpretation in a more careful set of equations:

  pl:proper_name == webarch:URI
  pl:denote == webarch:identify
  pl:meaning == webarch:resource
  pl:interpretation == pl:referent == webarch:resource
It's also worth noting that some URIs are more like pl:proper_names
than others -- there's a sort of continuum determined by URI scheme,
with uuid: at the most rigid end, ftp: and http: in the middle, and
mailto: being a bit off to one side. . .

Finally for this first message, note that there is another
correspondence which I think obtains:

  pl:baptism == [webarch:minting] ([2] itself doesn't actually have a
                                   term for this, but minting is commonly
                                   used in discussion of the Web )

In both cases the person who first 'utters' a name has the authority
and takes the responsibility for determining the
pl:referent/webarch:resource it will thenceforth
pl:denote/webarch:identify.  In both cases such authority may be
exercised felicitously or spuriously.


[3] Goodman, N., _Languages of Art: An approach to a theory of
    symbols_, second edition, Hackett Publishing, 1976.
[4] Cantwell Smith, B., "Varieties of Self-Reference," in Joseph
    Halpern, ed., _Theoretical Aspects of Reasoning about Knowledge_,
    Morgan Kaufmann, 1986, pp. 19-43.
[5] Kripke, S., _Naming and Necessity_, Cambridge, MA: Harvard University
    Press, 1980.
- -- 
 Henry S. Thompson, HCRC Language Technology Group, University of Edinburgh
                     Half-time member of W3C Team
    2 Buccleuch Place, Edinburgh EH8 9LW, SCOTLAND -- (44) 131 650-4440
            Fax: (44) 131 650-4587, e-mail:
[mail really from me _always_ has this .sig -- mail without it is forged spam]
Version: GnuPG v1.2.6 (GNU/Linux)


Received on Monday, 9 July 2007 15:15:59 UTC