Metaprogramming — Explained with Examples

Metaprogramming is a programming technique where code can manipulate other code — or itself — as data. This includes writing code that generates code (code generation), modifying program behavior at runtime, and treating program structures as first-class objects.

Common metaprogramming tools include macros (Rust, C, Elixir, Lisp), decorators (Python), annotations (Java), templates (C++), eval and dynamic code execution (JavaScript, Python), and reflection (introspection APIs). Metaprogramming can reduce boilerplate, enable DSLs (domain-specific languages), and implement powerful frameworks. However, it can also make code harder to understand and debug if overused.

Real-world analogy. Metaprogramming is like a factory that builds robots that build other robots. The factory doesn’t just assemble cars — it writes the blueprints and programs for new assembly lines. When you need a new type of car, you write a new blueprint (macro/DSL) rather than building a new factory from scratch.

Example (Python — decorator metaprogramming):

def log_calls(func):
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__}")
        return func(*args, **kwargs)
    return wrapper

@log_calls
def add(a, b):
    return a + b

add(1, 2)  # Prints "Calling add"

Example (Rust — declarative macro):

macro_rules! create_fn {
    ($name:ident, $val:expr) => {
        fn $name() { println!("Value: {}", $val); }
    };
}
create_fn!(greet, "Hello, world!");

Related terms: Reflection, AOP, Macros, Generics, Functional Programming

Related tutorial: Metaprogramming Guide