Foundations of Computer Science I: The StuyCS Way

Almost all of our time in Racket was spent writing our own functions. The ability to combine existing procedures into new ones is a common feature of programming languages, and NetLogo is no different, we just need to learn the syntax for that. First, we need to venture off to a new section of the NetLogo IDE, the code tab. This is the area where you will write most of your custom code. Now that we’re in the right place, let’s take a look at the general syntax for NetLogo procedures:

to NAME [p0 p1 p2]
  CODE
end

And here is a specific example:

to setup [n steps]
  clear-all
  create-turtles n
  [
    pen-down
    forward steps
  ]
end

Without () to enclose all function calls, we need some way to show that lines of code belong together in a custom procedure. This is the purpose of to and end. After to we give the name for our procedure. NetLogo has it’s own particular rules about valid identifiers, but as we discussed earlier, if we stick to upper and lower case letters, and numbers (as long as we don’t start with a number), we’ll be fine. We use [] (brackets) after the procedure name to provide any parameters we may need. If we don’t need any parameters, we can have an empty set of brackets, or omit them entirely.

The setup procedure define above resets the NetLogo world, makes a number of turtles provided as a parameter and has those turtles immediately put their pens down and move forward a number of steps also provided as a parameter. In that example you’ll also see another use of the brackets. When we want to define a separate code block that is part of a procedure, we will always use [] to create that code block. In this case, we’re providing a series of commands (technically, this is an argument to the create-turtles procedure) for the newly created turtles to run.

Just like in Racket, we should take care to think about making consistent style choices when writing code. In addition to using meaningful names, newlines and tabs are your friends. NetLogo (the IDE) will help you in this regard, similarly to DrRacket. The first line after a procedure header (to NAME []) will automatically indent. NetLogo will also indent the first line after an open bracket. NetLogo will also continue to use the same indentation level until a closing symbol is used (like ] or end).

With this syntax in hand, we’re ready to start writing our own procedures. There’s just one thing we need to consider, and that is context. All commands have a context, and our custom procedures will be no different. The first context-dependent line of code in a custom procedure determines the context. The first line of the example above is clear-all, which is an observer procedure, which means that our setup is also an observer procedure. Once the context has been set, you can’t have any out-of-context commands in your procedure. If you don’t use any context-specific commands, then your procedure would be applicable in all contexts.

While the command center can be very useful for testing out procedures, NetLogo also gives us the ability to use other kinds of interface elements to control our programs. In many languages, the ability to create things like buttons, sliders, menus, etc. is at best painstakingly annoying. Thankfully, NetLogo makes this stuff fairly straightforward.

To add an interface element you can either right-click anywhere outside the NetLogo world area, or select the element type from a menu above the interface area: After selecting the element you want, the Add button will be highlighted and you can click anywhere in the white space outside the NetLogo world to place the new element. A window will pop up allowing you to configure the new element.