may have 0 or more Users
are accessories to Servers
is a special proxy to one target Server
allocates its Users
locates its Server through Handle
is an object that impersonates one other.
and Target are of the same type
differs from Target in allocation.
is accessory to a User
to the same Target may coexist for a User.
allocates proxies to target objects belonging to Server
tracks all its proxies.
to the same Target and belonging to different Users
proxy to another proxy to a Target has the type of the
proxy points to a more direct proxy through Handle.
arborescence of Proxies leads to its root Target.
a proxy, the corresponding target object on the Server
can be located by first dereferencing the User, locating
the user’s target to find the server, finally dereferencing
the server to the proxy’s handle to the target object.
with a Target object, all proxies of the object may
be tracked to any outer rim in the concentric circles
of proxy levels.
is an abstract attribute of each Object
type and meaning of Handle is assigned by the Object’s
Container. (See systems, nested objects, containment)
is a storage expression within a scope of one more persistent
objects lease the more persistent space and use only
cannot directly dereference its Handle and must delegate
the dereference to its Container. Container resolves
the dereference on behalf of its contained object to
a construct of the same volatility as the contained
object that may now be used directly.
delegates Container with a Handle to get back a usable
resolve the dereference, the Container can
recurse the process by delegating
its container, and so forth.
to proxies to Servers
local proxy P is required to an object O contained in
local user U is created to hold P and others like it.
U is contained in S, at he
same volatility level as O, thus setting P to be more
volatile than its target O.
more remote proxy P’ can now be taken to P with the
creation of another user U’ contained in remote server
S’ which is peer with S.
---> P ---> O is the path of locating target O starting
and U’ are considered identical.
handles U and U handles U’ in cross-over.
crossed-over U-U’ pair is called a PORTAL.
characteristics of this construct is that U belongs
to S and U’ belongs to S’ and create a window for exchanging
substance between adjacent system S and S’.
portal is a pair of objects called GATES that live the
same lifespan, each in a different system, each representing
the other in the containing system.
portal constructs necessarily between two existing systems.
portal is a CONNECTOR between the two systems. As such,
it has the same lifespan and volatility as any of the
two endpoint systems.
creation of a GATE may be initiated at one end by system
L determines the creation of the corresponding GATE
at the other end within system R.
creation, the abstract handle of the left Gate initially
holds the ID of system R. The Gate’s handle is abstract
in the scope of its container system L.
Sucha a gate was constructed
in a disconnected state.
gate must move to a connected state before any dereference
is made possible.
connection, a super system E, called the Environment
of L and R resolves the gate’s handle by locating the
corresponding Gate within the system indicated by the
handle. If no such gate yet exists, one would be created
in a connected state.
identity of the connecting gate is convolved into the
handle of its counterpart.
or referencing is the opposite of dereferencing, and
is the act of abstracting the location of a persistent
object down to identifiers used by more volatile objects.
E is a network environment, and L and R are networked
computers, then the abstract handle of a gate is initially
the other machine’s IP address and Port number. Upon
connecting, the handle changes to be the open socket
between the gates. Upon disconnection, the handle changes
from socket back to IP address.
object can be a gate.
are connectors. The scope of the connector binds to
the environment E.
gates can be the femurs of a LINE.
question is now who owns the LINE.
Network is a unique object which is copied and kept
synchronized on all computers participants to
network portal binds into the network scope, and links
one of its endpoints to the connecting system. The other
endpoint is convolved with the reference to the other
Portal LINE is an instance of a relation between the
two types of the connecting systems.
L uses system R by logging into it. As a result, the
entire content of R is made available to L as its own
are instances of the USES relation.
Morphic Core tests the children
of a scope to see if they are femurs of lines.
scope is a femur if it is contained in a LINE
is a multi connector with a maximal number of endpoints,
each testing positive as connector endpoints.
Schematic Editor is the promoter of such traversals.
(Important) More than one unary
relation generator may exist in a running morphic system
at a given time. Let G1 and G2 be two relation generators.
A relation such as A contains B reclaims the generation
of a relation R from A to B. Since two such relation generators
exists in the bodies of G1 and G2, one of them needs to
be identified and invoked to construct R. The selectors
of R would have different layouts into the user data space
depending on whether G1 or G2 generated the relation.
In the figure above we have two instances
of the Morphic System, A and B. The two may exchange substance
through a portal. We follow the evolution of some structures
of A as they port over to B in four stages.
System A at stage 0 under the microscope:
The above is a normal,
frequent case of a type including another.
- T and T' are
types, uncontained, subsystems in the scope A.
- T' contains
T through relation R.
- R is a unary
relation with a unary connector c to T.
- Connector c
belongs to scope A.
- Connector c
is included in relation R (hard couple).
- Relation R
belongs to scope T'.
- Scope A has
a selector $ of relation R in scope T'.
R is built with
two components: a Field and a connector. They form a solid
structure through hard coupling. The relation is indivisible.
Connector c and
selector $ also have intrinsic components, which are their
Points p1 through
to p8 are weak links. For example p8 is a multi-pointer
that establish the parenthood of scope A above T. A and
T are independent systems which may be decoupled without
compromising the integrity of either one of them. The same
applies to p1-p7. A special note as far as p2 is concerned:
$ is an instance of R, and p2 is a multiple pointer that
defines the instantiation relationship. p2 sais that the
type of $ is R. This too is a loose link, because it can
be severed, without compromising the integrity of $'s frontier,
and only loosing its identity.
Porting starts with shifting T through
the portal. The shifting of a structure is done by recursively
porting its included subsystems. If T is indivisible than
it is one of the atomic types of the Morphic System for
which porting channels have been supplied.
The process of porting a structure
from an environment with a certain definition to another
environment with a different definition is generally known
Our method of porting a structure has
the following particularities:
- A structure exists in either one
on the environments, and not in both.
- A solid structure may be partly
ported, so it may exist half in one system, half in
- A solid structure may overlap
more than two environments.
- Weak links are not allowed at
the level of the portal.
- The act of porting of a structure
is an act of re-typing it, or a structural morphism.
The problem of porting:
- We serialized and transferred
T across from A to B. This means that T has ceased to
exist in environment A and has resumed its existence
in environment B. T has had to release the space it
occupied in environment A (that space will be recycled
by the Morphic Memory Manager) and was given new space
to occupy in environment B. This is death followed by
a birth for structure T. Since T seamlessly continues
to exist, this death+birth, just a blink in T's existence,
is called a Port.
- At this stage, the objects such
as R and c of the source environment A, as well as the
ported T itself, have the problem of integrity of their
weak links. The weak links formed around T were p7 and
p8. Of these two, p8 is resolved by the following convention:
a weak link to a Morphic System may be replaced by a
link to any other Morphic System. So p8 will be severed
from A and made to point to B.
- Relation R was pointing to T at
one end through its connector c at p7. The pointer to
T is now invalid since T is in a different environment
with a different addressing scheme, or with a different
- Ex: T has made it out of software
and into hardware.
- Ex: T has broken out of paper
and into software.
- Ex: T has broken out of RAM
and into the File System
- Ex: T has gotten out of machine
A and made it to machine B.
T also had
pointers back to the femur of the connector c, which are
now invalid. Any such pointer needs to be fixed before the
port step is deemed complete. This, however would be the
wrong approach (must explain why???). Solid complex structures
may be partly ported and thus sit on the Portal.
will be deemed complete when no weak links are at the level
of the portal. This implies that the portal will continue
the porting of all weakly linked structures until no such
links are pending at the portal. The whole galaxy of dependents
may have to shift through as one step of the porting process.
The porting relaxes when there are no more dependents, or
when only partly ported structures are pending at
- The port of T will be deemed complete
only when the femur of connector C has also been shifted
through the Portal. Only then the portal between A and
B can relax.
- The connector c of relation R,
as well as the whole of relation R unlike any other
connector of system A, because it is only partially
within A. The femur of connector c must change to hold
information about T's location in its new environment
B. The porting of B may attract vastly different addressing
rules and numeric processing than the source environment
has. The femur of connector c must therefore be amputated
and another type of a femur must be grafted. The new
connector femur must be of a type compatible with environment
B. It follows that connector c must be retyped to another
Type Master. Because c is solidly contained in R, R
also needs to be retyped.
- Environment A must provide conversion
types ConFS and RelFS to retype c and R to the new femur.
We derive the following principle:
- A Morphic System must provide
a Conversion Type Master for each Type Master whose
instances are allowed to cross the boundary to another
Morphic System. Depending on the resolution of these
Conversion Type Masters, we are able to port an XRef
of objects across in smaller pieces and under finer
- The porting step is still not
finished. Under environment B, T must be satisfied with
its dependent connector c, which is part of relation
R. A relation R with a connector c must be constructed
under two Conversion Type Masters RelMS and ConMS of
environment B. Just as with the conversion of R and
of c under environment A, the new R and c of environment
B would hold information about their respective external
A' is a FILE. A
Morphic File is a Portal into another Morphic System.
For system A to
be able to transfer a structure over to B the following
- B must have
a set of type masters compatible with A's to at least
cover the types of the structure being transferred.
- A must have
a mirror of those compatible types of B.
For a system A to
be able to transfer a structure from B the following must
- A must have
a set of type masters compatible with B's to at least
cover the types of the structure being transferred.
- B must have
a mirror of those compatible types of A.
are possible between A and B when:
- A and B have
a set C of equivalent types, and
- The structure's
types lie completely within the type set C.
STREAM is a TYPE
Principles of porting a structure from
L to R
All instances of a type must coexist in the same
environment as the type itself. It follows that:
a type recurses to porting of all its instances.
an instance of a type requires the existence of
a proxy of the instance's type in the target environment,
and the port will retype the instance to the proxy
To allow for distributed solid objects, the portals
must allow partial porting of sub-components.
Stage 0: we prepare
to port T from environment L to environment R. T is a subsystem
of L, and we want it to become a subsystem of B child of
R. B is a file. All objects are typed by the nucleus of
We created StreamB,
an instance of STREAM and a Type Master generating NODEs.
StreamB is a proxy
of MirrorL, which is a collection of conversion Type Masters
for nucleus L. Now we want to port all the children of A
over to R, as children of B.
- L:T is of type
Type of L's nucleus.
- We create an
instance R:T of type "Type" of the Mirror L nucleus.
- StreamB interlocks
L:T with the location of R:T. The interlock will prevent
any other process of L from accessing L:T, which is
about to become invalid with respect to L's rules of
- The exchange
of substance between L:T and R:T is carried-out through
StreamB to MirrorL of R.
- All instances
of L:T must now also be ported.
- L:T can now
be retyped from L:Type to StreamB. Since T may have
been a NODE descendent, and therefore larger than NODE,
the extra space is reclaimed into the MMM. This extra
space is an internal fragment of T. Any XRef to L:T
will remain unharmed.
- File B contains
R:T and all of T's instances ported from L.
- Just as every
operation in environment L ensures the correctness of
its structures, so must the structure correctness be
ensured in environment R. Stage 1 will continue recursively
until correctness of L and R are achieved, and both
L and R are in equilibrium.
The next child of
A that we have to serialize is connector c. Connector c,
however, is an included component of relation R. The connector
c must be ported to environment R while keeping its container
R still in the environment of origin. (Principle 2). The
port of connector c is done in the following steps:
- Construct R:c
of conversion type master MirrorL:Con.
- Interlock L:c
to StreamB with the location of R:c.
- Shift across
all the substance of c.
- Recursing the
portal for all instances of L:c is not applicable for
- Retype L:c
to StreamB, and reclaim the extra space resulting from
the shrink as internal fragment of R.
- Decrement T's
reference count so that it may eventually be deleted.
This is because L:c's femur to T has now been destroyed.
- Relation R
is now quasi functional, in that it can be skipped,
but it cannot be traversed as no other process of L
may interlock with L:c. R now has an internal free fragment
where the connector's femur used to be.
- Under environment
R, the new connector c will be bound to R:T using the
MirrorL:Con conversion type master logic.
- The structure
that evolves under environment B is correct at all times,
so a third party may already use it, but it still has
a different meaning to the structure under L since it
isn't completely received. A third party querying R:T
would observe that it is selected through the unary
connector R:c into B, without having any way of knowing
that R:c is in fact a relation of R:T.
05/27/2009 06:34:03 AM,
05/27/2009 06:34:03 AM