12.5.2006
(If you don't like polemics, skip this one ;-)
Someone who studied computer science recently told me that he had a look
or two into logic courses at the philosophy department then, and he expressed
mild contempt on what he saw there. If I remember his words correctly, he
thought that the entire course's programme there was covered by just the
first two weeks of 'Introduction to theoretical computer science' he was
doing in his own studies.
Now this did not fit with my recollections from logic courses (but then I
may have been lucky at the time). I remember very well a two-term (which
means one year's length in Germany) logic course that started with
propositional calculus, then introduced semantic tableaux, and continued
with quantification, identity and non-truth-functional operators. We had an
excellent teacher and were very well trained after this - which was at the
end of the first term. In the second term, we discussed infinity and its
axiomization, decidability and the incompleteness of arithmetics (i.e.
Gödels proof). The class grew very small during this, and only a
handful of students remained, but even those who opted out thought it had
been well worth the effort. When I was doing CS courses (later), there was
a lot more maths (which easily makes the impression of dealing with
something extremely difficult) and a different focus of attention to things
like Turing machines. But I wouldn't say it was more or less challenging,
or that I would have learned more or less interesting things. I'd rather
say I learned two different (and sometimes not so different) ways of
looking at the same topic.
Apart from that, on the philosophy side, I heard lectures in medieval
and early modern logic, and also one about logic around Kant's time. Of
course these things are not of much interest to anybody doing CS today.
But they are important to understand the frame of thinking that makes up
much of the background of Ockham, Descartes, Leibniz or Kant. And after
all, there is a bit more to philosophy than just the bit that's needed for
computational purposes, isn't there?
On the other hand, there are some bits in logic (and philosophy
of language) that seem to be only poorly covered in CS courses. For
instance the difference between names (i.e. proper names) and definite
descriptions.
There are some splendid examples of this even if you look not much
further than just
http://eclipse.org. Eclipse is a great example of a name. But what is,
say 'Eclipse Modeling Framework'? Or 'Testing and Performance Tools
Platform'? Now, by sheer chance, there is a car that is called like the
former one. There is none, and never will be, anything that is named in the
manner of the latter. And that is because 'Testing and Performance Tools
Platform' is not a name. It's a description. It describes something, by
telling what it is, by bringing it under some general concepts. The same
applies to the 'Eclipse Modeling Frameworks', which you may describe to
someone as just that: the modeling framework for Eclipse. (Note that the
capitals and quotation marks are gone ...)
Conversely, there is heavy misuse of names in the software world (or
rather, in the connected marketing departments). In some situations, it is
sensible to get some order into things by numbering them. Almost every
software comes in different versions. That is because it might be
interesting to know when a certain feature or API (Application Programming
Interface) was introduced. Now, for some software it seems not to be cool
enough if you talk about the new features of, say, version 1.4. This is
then helped by inventing 'code names'. Every version gets one, and you
don't count as an insider if you don't know how to resolve these code names
back into an ordered track of version numbers. (Not that it matters much -
these names are so widely spread that the problem is not so much not
knowing them as not to confuse them with other, equally cool, code names.)
What good is it to know that such-and-such API was introduced in 'Merlin'
rather than in 'Tiger'? Unless you know the entire line of names by
heart (and haven't forgotten half of it after a while), you can't even
infer that it must be in 'Tiger', too (because 'Merlin' was earlier).
Compare with this interchange: "Is that API available in version 1.5?" -
"Yes, it was introduced in 1.4."
Therefore, perhaps it would be a good idea to teach students of computer
science a little bit more about the proper use of names and descriptions.
There might be a chance that future ages would not have to put up with
having to use names for things that require version numbers, and non-names
(or quasi-names) for things that could do with a nice proper name.
