🚀 go-pugleaf

I'm having some trouble fully understanding a design issue.  Perhaps,
some reader can point out a design pattern or offer some insight.
Please bear with me, I think I'm making it a lot harder than it need be.

Suppose, I have a class X that further contains a collection of X.  (Ex.
Person with a collection of Persons -- children).  In a multi-user
environment, I want to have the class X materialized on a server
(perhaps by accessing some legacy data) and available to multiple
clients.  In the simplest case, CORBA/RMI would remotely access
methods/data.  However, this could be a performance bottleneck if one is
,say, accessing methods in a tight loop.  I could serialize the object
over to the client (ignore coherence problems by assuming it is
read-only) and avoid paying for the remote method call repeatedly.
However, this might transfer too much data at once.  The embedded
collection could potentially be quite large and I do not want to
serialize it unless it is absolutely required.

I guess, ideally, I want the "primary" object to live on the server, and
have the ability to migrate a copy/replica to the client.  However, I do
not want to migrate the entire object but only as much as is required
and can be "efficiently" transferred.  I suppose that would at least
suggest not sending embedded collections unless required.  Does this
make any sense and where would I look for further information?  Or am I
totally missing the mark?

TIA,
Vidur