virtual C

1.11: adda/dstr/safe pointers/virtual C:
. adda's pointers can feature arithmetic exactly like c;
yet it can still remain safe because
the addresses are not absolute;
the pointers are actually actually just offsets .
. also, the heap that it draws from
is coming from main's private space,
not the machine's entire address space .
. each C main program has its own memory;
so, it can build c structures;
but it can't share them directly with other c programs .
. syntactically,
it appears to operate on foreign pointers,
but, what it does under the hood is
send messages to an owner
requesting an access be done for it;
... actually, there are syntactic diff's;
because, addresses from differing owners
are not contiguous:
each pointer is now 2 parts:
owner, index .
. but if you needed linearity
we could compare owners by their id ... .

[1.31: mis: wild imagination:
. C does not need such linearity,
except when the pointers are in the same data structure .
. it needs to do things like
design arrays of records of array,
and yet treat the whole thing like one array .
. c is also known for offering simplicity
while also providing direct access;
however, what was nice about this was speed;
and, the primary feature of adda,
is to let you code the way you think,
but then keep you virtually safe,
at the expense of speed .
. to compensate for this lack of per-thread speed,
adda needs to be like Parasail,
finding ways to increase concurrency automatically .]