Conventionalist Theory of Reference is Comparison to Programming Language

A Semantic and Pragmatic Analysis

by Evan D'Elia

I believe Gareth Evans' conventionalist theory of reference can be saved by comparing the basis of the theory to that of a computer language.

This analogy identifies why Gareth Evans' theory is the best for explaining the natural way in which we already use names.  A computer language works with references and names the same way we intuitively do in conversation.  Therefore, I argue that successfully comparing the conventionalist theory of names to a programming language proves that the conventionalist theory of reference explains our use of names in daily conversation and refutes the following argument.

The argument states that proper names are special because an individual can use a name without there being a predefined social convention.  This will be shown to be false and that, in fact, proper names follow Gareth Evans' theory of reference.

For this article, I will be making the analogy between Gareth Evans' conventionalist theory and that of the computer programming language JavaScript which is common on all web browsers today.  All of the concepts which will be discussed not only apply to JavaScript but also apply, in some degree, to all programming languages.

For simplicity's sake, I will only use examples from JavaScript in order to clearly flesh out the analogy.

First, I will explain how Gareth Evans' theory of reference treats the meaning of words similar to the way variables are defined within a computer program.  Then, when comparing social conventions to that of a computer function, it will be shown that the theory of reference still holds for common words like "dog" and, also, for proper names.  Finally, using this analogy, we can explain other common uses of proper names, such as nicknames.

The first premise which Gareth Evans outlines for a conventionalist theory of reference is that, "... there is a community 'C' in which it is common knowledge that members of 'C' have in their repertoire the procedure of using [a name] 'NN' to refer to [a thing] 'x' (with the intention of referring to 'x')"  (The Causal Theory of Names, p. 17).

This is similar to Saul Kripke's causal theory of names in that both theories depend on a tangible source by which 'NN' refers to 'x'.

Saul Kripke believed there must be a causal chain leading to a source which originally used 'NN' to refer to 'x'.

Similarly, for Gareth Evans, the source which allows 'NN' to refer to 'x' is a social convention in which a group, 'C', uses 'NN' to refer to 'x'.

In both cases, there must be a real world instance (social convention or source) which leads to us to positively conclude some name can refer to some real world thing, except for Gareth Evans there must also be intentionally behind the use of a name to refer to a real world thing.

In JavaScript, to define a variable we first use the expression "var".

This signals that a name is about to be defined and given a value.  This signal is much like that of Gareth Evans' social convention because it shows the intent to use a name for a value.  This process of using "var" to define a name may also seem like the origin in a causal chain, but if we were to try and compare this programming convention to the causal theory of names, we would be forced to ask ourselves: Why do we use a convention to signal the origin of a name?

The answer to this question is that we use social conventions, not to signal the "origin" of a name, but rather to define a social group in which the name can be used.

Due to this fact, it should be clear that the conventionalist theory does better than the causal theory of names in this situation.  It is also important to note that you can only define a variable once.

Once a variable is given a name, you can still change the value of the variable, but you can never again define another variable using the same name.  This means that when you use that variable's name in the program, there exists one and only one thing which it can refer to.  I believe this is important because, as Gareth Evans argues, we must be able to distinguish between "dead and live metaphors" (The Causal Theory of Names, p.17).

I believe he means here that we must be able to distinguish between words which refer unambiguously to real world things and those which do not have such a basis.

When the computer program sees the name of a given value, it knows that there exists only one place in memory where a value is stored for that name.  Variables aren't the only thing that programs are made up of, though.  There are also functions and loops where these variables can be manipulated.  Now that we understand how names are similar to variables in a programming language, we can look at how a program works with variables within functions and loops.

In a computer program, functions and loops usually serve the purpose of manipulating the data stored in the variables and producing some kind of output.

I would like to make the comparison that these functions and loops are like a social group in Gareth Evans' conventionalist theory.

In addition, making this comparison we will see that names, even if used by only one person, can qualify as a social construct.  When a variable is defined, that variable also has what is called a scope which is dependent upon where in the program it was defined.  In JavaScript, if a variable is defined outside of all functions, meaning it is defined globally for the entire program, then any function or loop may use that variable by referencing its name.

If the entirety of a computer program is thought to be the entirety of a country, then defining a variable globally can be thought of as having a country-wide social construct such that the name 'NN' refers to the value, 'x', which is stored in that variable.

Instead of defining a variable globally, what happens when a variable is defined inside of a loop or function?  The scope of the variable will now only apply to the loop or function which it is defined in.  This means that the variable will only exist as long as the function or loop is running.  Therefore, the social convention only exists in a community, 'C', which is as large as the length of the loop or function.  For this reason, we can now argue that no matter how large the scope of variable, as long as a variable is defined in a loop or function, that variable can be used as a social convention.

In the example that I call my pet "Boris" there exists a social convention between myself and only myself (let's not count Boris) in which I use the name "Boris" to refer to my pet.  Analogously, this would be as if I created a function in which all the function does is define a variable named "Boris".

Even though no other functions use this variable, this variable is still valid and can be used or manipulated inside this small function.  The variable still has a scope just like in the example there still exists a social convention.

This analogy can also explain the use of common words such as "dog".  We can say that such a word is defined globally since there is a country-wide social convention to call what we know as dogs by the name "dog".  We can then say that different languages or even slang and other colloquialisms used to refer to dogs are all valid, but the caveat is that these names/variables have different scopes and therefore different but still valid social conventions.

So far we have only seen how different social conventions are created, but it is also important to note that not all names are mutually exclusive.

To explain what I mean by mutually exclusive, let us consider two different social groups, one which uses the name "Punxsutawney" to refer to a groundhog, and one which uses "Phil" to refer to the same groundhog.

Upon the second group hearing the name "Punxsutawney" when referring to what they believe is "Phil", they may also adopt the name "Punxsutawney" as if it were the same as "Phil".

They are still referring to the same value, but it is as if the first group passed their own social convention onto the second group.  The name "Punxsutawney" is not exclusive to the first group and may be passed to other groups as long as they know they are referring to the same object, in this case, a groundhog.

In computer functions, something similar also occurs.  When calling a function, the function may take certain parameters.  This function can then use those parameters however it pleases and call those parameters whatever it wants within its own scope.  When calling the function, one may pass in already existing values that go by different names.  For instance, one function may have the parameter "Boris".  Someone may then call this function by passing a variable with name "Bilbo" into the parameter.  When "Bilbo" is passed to the function, "Boris" will then refer to the same value which "Bilbo" refers to.

This construct of passing one variable from function to function can be equated with the real world construct of nicknames.  When giving a person or thing a nickname, the name still refers to the same real value, but only certain social groups or functions may be privy to the use of this name.  Additionally, when we discussed loops and functions, we saw that the variables in that scope only exist for the length of the loop or function, just like how nicknames may cease to be used once a social convention or social group has ended.  In this way we are able to explain the way we commonly use names in the real world by passing them between social groups and creating different social conventions among respective groups.

After drawing the analogy between computer programs and the way we assign names to values in the real world, we can conclude that names refer to their referents in the same way a computer program allows variables to refer to a value.  Like names, a variable provides a name for a value or object.  It is also important that this name refer to only a single real world thing or concept just as a variable may only refer to one space in the computer program's memory.  We saw that when variables are created, they are given a scope either globally or inside a loop or function and that the variable can only exist inside its own scope.

Scope in a computer program is like Gareth Evans' social conventions in the real world.  Furthermore, we saw that functions can be passed values through parameters.  This action aligns perfectly with the way in which we use names in the real world.  We sometimes create nicknames for people and pass those nicknames on to other people for their own use in referring to the same person.  We also refuted the argument against Evans' conventionalist theory concerning the use of proper names which only one person uses.  Even though one person may not make up a social group, we can still say that a variable has a very small scope, namely a single person, and can be used by that person to refer to a referent such as a pet.

In conclusion, Gareth Evans' theory, in much the same way as a computer program, explains the way referents get their meanings.  I believe Evans' conventionalist theory of reference holds up against argument because it most closely aligns with our normal intuitions about how we use names to refer to real world objects and concepts.

This is why for good reason it makes sense that computer languages align closely with the tenets of a conventionalist theory, because our computer languages, though vague in terms of a language, still need to convey meaning and references which humans and machines can understand easily.