When you have run-time type information (RTTI) in a language it turns out that having names for types is important, for data serialization in particular. But when you also have anonymous types (as Delphi does), you can end up with versioning problems, because you need to generate names for these things - and they usually end up involving numbers of some kind.
So you can see a type that looks like this:
type
R = record
X: record
E: set of (a, b);
end;
end;
But when it comes time to serialize, the effort to map all the properties and relationships into an enumerated form can very quickly invade the codebase and dominate it like a lodestone. Either you "bash down" the most structured elements into more primitive forms so that version compatibility is maintained(leading you to code in a primitive style as well), or you escalate to the prospect of storing code as well as data(the "image" strategy).
For example, "transparent" serialization really isn't because you get run into severe versioning issues. But dropping to primitives doesn't work well either, because then there's impedance to deal with. If you acknowledge there is bound to be impedance, you can encapsulate it in a separate mapping/specification, and deal with it on its own terms.
That lets you do things like evolve your storage format and internal model independently, without the very real drawbacks of an image-style system.