Question: What type of organisms are simple to clone?
About the article "Cloning", section "Cloning unicellular organisms".

Candidate passages:
These companies are famous examples of the Copy to China model.
Many of them have evolved to more than a simple clone. 
Living organisms are complex adaptive systems.
Although complexity is hard to quantify in biology, evolution has produced some remarkably complex organisms.
This observation has led to the common misconception of evolution being progressive and leading towards what are viewed as "higher organisms".
If this were generally true, evolution would possess an active trend towards complexity.
As shown below, in this type of process the value of the most common amount of complexity would increase over time.
Indeed, some artificial life simulations have suggested that the generation of CAS is an inescapable feature of evolution.
However, the idea of a general trend towards complexity in evolution can also be explained through a passive process.
This involves an increase in variance but the most common value, the mode, does not change.
Thus, the maximum level of complexity increases over time, but only as an indirect product of there being more organisms in total.
This type of random process is also called a bounded random walk.
In this hypothesis, the apparent trend towards more complex organisms is an illusion resulting from concentrating on the small number of large, very complex organisms that inhabit the right-hand tail of the complexity distribution and ignoring simpler and much more common organisms.
This passive model emphasizes that the overwhelming majority of species are microscopic prokaryotes, which comprise about half the world's biomass and constitute the vast majority of Earth's biodiversity.
Therefore, simple life remains dominant on Earth, and complex life appears more diverse only because of sampling bias.
This lack of an overall trend towards complexity in biology does not preclude the existence of forces driving systems towards complexity in a subset of cases.
These minor trends are balanced by other evolutionary pressures that drive systems towards less complex states. 
The clarification of the distinction between simple and complex scientific models became in later years a major goal of Rosen's published reports.
Rosen maintained that modeling is at the very essence of science and thought.
His book "Anticipatory Systems" describes, in detail, what he termed the "modeling relation".
He showed the deep differences between a true modeling relation and a simulation, the latter not based on such a modeling relation.
In mathematical biology he is known as the originator of a class of relational models of living organisms, called formula_1-systems that he devised to capture the minimal capabilities that a material system would need in order to be one of the simplest "functional organisms" that are commonly said to be "alive".
In this kind of system, formula_3 stands for the metabolic and formula_4 stands for the 'repair' subsystems of a simple organism, for example active 'repair' RNA molecules.
Thus, his mode for determining or "defining" life in any given system is a functional, not material, mode; although he did consider in his 1970s published reports specific "dynamic realizations" of the simplest formula_1-systems in terms of enzymes (formula_3), RNA (formula_4), and functional, duplicating DNA (his formula_8-mapping).
He went, however, even farther in this direction by claiming that when studying a complex system, one ""can throw away the matter and study the organization order"" to learn those things that are essential to defining in general an entire class of systems.
This has been, however, taken too literally by a few of his former students who have not completely assimilated Robert Rosen's injunction of the need for a theory of "dynamic realizations" of such abstract components in specific molecular form in order to close the modeling loop for the simplest functional organisms (such as, for example, single-cell algae or microorganisms).
He supported this claim (that he actually attributed to Nicolas Rashevsky) based on the fact that living organisms are a class of systems with an extremely wide range of material "ingredients", different structures, different habitats, different modes of living and reproduction, and yet we are somehow able to recognize them all as "living", or functional organisms, without being however "vitalists".
His approach, just like Rashevsky's latest theories of organismic sets, emphasizes biological organization over molecular structure in an attempt to bypass the "structure-functionality relationships" that are important to all experimental biologists, including physiologists.
In contrast, a study of the specific material details of any given organism, or even of a type of organisms, will only tell us about how that type of organism "does it".
Such a study doesn't approach what is common to all functional organisms, i.e.
"life".
Relational approaches to theoretical biology would therefore allow us to study organisms in ways that preserve those essential qualities that we are trying to learn about, and that are common only to "functional" organisms.
Robert Rosen's approach belongs conceptually to what is now known as Functional Biology, as well as Complex Systems Biology, "albeit" in a highly abstract, mathematical form. 
Unlike in C++, objects in Java are always accessed indirectly through references.
Objects are never created implicitly but instead are always passed or assigned by a reference variable.
(Methods in Java are always "pass by value", however, it is the value of the reference variable that is being passed.)
The Java Virtual Machine manages garbage collection so that objects are cleaned up after they are no longer reachable.
There is no automatic way to copy any given object in Java.
Copying is usually performed by a clone() method of a class.
This method usually, in turn, calls the clone() method of its parent class to obtain a copy, and then does any custom copying procedures.
Eventually this gets to the clone() method of codice_1 (the uppermost class), which creates a new instance of the same class as the object and copies all the fields to the new instance (a "shallow copy").
If this method is used, the class must implement the marker interface, or else it will throw a CloneNotSupportedException.
After obtaining a copy from the parent class, a class' own clone() method may then provide custom cloning capability, like deep copying (i.e.
duplicate some of the structures referred to by the object) or giving the new instance a new unique ID.
The return type of clone() is codice_1, but implementers of a clone method could write the type of the object being cloned instead due to Java's support for covariant return types.
One advantage of using clone() is that since it is an overridable method, we can call clone() on any object, and it will use the clone() method of its actual class, without the calling code needing to know what that class is (which would be necessary with a copy constructor).
Another disadvantage is that one often cannot access the clone() method on an abstract type.
Most interfaces and abstract classes in Java do not specify a public clone() method.
As a result, often the only way to use the clone() method is if the actual class of an object is known, which is contrary to the abstraction principle of using the most generic type possible.
For example, if one has a List reference in Java, one cannot invoke clone() on that reference because List specifies no public clone() method.
Actual implementations of List like ArrayList and LinkedList all generally have clone() methods themselves, but it is inconvenient and bad abstraction to carry around the actual class type of an object.
Another way to copy objects in Java is to serialize them through the interface.
This is typically used for persistence and wire protocol purposes, but it does create copies of objects and, unlike clone, a deep copy that gracefully handles cycled graphs of objects is readily available with minimal effort from the programmer.
Both of these methods suffer from a notable problem: the constructor is not used for objects copied with clone or serialization.
This can lead to bugs with improperly initialized data, prevents the use of codice_3 member fields, and makes maintenance challenging.
Some utilities attempt to overcome these issues by using reflection to deep copy objects, such as generic deep copy and the deep-cloning library. 
Cell cloning.
Cloning unicellular organisms.
Cloning a cell means to derive a population of cells from a single cell.
In the case of unicellular organisms such as bacteria and yeast, this process is remarkably simple and essentially only requires the inoculation of the appropriate medium.
However, in the case of cell cultures from multi-cellular organisms, cell cloning is an arduous task as these cells will not readily grow in standard media.
A useful tissue culture technique used to clone distinct lineages of cell lines involves the use of cloning rings (cylinders).
According to this technique, a single-cell suspension of cells that have been exposed to a mutagenic agent or drug used to drive selection is plated at high dilution to create isolated colonies; each arising from a single and potentially clonal distinct cell.
At an early growth stage when colonies consist of only a few of cells, sterile polystyrene rings (cloning rings), which have been dipped in grease are placed over an individual colony and a small amount of trypsin is added.
Cloned cells are collected from inside the ring and transferred to a new vessel for further growth.