As we noted earlier, an expression is a distinct building block of a lisp program. We can think of ``evaluating an expression'' as the act of executing the expression and obtaining its value. Strictly speaking, when an expression is evaluated, two distinct things happen: firstly the text of the expression is read by what is called the ``Lisp Reader'' which produces an internal representation called the ``Lisp object'', secondly this produced object is evaluated and a vale is returned. The distinction between these two processes is not important most of the time. But knowing about the difference will help understand things better as you become more proficient in Lisp.
What happens when you evaluate a particular expression depends on the type of expression. For a Type (1) expression, the value of the variable is the result. If the expression is of Type (2) then the result is the constant itself. i.e. if 10 is evaluated, the result is 10. If the expression being evaluated is of Type (3), then a function call is made. The value of such an expression is the return value of the function. Function calls are explored in greater detail in the following section. If the expression, on the other hand, is a ``quoted expression'', i.e. of Type (4) or Type (5), then evaluation is inhibited. For e.g. in (set 'foo 10) 'foo is a quoted expression. Here, we want to pass the variable itself to the function, rather than its value. So, we want to inhibit the evaluation of the expression foo before the function set is called. To accomplish this, we put a quote character before foo, thereby telling the lisp interpreter to return the expression itself, rather than the value of the expression. To say it a little differently, the value of a quoted expression is the expression itself (or more correctly, the lisp object corresponding to the expression; more on this later)
A solid understanding of quoted expressions is key if you want to program in Lisp at any level and, as a result, exploit the customisability of Emacs. It is to the Lisp programmer, what understanding pointers is to a C programmer. As such, it is worth spending some more time on the topic.
Consider the English sentence: Madras has six letters. The sentence is ambiguous. Does the statement make a reference to the number of missives present in all post offices of the city called Madras, or does it point out to the reader, the total number of letters of the English alphabet making up the word Madras? Two things contribute to this ambiguity - the multiple meanings of the word letter, and far more relevant to this discussion - the potential for ambiguous parsing of the symbol Madras. When we write Madras, do we refer to a six letter word itself, or do we refer to a city of nearly 7 million inhabitants, the South Indian port city and capital of Dravidian state Tamil Nadu? Generally, the surrounding context is enough to disambiguate. However, the potential to confuse remains, as seen above.
This problem is generally solved by enclosing the problematic term in quotation marks when the reference is to the symbol itself, and use the term plainly when the reference is to the object it nominally denotes. That is, we would say ``Madras'' has six letters if we want to refer to just the word without invoking any related connotations. And Madras has six letters will refer to the City. What we have done is made use of quoting.
In this sense, a quoted expression in Lisp refers to the Lisp object itself that makes up the expression rather than the value of the expression. The Lisp interpreter will not evaluate a quoted expression, just as humans refrain from attributing meaning to a word in an English sentence enclosed in quotes.
Finally, a note for the advanced reader. As noted earlier, Type (4) and Type (5) expressions are largely similar. The only difference between the two, apart from the obvious difference of using different ticks used to quote, is that if a Type (5) expression is a quoted list, then there are ways to selectively allow some of list elements to be evaluated and used in the quoted expression. If that is not enlightening, do not worry. This difference is important only when using an advanced lisp programming feature called Macros. We do not talk about macros in this tutorial, so we do not need to concern ourselves about it here.
If you want to test out some expressions and evaluate them, go to the *scratch* buffer in emacs, type an expression, move cursor to the end of your expression and type C-x C-e. This will evaluate the expression and print the result in the mini-buffer.