Q:

The relationship between quotation, reification and reflection

I recently get confused with quotation, reification and reflection.  Someone could offer a good explanation about their relationship and differences (if any)?

A:

Quoting
This is probably the easiest one.  Consider what happens when you type the following into the REPL:
(+ a 1)

REPL stands for Read Eval Print Loop, so first it Reads this in.  This is a list, so after reading we have a list of 3 elements containing: <the symbol "+"> <the symbol "a"> <the number 1>
The next step is evaluation.  Evaluating a list in Common Lisp involves looking up the function (or macro) bound to the first item in the list.  Since + is bound to a function and not a macro, it then evaluates each subsequent element in the list.  Numbers evaluate to themselves, and "a" will evaluate to whatever it is bound to.  Now that the arguments are evaluated, the function "+" is called with the results of the evaluation.
We then Print the result and Loop back to the Read step
So this is great, but what if we want something that, when evaluated, will end up as a list of 3 elements containing <the symbol "+"> <the symbol "a"> <the number 1>?  The solution to this is quoting.  Lisps in general have a special form called "quote" that takes a single argument, and the result is that argument, unevaluated.  So
(quote (+ a 1))

will evaluate to that list.  As some syntactic sugar, ' is treated the same as (quote ), so we can just write '(+ a 1).
Reification
Reification is a generic term that roughly means "Make an abstract concept" concrete.  Specific to programming, when something is reified, it roughly means you can treat it as data (or "First-class object").  An example of this in lisp is functions the lambda expression gives you the ability to create a concrete, first-class object that represents the abstract concept of a function call.  Another example is a CLOS class, which is itself a CLOS object, that represents the abstract concept of a class.
Reflection
To a certain degree, reflection is the opposite of Reification.  Given something concrete, you want some information about it's abstract representation.  Consider a Common Lisp Package object, which is a reification of the concept of a package, which is just a mapping from symbol names to symbols.  You can use do-symbols to iterate over all of the symbols in a package, thus getting that information out at runtime.
Also, remember how I said lambda's were a reification of functions?  Well "function-lambda-expression" is the reflection on functions.
The metaobject protocol (MOP) is a semi-standard way of doing all sorts of things with classes and objects.  Among other things, it allows reflection on classes and objects.

