Home   Vita   Projects   Papers   Journal 


Online Journal

  • 12.5.2006

    The proper use of proper names and descriptions

    (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.


All content on this site is Copyright (c) 2005-2012 by Leif Frenzel. All rights reserved.