The Mirror Breaks

Consider a simple self-modifying function:

    function greet(name):
        return "Hello, " + name
    
    // Reflection modifies it
    replaceFunction(greet, (name) => "Goodbye, " + name)
    
    greet("World")  // Returns "Goodbye, World"
    // But the source code still says "Hello"

The function's behavior has diverged from its source code. What does the program "mean"? The written code, or the running behavior?

Metaprogramming flirts with similar tangles. In Smalltalk, every object is an instance of a class. But classes are objects too. So what is a class an instance of? A metaclass. And what is a metaclass an instance of?

    Object class           // Object's metaclass
    Object class class     // metaclass's metaclass
    // ... turtles all the way down?

This isn't merely academic. Real systems encounter these questions. A debugger that debugs itself. A compiler that compiles itself. An AI that improves its own code.

Can a program analyze another program completely? Alan Turing proved it cannot. The halting problem---determining whether a program will finish or run forever---is undecidable.

    // Can we write this function?
    function willHalt(program, input):
        // Analyze program
        // Return true if it will halt on input
        // Return false if it will run forever
        ???
    
    // If we could, consider:
    function paradox():
        if willHalt(paradox, null):
            while true: pass   // loop forever
        else:
            return             // halt immediately

Reflection cannot give us complete knowledge of a system's behavior. Some properties are inherently unknowable from within the system itself.

When code examines itself, who is examining whom? The inspecting code and the inspected code are both part of the same program. The observer affects the observed simply by existing.

    // This program is different because it examines itself
    function selfAwareSize():
        myCode = getSourceCode(selfAwareSize)
        return length(myCode)
    
    // The function is larger because it contains
    // the code to examine itself

The act of introspection changes what is introspected.

Code that reflects on itself experiences a similar split:

    // The examining code
    function examiner():
        target = getFunction("examiner")
        analyze(target)
    
    // Is 'examiner' the code running, or the code being examined?
    // They have the same source but different roles.

Beyond philosophy, reflection has practical limits:

Performance: Reflective operations are slower than direct operations. Looking up a method by name is slower than calling it directly.

    // Fast: direct call
    knight.move("e4")
    
    // Slower: reflective call
    invoke(knight, "move", ["e4"])

Optimization barriers: Compilers optimize code by analyzing what it does. Reflection makes this analysis impossible---the code might do anything.

Security: If code can examine and modify itself, malicious code can hide, mutate, and evade detection.

Maintainability: Code that modifies itself is hard to debug, test, and understand. The behavior isn't visible in the source.

The craft lies in using reflection judiciously:

Proxies for change tracking and validation---invisible wrappers that add behavior without modifying the wrapped code.

Aspects for cross-cutting concerns like logging---defined once, woven throughout, but the original code stays clean.

Code generation for boilerplate reduction---reflection at build time produces explicit code that runs normally.

Snapshot diffing for state synchronization---comparing data, not examining code.

And yet---strange loops are also the source of emergence. Hofstadter argues that consciousness itself arises from the brain's ability to model itself. Self-reference isn't just dangerous; it's the source of higher-level phenomena.

    // A simple self-improving loop
    function improve(program):
        metrics = evaluate(program)
        variants = generateVariants(program)
        best = selectBest(variants, metrics)
        return best
    
    // Can we apply this to improve itself?
    improvedImprove = improve(improve)

Whether such loops lead to superintelligence or infinite regress remains an open question.

Reflection, used wisely, gives us:

• Abstraction: Code that works on any structure, not just specific types
• Separation: Cross-cutting concerns handled orthogonally
• Synchronization: State tracked and shared across boundaries
• Evolution: Systems that can examine and extend themselves

The mirror of code reflects our programs back to us, revealing structure we couldn't see otherwise. It also reflects the deepest puzzles of self-reference that philosophers and mathematicians have grappled with for centuries.

We've explored the meta-level---code that examines, modifies, and synchronizes itself. These techniques underpin the frameworks, tools, and collaborative systems we use daily.

In the chapters ahead, we'll see how large language models blur the boundary between human intent and machine instruction, opening new questions about what it means for code to "understand" itself---or us.