In usual OOP, objects contain references to other objects. 
This creates a problem when cloning a parent object for the purpose of undo/redo due to the complexity
of serializing and deserializing references to child objects which may or may not be referenced by other 
parent objects.

e.g. Assume each nucleotide stores a reference to a style object (which contains information about color/font etc)
Parents A, B, and C each refer to separate style objects, S1, S2, and S3, but D refers to S1, the same one as A. 
When serializing, these relationships must be noted and stored. When deserializing, the same relationships 
must be recreated: i.e.  A' (the clone of A) must point to S1' (the clone of S1) and D' must also point to S1'. 
Importantly, A' and D' must both point to the same clone of S1, because the user will expect that changing the 
style of A' will affect the style of D' (because the user assigned the same style to both A and D in the original model).

This becomes complicated as additional references are added to each object and it does not scale well.

Therefore a "flat" model has been used in which it is assumed that (most) object references are "transient" -- 
i.e. they should not be serialized per se.  Instead objects contain explicit int fields that act as pointers into 
an array that contains objects that are to be referenced.

For example:
	Each nucleotide can be drawn individually