This is a useful distinction made by philosophers of language. It allows for there to be an important difference between using a word, as we normally do, and mentioning it. If you use a word, you are talking about the thing that the word denotes. For example, if you say, "The American government is corrupt," the subject of your speech is the actual American government, out there in the real world. If, on the other hand, you merely mention a word, you are not talking about the thing the word denotes, you are instead talking about the word itself. For example, "The word 'kiss' starts with a pointy letter." In this sentence, you are not talking about anything resembling the meeting of the lips with a surface, you are talking about a symbol in English, which happens to mean something like that.

This can be a useful distinction to make when hate speech is under discussion. For example, it is and should be perfectly allowable for me to say, "'Nigger' is a perfect example of a word that often promotes racial tension." If I were to say, "All niggers are short," this would be bad (although, in an interesting case of self-reference, both of my examples are actually mentions--I am mentioning them as examples of what I could say, rather than actually using them).

The big tipoff in written English that there's a 'mention' situation going on rather than a 'use' situation is the presence of quotation marks. Though sometimes used in other ways (for example, in the previous sentence), any mention should be surrounded by single or double quotation marks, as a way of letting the reader know that that's what's going on.

This can also be a way of getting around the age-old problem of tattle-tails: how to accuse someone of swearing specifically. You can't usually run up to the teacher and say, "Miss Ingle, Johnny just said, 'fuck'!" However, I absolutely hate hearing an exchange like this:
Billy: Miss Ingle, Johnny just said a bad word!
Miss Ingle: What did he say, Billy?
Billy: He said, umm... well... (of course, he can't describe it by its meaning, because little Billy has no clue what it means)
Miss Ingle: Was it a very naughty word?
Billy: I don't know. Mom gets mad at Daddy when he says it, though.
Miss Ingle: I'm going to shut my mouth now, because the author of this dialogue is already being driven crazy by this insipid nonsense.

So, my opinion is that people should always be allowed to mention swear words, so long as they do not use them. I'm still not going to encourage my kids to mention swear words in school, though.

Part of the idea of this node is to allow me (and others, if you wish) to softlink it when talking about words you don't like to use--feel free to use it for this purpose!
The use-mention distinction is a very important concept that comes out of the study of Logic that helps us understand the complexity and flexibility inherent in natural language. In ordinary usage, speakers may alternate between using and mentioning things without even noticing it. For example, consider the following two sentences:

Life is a many splendoured thing.
Life begins with the twelfth letter of the alphabet.

The first sentence uses the word "life", while the second sentence mentions it. When one uses a word, one invokes its meaning, intending it to stand for the thing in the "real world" that it refers to. Therefore in the first sentence, the speaker intends the listener to interpret the word "life" as referring to the concept of life as it exists for us in the world.1 In contrast to this, we would find the second sentence to be utterly non-sensical if we were to assume the speaker were using the word "life", just as in the first sentence. If so, this would mean that life began not with conception or birth (or even at forty), but rather with an L, which just seems plain strange. It is clear that in this case, the speaker is mentioning the word, intending the listener to be aware of the word itself --the lexical entity-- rather than what it stands for.

While the ability to move back and forth so easily between these two senses is convenient, it actually belies something very fundamental about the nature of natural language and its descriptive power. When we use a word, we are using language as an object language, a language which solely talks about the world. It can talk about entities in this world, and assign truth values to them. When a word is mentioned, however, we are using language to talk about itself. In the second sentence of the example, English is talking about the orthography of one of its words. This self-referential capability is a property of a metalanguage. What is so fascinating is that we are able to discuss both the world and our own manner of discourse (language) with the same language!

In typical writing, words that are mentioned are placed in quotation marks, in order to make it clear that we mean to refer to the word itself. 2 According to this convention, the second sentence of the example should really be written:

"Life" begins with the twelfth letter of the alphabet

More examples include: and so on... Note that the song "Friend is a Four Letter Word" by Cake should actually be titled "'Friend' is a Four Letter Word" because it is mentioning rather than using the word "friend".

Outside of logic and proper writing, the use-mention distinction has found an interesting place in the study of computer science. Consider the case of a bit of code that prints something out to the screen. Taking an example from C, the typical syntax for this would be:

printf("Hello World!");

where the quotation marks are used to delimit what is to be outputted. But what if we wanted to print out a phrase that itself contained quotation marks? Instead of using the quotation marks, we should like to mention them in our phrase. How does the computer know the difference between these two functions? The answer is to be found with escape characters which are are a conventional way to signal that we wish to mention the quotation marks.

printf("Why does every single textbook program write out \"Hello World\"?  Arrgh!");
Consider next the more complicated task of having a program document itself, essentially to print out its own contents. Any simple, straightforward attempt at this will fail because we inevitably have trouble switching the code from a use function to a mention function. (for more on this, see quine) What about if we wish to write self modifying code? The Java Reflection package, for example, allows programs to introspect upon themselves, to in a sense access their own code. Dizzy yet?

Finally to end this discussion on a fun note, here's something amusing that I found written in the Linguistics dept. lounge at the University of Edinburgh:

If you use a mention
in use then you
don't use the use-mention
distinction usefully.
          (just thought I should mention it)

1 This example is a bit tricky, because life isn't a very concrete concept, but bear with me.
2 For an example of this convention, just look at this writeup itself. If I refer to the word "life" (like right now!) I use quotation marks.

There is a special case of language in which the use-mention distinction is particularly vital: computer languages, with pointers. Just like in human languages, it provides great power - but it is also a great cause of errors, especially for programmers who are copying code examples without comprehension of what's going on.

Let's look at this pseudo-C/C++ fragment.

// we have an independently initialized pair of pointers-to-int, foo and bar.
*foo = 0; *bar = 0;// this means that the contents of the addresses (hereafter 'data') pointed to by foo and bar are both assigned the value 0.

// Now let's check some equalities.

*foo == *bar; // true. The data pointed to by foo and bar are both 0. This would be a use of what foo and bar are pointing at.
foo == bar; // false. Foo and bar point to different addresses. This would be a use of foo and bar, and a mention of what they point at.
&foo == &bar; // false. Foo and bar themselves have different addresses. This is use of the implicit underlying structure of foo and bar, a mention of foo and bar themselves.
// now assign bar to foo, just to complicate matters...
delete bar; // the address pointed to by bar is now history. For C, free(bar).
bar = foo; // assign bar to point to the same address that foo does.

// and try checking some more equalities.
*foo == *bar; // still true...
*foo = 3; // change the data in address pointed-to by foo to 3 rather than 0.
*foo == *bar; // STILL true, since foo and bar are pointing at the same address.
foo == bar; // true, for the reason demonstrated above - pointing to same address.
&foo == &bar; // false. Foo and bar are still distinct variables, so THEIR addresses differ.

Things get even more complicated when we add pointers-to-pointers. That would be akin to "Tommy asked, "Did Katie say, "Devilbunny needs a ham!"?".".¹

All of this is rather different from standard languages, in which one does not normally work on the second level, with values that are mutable. Ice Cream can be two words or a tasty treat - but it's rare to try to reassign it to no longer mean that sweet melting stuff... while almost the whole purpose of using a pointer is to reassign it. Still, the matter of content vs. container is the heart of this distinction.

Taking up the escape character idea above, note that HTML uses the "&" for escaping things, but does so via macros rather than simple escapes. That is to say, to type that ""&"", I had to type "&", and to type THAT, I had to type "&", ad nauseam. It's just as bad as the mess with asterisks and ampersands that C and C++ provide.

Actually, it looks like you can get away with bare quotation marks in HTML, so I would only have had to expand the ampersand.

¹Yes, that last bit of punctuation was incorrect for English - but it makes sense. And snce they had had different end marks, it was actually kind of important. Sorry for letting that rant leak in here

Log in or register to write something here or to contact authors.