Ok, now we're going to write

the compete for space procedure.

First of all,

we're going to say if there is any ...

we're going to have to ask the turtles

to do this. If there are any other

turtles here die. If you're sitting on

any space with another turtle,

then just die. That's the extreme

form of over-crowding.

Now we need to write a procedure

for a condition, turtles will die,

due to over-crowding.

We need a parameter that we set

that is related to the over-crowding.

Let's call that parameter, space.

I have added a slider here called space.

We know that around every turtle

there is a neighborhood of eight spaces,

North, South, East, West,

Northeast, Northwest, etc.

We made a slider that goes from 1 to 8.

I am going to ask,

We can easily count the turtles and

the neighbors. If the count of turtles on

neighbors is eight minus the count of

turtles. That should gives us number of

empty spaces. If the empty spaces is less

than the amount of spaces, the turtle

needs to live, the turtle needs to die.

We can set the space any number

from 1 to 8 spaces. If the turtle needs

eight spaces to live, it is going to

have to be very thinly populated.

You can think of that as a resource that

constrains the growth of this population.

I am going to make a note here,

Constraint to pop growth.

We should add comments so other people

can understand our code.

If we come back to this later, we can

understand what parts of the code do.

Now, we have to write

our disperse procedure.

That will be our last procedure.

To disperse, just ask the turtles to move

to one of the patches with not any turtles

here. This language is

not at all obvious. It reads pretty well

as English, but it certainly is not easy

to come up with when you are beginning to

program. This is one of the sample code

you can look at to see how to code.

We're talking about patches, a subset of

patches those with this conditional met,

not any turtles here.

If a patch has no turtles on it, we're

going to move to one of those patches.

We have to only do this, a little tricky

thing here. If we were going to ask

turtles to try to do this.

and there weren't any of these patches

available, turtles could continue to

look, and this code would never terminate,

so we need to add conditions, and we

only do this is there are patches.

We only do this if the number of turtles

the screen is less than or equal to

number of patches.

We could have more turtles than patches,

then this would be hopeless. The code

would just keep running. We would not

know what is going on. I speak from

experience there.

I think that should work.

Let's see if this whole thing can run now.

There are still some questions.

We set a large initial population.

We still have these things changing color.

Let's delete what I added to do an

artificial disperse.

It looks like something is happening.

I am not sure what.

Let's get higher density.

When we step, we should have,

if we require them to need a lot of space,

let's see if that results in a thinner

population, indeed it does.

With less space, we get a higher density.

Look here, looks to me, like we have a

model that is roughly working.

Let's see what occurs here,

when we look at the population.

I am going to make a simple plot.

By default, they set a plot that

counts the turtles. In order to get the

plot to actually plot, we have to do

something to the model.

This will happen by default everytime we

have a tick. Every time we step,

we're going to see a tick.

This is going to give us an error the

first time. Let's see what kind of error

it gives us. If we run setup,

and then step.

We have to use this command

reset ticks in the setup.

Reset ticks.

So, setup, ok,

Not sure that was exactly what we wanted.

Let's try starting with a lower population

and having a kind of a generous

Let's see how that works.

Initial population 12.

Am I doing this right?

It looks like our reproduction function

isn't working.

Let's figure out what's going on here.

Inspect this turtle.

320. Generation 13.

Show you how I debug this.

Let's comment this out, turn off death,

and see what happens for a second.

The death isn't happening since we turned

it off, we should have exponential growth.

There is something about my

compete for space. Comment this out.

I am guessing we will still have

the same problem.

Hmmm. I guessed wrong.

Let's go back to look here.

This is the rule causing the problem.

If any other turtles here die.

Ok, oh, I see the problem.

We need to have ... this rule here is

killing off the offspring.

I need to have the offspring disperse.

So, we reproduce and then we disperse.

Then we compete for space.

These programs almost never work right

out of the box. I am guessing this works.

What I have done is say,

after you reproduce, disperse, then

parents from previous generation die,

then there is a compete for space.

Setup, step, now we get exponential growth

and we get a leveling off.

I am not seeing, ..., step, step, step,

Huh, not quite what I expected,

That's more like I was expecting.

It's like a sigmoidal curve.

I am going to compete for a lot of space.

So, slower growth, and more variation.

Ok, I think that the model,

I would say this model is working,

we have exponential growth, and then a

kind of leveling off.

We have a kind of frozen configuration.

These are the kinds of questions

that can come up.

Why that works that way?

With a different disperse procedure

we would probably see something else.

One of the things I would want to change

is disperse, to make it physically more

realistic. Have them migrate from current

location until they find a new location.

It would be a little more code, but ...

Create different colors to see different

families and watch them over time.

A neat project.

Ok, finally, to close the gap here,

We have a step button, that goes through

one full route here.

The Go button can be a Step button with

the forever attribute turned on.

We should call this, this is an

important point to notice,

the display doesn't have to be the same as

the command, but if you don't put the

display name in, the command name is used

as the display name.

We have a nice little model that has

constraints. At certain space settings,

it does an ok job of modeling exponential

growth and kind of a rounding off to a

carrying capacity.