How do we actually build an agent-based model?

Well, there are two basic ways to do that.

One is to build your own model completely from scratch, just like you would any computer program,

but then another way, in a way the one a lot of people increasingly are choosing, is to use a toolkit that is created for agent-based modeling.

And we have already briefly mentioned one of those toolkits, NetLogo, which is the one we will be using throughout this course.

But I just want that you know that there is a suite of other toolkits available out there.

For instance, there is the ancestor of all agent-based modeling toolkits, developed at the Sante Fe Institute in the early 90ies, which is Swarm,

written in a language called objective C. Which actually has gained some popularity again, the language has, due to the fact that it is the basis for a lot Mac OS X Apps, actually.

And Swarm still exists and is still in use, in fact there is still a meeting called SwarmFest that is held every year that you can attend, around the Swarm development and more general about agent-based modeling.

Repast was a toolkit built at the Argonne National Lab in part, among other places, and is written in a number of different languages at this point.

It has been a planned[?] in places others but probably most popularly implemented in Java, and has been around since the early 2000s. And it is pretty popular still to a large extent, still well used.

Then there is Ascape. Ascape was developed in part at the Brookings Institute and was developed primarily to support the development of the Sugarscape models that were used by Joshua M. Epstein and Robert Axtell in their foundational book on agent-based modeling that is about 20 years old now.

And there is Mason which is developed by the George Mason University in part by Sean Luke, and it is a very fast and efficient agent-based algorithm.

Mass is a toolkit that comes out of Hungary, developed by Laszlo Gulyas and some colleagues over there and that stands for the Multi-Agent Simulation Suite.

Breve is an interesting, lightweight, kind of agent-based modeling simulation toolkit that really allows you explore some of the physical aspects of building agent-based models.

And then there is NetLogo which is the one we will be using for this course.

So we will be using NetLogo throughout this course. And the reason why we will be using that NetLogo is because it is premier agent-based modeling language development library.

It was designed by Uri Wilensky at Northwestern University, who is also my co-author on the textbook, that you might want to pick up, that accompanies this course, called An Introduction to Agent-Based Modeling.

And NetLogo [?] and is still the most widely used agent-based modeling environment.

It is also the easiest to learn in many respects. And, in fact, in a hands-on kind of workshop where I am interacting with people, I can get people up and running NetLogo in, say, a 3 hour workshop or something along those lines.

NetLogo has an essential design principle that really facilitates this.

The first of all that it has a very low threshold, novices can build simple models in their first use in easy to understand ways.

It also has a pre-collegeic curriculum that includes complex systems and modeling, so even people to K–12 level, students and learners can, kind of, pick up and start to understand how to use agent-based modeling.

But it is also being used in university courses that include and require agent-based modeling.

News and media have also been brought in to look at the models as evidence for arguments that have been explained.

So it has a very low threshold to understanding and to comprehension of the models or for creation of models, for that matter.

But at the other end, it also has a very high ceiling. The language is expressive enough that enables high-end complex models. Researchers should be able to read and write and publish the models.

The idea is that traditionally in a lot of software modeling environments you have the conceptual modeler on the one hand and you have the actual software engineering implementer on the other hand. And they are two different people.

The idea behind NetLogo modelers is that these two people could be the same person.

This allows you to narrow or even eliminate the gap between the modeler and the programmer.

And it enables very interactive model development and research.

That allows interactive or iterative modeling type environments with the model developer and the model programmer constantly communicating about the model they are creating.

It also provides the ability to share the models easily, since they can be understood and worked with on a very easy to comprehend way.

And because of the fact that this gap has been eliminated between the modeler and the programmer, it makes it easier to verify and challenge models, which we think is important for the scientific progress of modeling.

Now, there is one interesting aspect of NetLogo that I feel like I should take a second to talk about, and it makes a great story anyway.

Which is that Logo was first developed round 1969 by Seymour Papert and colleagues. And Logo is, in fact, the ancestral language behind NetLogo.

So, in Logo, which was not developed as a multi-agent language but really as a single-agent language, you are essentially controlling a small little turtle robot that would go out and take actions in the world.

And Seymour Papert developed this with his colleagues to help try and teach children how to think from a computational perspective.

And when he introduced Logo to the class rooms, a lot of times he would use one of these actual robot type things.

And to get the children to be a little more interactive with the robot, he would call it 'turtle' rather than a robot. Because children would like to play with turtles.

As a result of this, the virtual realization of the agent, of that physical robot agent, was also called a turtle.

And, in fact, to this day, NetLogo, which is a direct descendant of the Logo programming language, also refers to all agents as turtles.

It does not mean that the agents are slow or implies anything about them, it is just what we call the basic class of agents within the NetLogo programming environment.