Reification
Reification is a form of instantiation. When you reify a concept, you take something abstract and make it concrete, just like the dictionary definition you provided.
You might choose to reify a type as a term inhabiting some abstract syntax tree of possible types.
You might reify a design pattern by coming up with a general purpose implementation of it for some language. For instance, something like
template<typename T> class Singleton {
public:
static T& Instance() {
static T me;
return me;
}
protected:
virtual ~Singleton() {};
Singleton() {};
}
reifies the singleton design pattern as a template in C++.
You can reify Hoare's idea of quicksort into an implementation in the programming language of your choice. In this vein, I spend a lot of time reifying concepts from category theory into Haskell code.
You can reify a language as an interpreter for that language. Larry Wall's idea of Perl the language is reified as the perl interpreter.
The data-reify and vacuum packages reify terms as graphs representing how it is structured in memory with sharing.
Reflection
The flip side of reification is reflection, which takes something concrete, and generates an abstraction, usually by forgetting some details. Perhaps you want to do this because the abstraction is simpler, or somehow captures the essence of what you are talking about.
Type-system reflection in Java, C#, etc. takes a concrete class in a programming language, and provides you with the abstract structure a class, giving you access to the list of what members your classes provide. Here we are taking the concrete notion of a type, and generating an abstract term out of it that describes its structure, while discarding any particular values.
Like how you can reify a programming language into an implementation, you may some times go in the opposite direction. Though this is generally considered a bad idea, you might take an implementation and try to reflect a language specification from the desirable properties of its behavior. TeX was implemented first by Knuth, sans specification. Any specification of TeX has been reflected from Knuth's implementation.
(More formally if you view reflection as a forgetful functor that takes you from a concrete domain to an abstract domain, then reification is, ideally, left adjoint to reflection.)
The reflection package I maintain provides a reify method that takes a term and yields a type that represents it, then a reflect method that lets you generate a new term. Here the 'concrete' domain is the type system, and the abstract domain are terms.
