reveal.js

# 12 NetLogo language basics

---
						## 12.1 Console interaction

**'Command Center'**
						```NetLogo
						You can do it!
						```

---
						## 12.1 Console interaction

<img width="400" alt="Batman Slaps Robin" src="https://static0.cbrimages.com/wordpress/wp-content/uploads/2016/09/Batman-Slaps-Robin-Meme.jpg?q=50&fit=crop&w=1232&h=693&dpr=1.5">
						
						
						```
						ERROR: Nothing named YOU has been defined. 
						```

---
						## 12.1 Console interaction
						
						* **Primitives**: basic building blocks
						* **Reporters**: return a value
						* **Commands**: do something
						
						---
						## 12.2 Entities

<a title="NetLogo world and entities (Figure 2 in Izquierdo et al. 2019)" href="https://wisc.pb.unizin.org/agent-based-evolutionary-game-dynamics/"><img width="400" style="background-color: white" alt="NetLogo entities" src="https://wisc.pb.unizin.org/app/uploads/sites/28/2018/09/the-netlogo-world.png"></a>
						 
						NetLogo world and entities (Figure 2 in Izquierdo et al. 2019)

---
						## 12.2 Entities

<a title="NightElfik, CC0, via Wikimedia Commons" href="https://commons.wikimedia.org/wiki/File:KochTurtleAnim.gif"><img width="256" alt="KochTurtleAnim" src="https://upload.wikimedia.org/wikipedia/commons/0/09/KochTurtleAnim.gif?20110330124613"></a>
						 
						KochTurtleAnim by NightElfik, CC0, via Wikimedia Commons

**Note**: "turtles" comes originally from the Logo programming language, which was designed for educational purposes in the 1960s and 1970s.

---
						## 12.2 Entities

* **Turtles**: unique `who` numbers
						* **Patches**: unique `pxcor` and `pycor` coordinates
						* **Links**: between two `turtles`

**Note**: turtles and links can be created and destroyed, patches are always there.

---
						## 12.2 Entities

```NetLogo
						turtle <WHO_NUMBER>
						patch <PXCOR> <PYCOR>
						link <WHO_NUMBER> <WHO_NUMBER>
						```

---
						## 12.2 Entities

```NetLogo
						breed [<BREED_1_NAME_PLURAL> <BREED_1_NAME_SINGULAR>]

breed [<BREED_2_NAME_PLURAL> <BREED_2_NAME_SINGULAR>]
						```

For example:

```NetLogo
						breed [apples apple]

breed [pears pear]
						```

---
						## 12.2 Entities

Then, we can refer to them individually as:
						```NetLogo
						<BREED_1_NAME_SINGULAR> <WHO_NUMBER>
						```
						```NetLogo
						pear 2
						```

**Note**: `who` numbers are unique across all turtles, including those of different breeds.
						---
						## 12.2 Entities
						We can also refer to them collectively as:
						```NetLogo
						<BREED_1_NAME_PLURAL>
						```
						```NetLogo
						pears
						```
						or randomly as:
						```NetLogo
						one-of apples
						one-of patches
						```
						Note: `one-of` will return a random entity from the specified breed.

---
						## 12.3 Variables

```NetLogo
						set <VARIABLE_NAME> <VALUE>
						```
						For example:
						```NetLogo
						set x 10
						set y 20
						```

---
						## 12.3 Variables

- **Number** (*e.g.*, `1`, `4.5`, `1E-6`)
						- **Boolean** (*i.e.*, `true`, `false`)
						- **String** (effectively text, but enclosed by quote marks: *e.g.*, `"1"`, `"my value"`)
						- `turtles`, `patches` (*i.e.*, NetLogo's computation entities)
						- **AgentSet** (a set of either `turtles` or `patches`)
						- **List** (a list enclosed in squared brakets with values of any kind separated by spaces: *e.g.*, `[ "1" 1 false my-agents-bunch ["my value" true 4.5] ]`)

---
						## 12.3 Variables
						### Variable declaration

```NetLogo
						globals [ <GLOBAL_VARIABLE_NAME> ]
						
						turtles-own [ <TURTLE_VARIABLE_NAME> ]
						
						<BREED_1_NAME_PLURAL>-own
						[ 
						 <BREED_1_VARIABLE_1_NAME>
						 <BREED_1_VARIABLE_2_NAME>
						]
						
						patches-own [ <PATCHES_VARIABLE_NAME> ]
						```

---
						## 12.3 Variables
						### Variable declaration
						```NetLogo
						globals [ x y ]
						
						turtles-own [ weight ]
						
						apples-own [ redness ]
						```

---
						## 12.3 Variables
						### Variable declaration (local)

```NetLogo
						let <VARIABLE_NAME> <VALUE>
						```
						For example:
						```NetLogo
						let freshness 100
						```

---
						## 12.3 Variables
						### Variable declaration (local)

<img title="Diagram about local variables" src="https://www.researchgate.net/profile/Rama-M-A/publication/283347855/figure/fig1/AS:391464140984327@1470343732789/Global-and-local-variables-in-procedural-programming.png" width="450"><img title="Meme about local variables" src="https://i.redd.it/hqokqm85vxz81.jpg" width="300">
						
						Source: [ResearchGate](https://www.researchgate.net/figure/Global-and-local-variables-in-procedural-programming_fig1_283347855), [Reddit](https://www.reddit.com/r/ProgrammerHumor/comments/1063697/when_you_try_to_use_a_local_variable/)
						---
						## 12.4 Expressing equations
						
						* Use of common operators
						* Parentheses for grouping
						* Order of operations
						
						```NetLogo
						set myVariable (2 + 2) * 10 / ((2 + 2) * 10)
						```
						---
						## 12.4 Expressing equations
						
						NetLogo is very permissive with line breaks and whitespaces, and parentheses are not always strictly necessary.

```NetLogo
						set myVariable (
						  (
						    (2 + 2) * 
						    10
						  ) / (
						    (2 + 2) * 
						    10
						  )
						)
						```

However, it is good practice to keep different operations on different lines and use parentheses to avoid confusion.

---
						## 12.4 Expressing equations
						### Using variables in equations

Variables can be used in equations, as placeholders for values.
						
						```NetLogo
						set myVariable 2
						set myOtherVariable 10

...

let myTemporaryVariable 2 * myVariable * myOtherVariable

set myVariable myTemporaryVariable / myTemporaryVariable
						```

---
						## 12.5 Logical operators
						
						Equalities and inequalities, returning a **Boolean** value (`true` or `false`). 
						
						Operators:

- `=`: "equals". 
						- `!=`: "not equal to". 
						- `>`: "greater than". 
						- `>=`: "greater than or equal to". 
						- `<`: "less than". 
						- `<=`: "less than or equal to".

try:

```NetLogo
						1 >= 0
						```

or
					    
						```NetLogo
						100 >= 100 + 1
						```

---
						## 12.5 Logical operators
						
						Cases when comparing non-numeric values:
						Booleans:
						```NetLogo
						true = false ; valid
						true >= false ; invalid
 			```
						Lists:
 						```NetLogo
						[1 2 3] = [ 1 ] ; valid
						[1 2 3] > [ 1 ] ; invalid
						```
						Strings:
						```NetLogo
						"apple" = "banana" ; valid
						"apple" >= "banana" ; valid
						```
						Entities:
						```NetLogo
						patch 0 0 != patch 1 1 ; valid
						turtle 0 < turtle 1 ; valid, but not recommended
						patch 0 0 > patch 1 1 ; valid, but not recommended
						```
						---
						## 12.6 Procedures

An action that can be performed by a turtle, patch, or observer, declared with the keyword `to` and ended with the keyword `end`.

```NetLogo
						to <PROCEDURE_NAME>
							<PROCEDURE_CODE>
						end
						```

---
						## 12.6 Procedures

```NetLogo
						to hello-world
							print "Hello World!"
						end
						```

```
						observer> hello-world
						Hello World!
						```

---
						## 12.6 Procedures

Serve to group and enclose a sequence of commands that are semantically connected

```NetLogo
						to set-it-and-show-me
							let thisVariableOfMine 42
							print thisVariableOfMine
						end
						```

---
						## 12.6 Procedures

Procedures can be called from within other procedures
						```NetLogo
						to <PROCEDURE NAME>
 							<PROCEDURE_1>
 							<PROCEDURE_2>
 							<PROCEDURE_3>
 							...
						end
						```
					
						---
						## 12.7 Logic bifurcations: `if` and `ifelse`

```NetLogo
						if (<CONDITION_1_IS_TRUE>)
						[
							<DO_ACTION_A>
						]

ifelse (<CONDITION_2_IS_TRUE>)
						[
							<DO_ACTION_B>
						]
						[
							<DO_ACTION_C>
						]
						```

---
						## 12.8 Iterators (*loops*)

```NetLogo
						while [<CONDITION_1_IS_TRUE>]
						[
							<DO_ACTION>
						]

repeat <NUMBER_OF_TIMES>
						[
							<DO_ACTION>
						]
						```
						Try this out in the command center:
						```NetLogo
						let counter 0 repeat 10 [ set counter counter + 1 ] print counter
						```
						
						---
						## 12.8 Iterators (*loops*)

A especial type of iterator abundantly used in NetLogo is `ask`. You can `ask` all or any subset of entities to perform specific commands by following the structure:

```NetLogo
						ask <ENTITIES>
						[
							<DO_SOMETHING>
						]
						```
						Try this out in the command center:
						```NetLogo
						ask patches [ set pcolor blue ]
						```

---
						## 12.9 Entities with variables, logic operations, and procedures

```NetLogo
						ask <BREED_1_NAME_PLURAL>
						[
							set <BREED_1_VARIABLE_2> <VALUE>
 							<PROCEDURE_1>
 							<PROCEDURE_2>
 							<PROCEDURE_3>
						]
						```

---
						## 12.9 Entities with variables, logic operations, and procedures

Scope is important!
						```NetLogo
						ask <BREED_1_NAME_PLURAL>
						[
							print [<BREED_1_VARIABLE_2>] of <BREED_2_NAME_SINGULAR> <WHO_NUMBER>
						]
						```
						Filtering using logical operations:
						```NetLogo
						<TYPE_NAME_PLURAL> with [ <VARIABLE_NAME_1> > <THRESHOLD> ]
						```
						---
						## 12.9 Entities with variables, logic operations, and procedures

Embedding `ask` within `ask`, and filtering oneself out using `other`:
						```NetLogo
						ask <BREED_1_NAME_PLURAL>
						[
							ask other <BREED_1_NAME_PLURAL>
							[
								<PROCEDURE_1>
							]
						]
						```

---
						## 12.9 Entities with variables, logic operations, and procedures

All this can be combined to form quite complex rules of behaviour, yet keeping itself generally readable:

```NetLogo
						to celebrate-birthday
							ask people
							[
								if (today = my-birthday)
								[
									ask other people with [presents > 0]
									[
										give-present
									]
								]
							]
						end
						```

---
						## 12.10 Grid (world)

Interface > Settings > Grid

<img src="https://ccl.northwestern.edu/netlogo/5.3.1/docs/images/interface/settings.png" width="200">
						
						Default: 33x33 grid with the position (0,0) at the centre.
						
						Warning: often you will want to uncheck the 'wrap' options. To see the effect of this, try:
						```NetLogo
						ask patch -16 0 [ print distance patch 16 0 ]
						```

---
						## 12.11 Commenting code

```NetLogo
						<CODE>
						; <FREE_TEXT>
						<CODE>
						; or
						<CODE> ; <FREE_TEXT>
						```

---
						## 12.12 Dictionary

Help > Dictionary

Any word highlighted in blue or violet in the code editor can be looked up in the dictionary.

---
						# 13 Sneak-peak at other languages

---
						## 13.1 ABM beyond NetLogo

**ABM is not equivalent to NetLogo** or any other software, it is a way of thinking about processes and systems.

Tecnically, ABM can be implemented in any programming language, however it is often easier to use a dedicated software (with a graphical interface, a built-in language, etc.).

---
						## 13.2 Major ABM platforms and libraries
						### **RePast** (Recursive Porous Agent Simulation Toolkit)

* **Languages:** Java (RePast J), Python (RePast Py), and RePast Simphony (with GUI).
						* **Highlights:** A long-established, research-oriented platform; used in social science, ecology, and urban modelling.
						* **Why it matters:** Provides strong support for building complex, data-driven models; integrates with GIS and statistical analysis.
						* **Learn more:** [https://repast.github.io](https://repast.github.io)

---
						## 13.2 Major ABM platforms and libraries
						### **AnyLogic**

* **Language:** Java-based, with a graphical modelling interface.
						* **Highlights:** Commercial and widely used in industry (logistics, epidemiology, economics). Combines ABM, system dynamics, and discrete-event simulation.
						* **Why it matters:** Demonstrates how ABM concepts are applied in professional and business contexts, often for decision-support.
						* **Learn more:** [https://www.anylogic.com](https://www.anylogic.com)

---
						## 13.2 Major ABM platforms and libraries
						### **GAMA**

* **Language:** GAML (GAMA Modelling Language), based on Java.
						* **Highlights:** Open-source, designed for spatial and multi-agent simulations. Used in ecology, geography, and urban planning.
						* **Why it matters:** Provides a strong focus on spatial modelling and GIS integration, making it ideal for environmental and geographic applications.
						* **Learn more:** [https://gama-platform.github.io](https://gama-platform.github.io)

---
						## 13.2 Major ABM platforms and libraries
						### **MASON**

* **Language:** Java
						* **Highlights:** Open-source, designed for large-scale, high-performance simulations. Used in ecology, social science, and engineering.
						* **Why it matters:** Provides a strong focus on performance and scalability, making it suitable for large-scale simulations.
						* **Learn more:** [https://cs.gmu.edu/~eclab/projects/mason](https://cs.gmu.edu/~eclab/projects/mason)

---
						## 13.2 Major ABM platforms and libraries
						### **Mesa**

* **Language:** Python
						* **Highlights:** Open-source ABM framework with web-based visualisation; well integrated with data science libraries like NumPy and pandas.
						* **Why it matters:** Ideal for researchers who already use Python for data analysis. Encourages modular and reproducible modelling workflows.
						* **Learn more:** [https://mesa.readthedocs.io/latest/](https://mesa.readthedocs.io/latest/)

---
						## 13.2 Major ABM platforms and libraries
						### **Agents.jl**

* **Language:** Julia
						* **Highlights:** Modern, high-performance ABM library that is easy to integrate with numerical computing and visualisation tools in Julia.
						* **Why it matters:** Demonstrates how ABM can benefit from efficient computation and real-time data analysis in a single language. Provides a strong focus on performance and scalability, making it suitable for large-scale simulations.
						* **Learn more:** [https://juliadynamics.github.io/Agents.jl](https://juliadynamics.github.io/Agents.jl)

---
						## 13.3 Quick comparison of ABM frameworks

| Platform / Library             | Language                      | Visual interface                                  | Typical use cases                                                    | License / Access                            | Learning curve                             |
| ------------------------------ | ----------------------------- | ------------------------------------------------- | -------------------------------------------------------------------- | ------------------------------------------- | ------------------------------------------ |
| **NetLogo**                    | NetLogo (Logo-like)           | ✅ Built-in GUI, easy model prototyping            | Education, conceptual models, rapid exploration                      | Free & open-source                          | ⭐ Beginner-friendly                        |
| **RePast** (Simphony / J / Py) | Java / Python                 | ✅ (Simphony) or code-only                         | Complex scientific ABM, GIS models, large-scale simulations          | Free & open-source                          | ⭐⭐⭐ Advanced                               |
| **AnyLogic**                   | Java-based                    | ✅ Professional GUI, multi-method                  | Industry simulation (health, transport, logistics), decision-support | Commercial (educational licenses available) | ⭐⭐⭐⭐ High but powerful                     |

---
						## 13.3 Quick comparison of ABM frameworks (cont'd)

| Platform / Library             | Language                      | Visual interface                                  | Typical use cases                                                    | License / Access                            | Learning curve                             |
| ------------------------------ | ----------------------------- | ------------------------------------------------- | -------------------------------------------------------------------- | ------------------------------------------- | ------------------------------------------ |
| **GAMA**                       | GAML (Java-based)             | ✅ Built-in GUI, GIS integration                   | Ecology, geography, urban planning                                   | Free & open-source                          | ⭐⭐ Intermediate (Java skills needed)      |
| **MASON**                      | Java                          | ✅ Code-only, some built-in visualisation tools    | Ecology, social science, engineering, large-scale simulations        | Free & open-source                          | ⭐⭐⭐ Advanced                               |
| **Mesa**                       | Python                        | ✅ Web-based UI templates                          | Research ABM + Python data analysis pipelines                        | Free & open-source                          | ⭐⭐ Intermediate (Python skills needed)     |
| **Agents.jl**                  | Julia                         | ✅ Visualisation in Julia ecosystem                | High-performance scientific computing, real-time analysis            | Free & open-source                          | ⭐⭐⭐ Intermediate–Advanced                  |

---
						## 13.4 Other frameworks and resources
						
						➡️ Explore: [https://www.swarm.org/wiki/ABM_Resources](https://www.swarm.org/wiki/ABM_Resources)

---
						## 13.5 What to take away

* **NetLogo**: ideal for learning ABM concepts quickly, focusing on model logic rather than low-level programming.
						* **Other frameworks** offer greater flexibility, scalability, and integration with scientific workflows — but they require more programming experience and practice with the platform.

learning about them is always a good idea!
						---
						## 14 NetLogo tutorials

Let us get another round of hands-on experience with the NetLogo language.

Complete the four official tutorials provided by the NetLogo developers:
						* **#0 – Sample Model**: [https://docs.netlogo.org/sample.html](https://docs.netlogo.org/sample.html) 
						* **#1 – Models**: [https://docs.netlogo.org/tutorial1.html](https://docs.netlogo.org/tutorial1.html)
						* **#2 – Commands**: [https://docs.netlogo.org/tutorial2.html](https://docs.netlogo.org/tutorial2.html)
						* **#3 – Procedures**: [https://docs.netlogo.org/tutorial3.html](https://docs.netlogo.org/tutorial3.html)