A turtle is a computer program that draws an image. For the most part, turtles do not exist on their own, they always exist within a population. Each turtle is unique and as such it is assigned a Unique Identifier, which is described in more detail below. Every turtle also keeps track of its Author. For the most part you turtles they will be presented as their drawing, but you can also access their program and other information when needed.
A population is a collection of turtles. In Evolved Art there are two types of populations - evolving populations and gene pool populations. The primary difference is implied by the name. Evolving populations evolve their turtles from one generation to the next, while gene pool populations do not. You can think of evolving populations as being active and gene pool populations as being static. Evolving populations are placed in a section of your population library titled User Populations. For this reason, they are sometimes referred to as user populations in the documentation. Like turtles, every population has a Unique Identifier and an Author. Because active populations are used to evolved turtles, they have properties that gene pool populations do not. There properties control the fitness function that is used when selecting turtles for reproduction. Also, active populations have a fixed size that cannot be changed, whereas gene pool populations increase in size as turtles are added to them (up to a limit).
When you configure Evolve Art, you identify yourself as an Author by providing a name and email address. You can leave either of these fields empty or even provide a pseudonym for your name. Like turtles and populations, every author is given a Unique Identifier. Every turtle and every population in Evolved Art records the Unique Identifier of its author. The purpose for this identification is to help acknowledge the person who originally evolved a given turtle or population. When you email a turtle or population to another user, or import from another user, Evolved Art keeps track of the author to ensure proper credit.
As mentioned above, every author, turtle, and population in Evolved Art
is assigned a Unique Identifier. This identifier is a long string that
looks something like this: 2DD9EC44-97C1-493E-A0D8-2C6EE479528A.
The identifier is generated in a fashion that attempts to guarantee
its uniqueness across all iPads and all time. Therefore, unique identifiers
should never be the same regardless of when they are generated or on
which iPad they are generated. In general, you never have to be concerned
with unique identifiers, but you will see them used occasionally. For example,
with a turtle is emailed to someone and the turtle does not have a name, the
subject of the email will use the unique identifier.
Note that Unique Identifiers are retained during evolution. When two turtles are selected for reproduction, the will create two new turtles as their offspring. These two new turtles will then replace the programs of their parents. The children will otherwise retain everything else about their parents, including their Unique Identifier, name, and comment. This can be a little bit confusing at times. For example, when you wish to checkpoint a turtle, you will be shown a popup that shows the turtle that will be overwritten. This is the turtle's code at some point in it's ancestry when you last performed a checkpoint. Sometimes you will not wish to overwrite the ancestor. This is why gene pools exist - to give you a place to archive turtles outside the evolutionary process.
If you are a gamer, you are familiar with the concept of checkpoints. Evolved Art provides checkpoints for both populations and individual turtles. It is important to understand how checkpoints work, because they not only assist you will your evolution, but they are also the only means of saving in Evolved Art. Evolved Art does not provide the typical Save command that many apps provide. It is up to you to decide when you wish to checkpoint a population or a specific turtle. Checkpoint is simply the term used to describe saving a population or a turtle to the app's database. All of your work evolving turtles is performed in memory. In order to save a population or a turtle, it must be saved into the app's database. Checkpointing a population or a turtle performs the step of saving to the database. When you close the Population view, the current generation exists only in memory, and those turtles will be lost if you do not Checkpoint. Evolved Art will notice if you have modified any of the turtles or if you have evolved the population, and will ask you if you wish to Checkpoint before closing the Population view.
Each time that you evolve a population of turtles, you are creating a new generation. The turtles in the current population become the parents of the turtles in the population that you evolve. These are generations, just like in your family. Each turtle keeps a count of its generation so that you can know which generation it belongs to. You can see the generation of a turtle in the Turtle Details view. You rarely care about the generation of a turtle, but there are some instances where it has significance. For example, when you email a turtle to another user, or export the turtle to iTunes, the turtle's unique identifier is included with the turtle. It may be confusing to see two turtles with the exact same unique identifier, but with different drawings. However, this can happen when the turtle has evolved. For this reason, the generation count of the turtle is included in file names and definition files so you can see that two turtles with the same unique identifier but different drawings are actually from different generations.
Populations contain turtles and turtles have programs.
There are certain operations within Evolved Art that operate on a turtle's program. For example, when you replace a turtle that is being displayed in the Turtle View. When performing this operation, you will select a turtle from a population to replace the turtle being displayed. This replace operation replaces only the turtle's program with the program from the turtle that is selected from the other population. The operation does not replace the actual turtle. This means that the original turtle's Unique Identifier, name, comment, and other properties remain unchanged. This can be a little confusing at times because turtles have Unique Identifiers and Authors. You may expect that when you replace a turtle in a population that the turtle will acquire the author from the turtle selected to replace it. However, this is not the case. The replace only copies the program from the selected turtle to the turtle being replaced, and the turtle being replaced retains it's author, as well as it's name and comment. When you copy a turtle into a gene pool, however, the turtle itself is copied, so it's author, name and comment come along with it.
Evolution operates on programs. When a population is evolved, turtles are selected to reproduce. The selected mates reproduce to create two new programs and these programs replace the programs of the mates selected to reproduce. So, the children that are evolved actually retain the original Unique Identifiers, names and comments of their parents. This is a little counter-intuitive to traditional evolution, where parents die off and children live on. However, the complexities required to simulate true evolution in this sense are beyond the scope of Evolved Art. For this reason, it is best to think of populations as working populations, and to think of gene pools as static populations. In other words, investing time to name and add comments to turtles is best done with turtles in gene pools, as opposed to turtles in populations.