Re: Fortran or Ada?

[Daniel Barker <sokal@holyrood.ed.ac.uk>]

`In the language of everyday life it very often happens that the same word
signifies in two different ways - and therefore belongs to two different
symbols - or that two words, which signify in different ways, are
apparently applied in the same way in the proposition. 

`Thus the word "is" appears as the copula, as the sign of equality, and as
the expression of existence; "to exist" as an intransitive verb like "to
go"; "identical" as an adjective; we speak of SOMETHING but also of the
fact of SOMETHING happening. 

`(In the proposition "Green is green" - where the first word is a proper
name and the last an adjective - these words have not merely different
meanings but they are DIFFERENT SYMBOLS.) 

`Thus there easily arise the most fundamental confusions (of which the
whole of philosophy is full). 

`In order to avoid these errors, we must employ a symbolism which excludes
them, by not applying the same sign in different symbols and by not
applying signs in the same way which signify in different ways. A
symbolism, that is to say, which obeys the rules of LOGICAL grammar - of
logical syntax. 

`(The logical symbolism of Frege and Russell is such a language, which,
however, does still not exclude all errors.)

`In order to recognize the symbol in the sign we must consider the
significant use.

`The sign determines a logical form only together with its logical
syntactic application.

`If a sign is NOT NECESSARY then it is meaningless. That is the meaning of
Occam's razor.'

- Wittgenstein, Tractatus Logico-Philosophicus, propositions 3.323-3.328.

(Capitals used in place of italics. Translation is the original 1922
version, by Ogden, which had Wittgenstein's approval. Published in London
& New York by by Routledge; reprinted 1996.) 

If I may veer into another language, C - and thus justify adding another
news group to the `to' line -

#include <stdio.h>
main()
{
  int a[100];         /* `a' means array */
  printf("%p\n", a);  /* `a' means pointer */
  a = a + 1;          /* ILLEGAL, since `a' means array again */
}

`a' here means two different things:

(1) an array of 100 normal-width integers;
(2) a pointer to a normal-width integer (in fact, to the first integer in
an array of 100 such).

To say that, in the call to printf(), the first thing is implicitly
converted to the second thing is to linguistically `work around' the basic
problem, that `a' has two meanings. Meaning (2) can also be expressed as

&a[0]

So, the example reveals two faults in the C language. Namely, that `a', as
a local variable in one function, can have two meanings; and also that one
of these meanings is may be expressed by either of two symbols. This is a
crying shame! Why does `a' have two meanings, when, given the possibility
of `&a[0]', one would have sufficed without reducing the functionality of
the language?

The answer is historical, as revealed by an interesting paper, "The
Development of the C Language" by Dennis Ritchie, available from Dennis
Ritchie's home page, http://plan9.bell-labs.com/cm/cs/who/dmr/index.html.


Daniel Barker,
Institute of Cell and Molecular Biology,
Swann Building,
King's Buildings,
Mayfield Road,
Edinburgh
EH9 3JR
UK