We want you to be able to:
In 1974, economist Thomas Schelling published what would become a landmark paper called "Dynamic Models of Segregation." In it, Schelling tried to explore how, in a simple toy system, individuals segregate themselves even if they have an expressed preference for having neighbors different from themselves. In other words: Schelling explored how a seemingly sensible individual preference ("I'm OK with up to 50% of the people in my neighborhood being different from me") can lead to larger-scale social segregation, where 'like' people clump together.")
Now, Schelling wrote this paper in 1974, in a different cultural context. You'll find that,
Studying this model and the history involved means also accepting the baggage that surrounds them. These models offer us great insight into social systems, but they also have a history and implications that touch on tense social issues. So, as a class, let's:
His first toy system looked like this: a one-dimensional set of typewriter characters to stand in for individuals who differed on some property ("stars and zeros"):
Schelling describes the figure thusly:
Suppose, now, that everybody wants at least half his neighbors to be like himself, and that everyone defines 'his neighborhood' to include the four nearest neighbors on either side of him. A star wants at least four of his eight nearest neighbors to be stars; a zero wants at least four of his eight nearest neighbors to be zeros. Including himself, this means that he wants a bare majority, five out of the nine. (For those near the end of the line the rule is that, of the four neighbors on the side toward the center plus the one, two or three outboard neighbors, half must be like oneself) I have put a dot over each individual whose neighborhood does not meet his demands.
Let's look at the line again. We'll take two individual characters (two zeroes) as examples. The first zero doesn't want to move, because its neighborhood has a simple majority of zeroes like itself. But what about the zero that lives next door?
// Calculate the number of residents in the second zero's neighborhood to figure out if it wants to move.
The results of this section are experimental. They are crude and abstract but have the advantage that anyone can reproduce them using materials that are readily available.
I assume a population exhaustively divided into two groups; everyone's membership is permanent and recognizable. Everybody is assumed to care about the color of the people he lives among and able to observe the number of blacks and whites that occupy a piece of territory. Everybody has a particular location at any moment; and everybody is capable of moving if [they are] dissatisfied with the color mixture where [they are]. The numbers of blacks and whites, their color preferences, and the sizes of 'neighborhoods' will be manipulated....
There is some fascination in the process as it emerges in the linear model; furthermore, the linear experiment can be replicated by any reader in five minutes; variants can readily be devised, and any reader with a spare half hour can change the hypotheses to suit.
Here's how Schelling sets up the rules for a 1-dimensional simulation:
As Schelling says, "We also need an order of moving.
When Schelling did his original simulations in 1974, he wrote "what is reported here has all been done by hand and eye." If he could do it, so can we.
Grab nickels and pennies and find a partner. We're going to try this in stages.
Now that you're set up, play one round of the game.
// When does/should the round stop? In other words, how would you describe how you know the round is over. Try and be as precise as you can in explaining.
// If you can, take a picture of what your board looks like after one round
This gives you a chance to talk about whether anything problematic or unexpected happened.
Play a second round through. And third, and fourth if you want. Set up a new board and try again, configuring the board how you want.
// If you can, take a picture of what your board starts like, looks like after each round and ends like in each game.
You've played the game. You hopefully have a handle on it. Now, let's try to move closer toward describing the model in a way that a computer---not just you---could potentially play/run the game.
You don't need to make a working Python program. We're going to start much smaller and try to build up.
Whether through words, pictures, flowcharts, or some other medium, start precisely describing the game so a non-human agent could play it.
One strategy you can use is often called top-down design. You start at the highest level of what you're trying to do, then break each big piece down into smaller, more specific pieces. You can also write in a way that looks like code, but doesn't have to be strict python (or any other language). Just something akin to a program sketch: understandable as a well-defined series of steps, even if the punctuation and words might make the Python interpreter throw a tantrum.
Here's an example of top-down design where the objective might be to call my mom.
TO call my mom:
Pick up the phone
Dial Mom's number
Prepare for a giant wave of guilt
That program describes a really loose level of detail of how I call my mom. But what if someone (a 4-year-old who recognizes numbers) didn't know how to pick up the phone, and they wanted more detail?
TO pick up the phone:
Place your hand on the handset
Lift it
Turn it so it faces you
Aaand what if they needed more specifics on how to dial (and how to prepare for guilt)?
TO dial the phone:
Read the first digit of mom's phone number
Hit the corresponding digit on the phone
Move to the next digit of mom's phone number
Keep repeating this until there are no numbers left in mom's phone
When we write pseudo-code like this, we often start at the top, then keep breaking down each line until we feel like we hit bottom: we have taken anything that was still complex (and hid several steps) and gotten the steps down to the base level of whatever our language is.
It takes practice, and you may hit dead-ends. But when you're done, you ought to have a set of instructions that:
In [ ]: