{% extends "base.html" %}

{% block content %}
  <div class="instructions">
    <h1>TCP/IP Simulation</h1>
    <p>
      TCP/IP is the protocol responsible for routing messages around the Internet. 
      These materials contain everything you need to run a fun and informative simulation
      of TCP/IP in your classroom, for any number of students. We once ran this simulation 
      with 200 students in a gymnasium!
    </p>
    <h2>Objectives</h2>
    <p>
      This simulation is designed to allow students to experience and participate in the TCP/IP 
      protocol, a core component of networking. This experience will make future learning experiences
      more impactful, by providing a context for asking and reasoning about questions such as:
    </p>
    <ul>
      <li>How do messages get transferred between the billions of computers on the Internet?</li>
      <li>When a new computer joins the Internet, how do all the other computers find out how to send it messages?</li>
      <li>Can other people see the messages I send over the Internet?</li>
      <li>What happens when a message from one computer to another can't be delivered?</li>
    </ul>

    <h2>Background</h2>
    <p>
      The Internet is organized into networks. There is one top-level network (the "backbone" 
      of the Internet, powered by huge data centers and connected by undersea cables), with
      smaller subnetworks attached. Smaller subnetworks are attached to those, on and on. 
    </p><p>
      TCP/IP is a distributed protocol: there is no overall map of the network and nobody is 
      in charge. Instead, each computer plays its part and the whole system works. Several roles 
      are included in this simulation:
    </p>
    <ul>
        <li>
            <strong>Regular nodes</strong> are normal computers on a network. Their job is
            to receive messages passed to them, and to pass along any messages which are not
            addressed to them. Regular nodes can also send messages.
        </li><li>
            <strong>Gateway nodes</strong> are part of two networks: their main network, and 
            a subnetwork. Like regular nodes, gateway nodes can send and receive messages. 
            But when they receive a message not addressed to them, gateway nodes need to determine
            whether the message should be routed to their subnetwork or to their main network. 
        </li><li>
            <strong>Nameservers</strong> maintain an "address book" of each person's IP address. 
            Whenever anyone wants to send a message, they must address it to an IP address. 
            So they must first send a message to their nameserver asking for the person's IP address.
        </li>
    </ul>
    <h2>Setup</h2>
    <p>
      First, use the <code>tcp_ip_simulation</code> software package to generate  materials for
      your specific group of participants. If you are reading this, you have probably 
      already generated your materials. Otherwise, please refer to the software documentation
      at <a href="https://github.com/cproctor/tcp-ip-simulation">https://github.com/cproctor/tcp-ip-simulation</a>.
    </p>
    <h3>Room setup</h3>
    <p>
      You will need to arrange your classroom for this activity.
      Each network needs to be roughly a circle, with enough space for all the members of 
      that network, each person witin arm's reach of their neighbors. A network could be a circle
      of chairs or desks, a table, or a loop of string or tape on the floor, if your floors are 
      clean enough to sit on! Label Network 0 in some way--each participant will use this label
      to figure out where to sit.
    </p><p>
      Start by creating Network 0 in the middle of the room, with enough room for the following 
      people: {{network_0}}. 
      Then create your additional networks, {{network_list}}. Each of these networks needs
      its own loop (again, a circle of chairs, a table, or a loop on the floor), and should
      touch its parent network. Label each network (e.g. with a sheet of paper in the center). 
      Here's a map of all the networks and their members:
    </p>
    <img src="sim_graph.png">
    <pre>{{tree}}</pre>
    <p>In case you need it, here's a directory of every participant's IP address:</p>
    <ul>
    {% for name, address in directory %}
      {% if name != "ROOT" %}
        <li>{{name}}: {{address}}</li>
      {% endif %}
    {% endfor %}
    </ul>
    
    <h3>Materials</h3>
    <p>
      In addition to these instructions, you will need a lot of small sheets of paper--about
      ten per person ({{n * 10}} sheets total) is about right. Scrap paper from the copyroom 
      cut into quarters works perfectly. 
    </p>
    <h2>Lesson plan</h2>
    <p>
      This lesson is designed for a 50-minute class period. If you have extra time, there are
      plenty of extensions you can explore in a second class period. 
      Spend as little time as possible introducing the lesson--it's best to jump right in. 
    </p><p>
      <strong>Setup:</strong> Hand out the individual instruction sheets which were generated
      with these instructions and ask students to complete the tasks under "setup." These are 
      different for each person. 
    </p><p>
      <strong>Demo:</strong> Tell students you are going to demonstrate the "Receiving messages"
      and "Sending messages" instructions on their instruction sheets, and ask them to read over
      these instructions for a minute. Then choose two students who are "regular nodes" on different
      subnets and model how one would send a message to the other. 
    </p><p>
      For example, {{sender.name}} will send a message to {{recipient.name}}. Follow these steps:
    </p><ol>
      <li>
        {{sender.name}} (whose IP address is {{sender.address}}) needs to find out 
        {{recipient.name}}'s IP address. To do this, {{sender.name}} needs to 
        consult their nameserver, whose IP address is {{sender.nameserver}} 
        (assigned in {{recipient.name}}'s instructions). Write the following message on a sheet of 
        paper:

        <div class="message-template">
          <ul>
            <li><span class="header">To:</span> {{sender.nameserver}}</li>
            <li><span class="header">From:</span> {{sender.address}}</li>
            <li><span class="header">Message:</span> What is {{recipient.name}}'s address?</li>
          </ul>
        </div>
        <p>
        Note that "from" and "to" must be IP addresses, not people's names. Other than "from", "to", 
        and "message", messages may not contain anything else. If anyone ever gets a malformed 
        message, they should feel free to crumple it up and throw it away. 
        </p>
      </li><li>
        Now {{sender.name}} should hand this message to the person to their right. Each person 
        should follow their own "Receiving messages" instructions until the message reaches
        {{sender_nameserver.name}}, the nameserver. Nameservers have a list of everyone's IP address,
        so {{sender_nameserver.name}} can write a reply:
        <div class="message-template">
          <ul>
            <li><span class="header">To:</span> {{sender.address}}</li>
            <li><span class="header">From:</span> {{sender.nameserver}}</li>
            <li>
              <span class="header">Message:</span> {{recipient.name}}'s address is 
              {{recipient.address}}.
            </li>
          </ul>
        </div>
      </li><li>
        Now this reply needs to be delivered. {{recipient.name}} hands the message to the person
        to their right, and once again each person follows their own instructions until the message
        reaches {{sender.name}}.
      </li><li>
        Now that {{sender.name}} knows {{recipient.name}}'s address, they can finally send a message:
        <div class="message-template">
          <ul>
            <li><span class="header">To:</span> {{recipient.address}}</li>
            <li><span class="header">From:</span> {{sender.address}}</li>
            <li><span class="header">Message:</span> Hey, it's {{sender.name}}. What are you doing
            after school today?</li>
          </ul>
        </div>
      </li><li>
        One last time, {{sender.name}} hands the message to their right, and everyone else follows
        their own instructions until the message is delivered.
      </li>
    </ol>
    </p><p>
      <strong>Round 1</strong>. In the first round of the simulation, everyone should do their
      best to make things work smoothly. The teacher should focus on helping people who get stuck. 
      After a suitable amount of time, once messages are finding their way around properly, 
      stop the simulation. 
    </p><p>
      <strong>Discussion</strong>. Ask students to share anything they noticed or anything they
      wondered. Common responses include:
      <ul>
        <li>
          Sometimes people send messages and they just disappear. (Is there anything you can 
          do other than re-sending?)
        </li><li>
          Sometimes nameservers or gateway routers get backed up, with large piles of messages. 
          Hopefully this was funny rather than stressful. (When someone gets backed up, what 
          should they do?)
        </li><li>
          Students often complain that other people are reading their messages. (What could be
          done about this?)
        </li><li>
          If you have a sufficiently trusting and playful classroom culture, some students may 
          have gotten up to some mischief, such as spoofing other users (sending messages that 
          claim to be from someone else), replacing messages in transit with different messages, 
          censoring messages, etc. (These are all real issues in networks. How could they be
          dealt with?)
        </li>
      </ul>
    </p><p>
      <strong>Round 2</strong> Run another round of the simulation. If things went well in Round 1, 
      consider adding a challenge or interfering with the network. Possible challenges:
      <ul>
        <li>With the class, agree on a policy to address an issue that came up in Round 1, 
        and see how well it works.</li>
        <li>Send a long, multi-part letter to someone else, using multiple messages.</li>
        <li>Find a way to send a secret message to someone else.</li>
      </ul>
      Possible forms of interference:
      <ul>
        <li>Start randomly intercepting messages and throwing them away.</li>
        <li>Create a message whose "to" address does not exist (it will go around and around forever, 
        until someone gets tired of it and throws it away!)</li>
        <li>
          Quietly encourare a student to begin some of the mischief described above: 
          spoofing other users (sending messages that claim to be from someone else), 
          replacing messages in transit with different messages, or censoring messages.
      </ul>
    </p><p>
      <strong>Concluding discussion</strong>. Once again, ask students to share anything they 
      noticed or anything they wondered. Depending on what additional lessons you are planning 
      to teach on networking, it may be valuable to write these down somewhere in the classroom
      so you can refer back to them. 
    </p>
  </div>
  {% for node in nodes %}
    <div class="node-instructions">
        {% include "node.html" %}
    </div>
  {% endfor %}
{% endblock %}