Your tone sucks but your question is valid, and I&#x27;m personally interested in the history of capitalising variables, so I&#x27;ll answer your question.<p>In short, it all goes back to Prolog, the language used to write the (first versions of) Erlang&#x27;s first compiler. Prolog has bequeathed quite a bit of its syntax to Erlang and also chunks of its semantics, for instance the pattern matching (although arguably that may be a trait inherited from its functional lineage instead, or maybe Prolog borrowed it from LISP, or possibly it was just convergent evolution).<p>In any case, in Prolog any term that begins with a capital letter or the underscore, &#x27;_&#x27;, is a variable. A single underscore is a &quot;don&#x27;t-care&quot; variable. There is a very good reason to syntactically distinguish variables from non-variables like this. Note that I said &quot;any term&quot; earlier, rather than &quot;any identifier&quot;. In Prolog, variables are never stand-alone identifiers[1], instead they are arguments of predicates. That&#x27;s because Prolog variables represent logic variables, rather than computer science variables. By &quot;logic&quot; here I mean mathematical logic, as one may find in textbooks. In this sense, logic variables are not meant as references to memory locations (though in Prolog it&#x27;s very convenient to see them as such, at times). Instead, they represent unbound terms, terms whose value we do not know until a certain point in our calculation, or indeed computation. Once the value of a variable is known, it stays the same until the end of computation (it&#x27;s immutable) and we speak of the variable as being &quot;ground&quot; or &quot;bound to the value&quot;.<p>Now, first-order logic predicates, and therefore Prolog predicates, are written in clausal form as:<p>F(t1, t2, ... tn)<p>Where &quot;F&quot; is a ground term and t1,...,tn any number of terms, each of which is either a ground term or a variable (ie, unbound). So we need a way to tell ground terms from variables. In textbooks, the convention is to denote variables with lowercase letters and ground terms in uppercase. In Prolog it&#x27;s the other way around, probably because of some concern over overuse of the Shift key in old-style keyboards.<p>The alternative of course would be some kind of annotation of the varible, with an additional term. For example, we could use the functors &quot;ground&quot; and &quot;variable&quot;. This would make for hairy syntax though; look at our example predicate from above:<p>ground f(variable t1, variable t2, ground t3)<p>That syntax would just make it harder to see what&#x27;s going on. Instead:<p>f(T1, T2, t3)<p>- makes it perfectly clear that T1, T2 are variables and t3 is a ground term. [Edit: where &quot;predicates&quot;, in Prolog, read &quot;functions&quot; for Erlang. In Erlang also there are no stand-along variables declared, or referenced, outside of functions so the same hairy syntax would have to be adopted to distinguish them].<p>... And that is how Erlang got its uppercased variables.<p>________________________<p><i>[1] So in Prolog, as in first-order logic, one cannot declare variables separate from predicates. You don&#x27;t start a program by laying out a bunch of variables and their types etc. Variables live between parentheses, as parts of terms, never anywhere else.<p>Well OK, you can also do this:<p><pre><code>  f(T1, T2, t3):-
    t3(T1)
    ,T2
    ... 
</code></pre>
But that&#x27;s a story for another time :P</i>