One pain point in dynamic language implementation is managing
code dynamically. Too often the JVM's class loaders and
naming conventions get in the way.
- load an arbitrary class from bytecodes
- put class in class hierarchy but *not* in any class loader
- piggyback on a "host class" as if it were an inner class
- element of the anonymous constant pool can be patched easily
- string constants can be replaced by arbitrary objects in CP
Why the patching stuff? Mainly, it makes some use cases much easier.
Second, the constant pool needed some internal patching anyway,
to anonymize the loaded class itself. Also, if you are going
to use this seriously, you'll want to build anonymous classes
on top of pre-existing anonymous classes, and that requires patching.
Finally, generated code often needs to get to complex constants
(e.g., lists or tables) and this provides a hook to introduce
them directly via the CP.
We want to cut ClassLoaders and the system dictionary out of the loop.
This means there will be fewer locks and no GC entanglements.
Drop the last object, and the class goes away too, just as it should.