It's the capability of a program to "reflect" upon itself, I.E. to inspect and understand its own code.

As an example, In C# you can write a class...

 cs

    
public class MyClass
{
    public void MyMethod()
    {
        ...
    }
}

  

...and you can create an instance of it, and use it, like this...

 cs

    
var myClass = new MyClass();
myClass.MyMethod();

  

Simple enough, nothing we haven't all seen before.

But you can do the same thing with reflection, as such...

 cs

    
var type = System.Reflection.Assembly.GetExecutingAssembly()
    .GetType("MyClass");

var constructor = type.GetConstructor(Array.Empty<Type>());

var instance = constructor.Invoke(Array.Empty<Object>());

var method = type.GetMethod("MyMethod");

var delegate = method.CreateDelegate(typeof(Action), instance);

delegate.DynamicInvoke(Array.Empty<object>());

  

Obnoxious and verbose and tossing basically all type safety out the window, but it does enable some pretty crazy interesting things. Like self-discovery and dynamic loading of plugins, or self-configuration of apps. Also often useful when messing with generics. I could dig up some practical use-cases, if you're curious.