-- DonaldActon - 05 Jul 2011

The first draft of a course timeline with topics was Revision 1.7. Compare the current version to Revision 1.7 to see the changes.

After thinking about this for a bit, it seems like we could have three themes for the course that come together to form a story about how to use the Internet.

• I could imagine starting out with the initial focus being on basic networking. We would look at things like Socket Programming, the TCP/IP model of data streaming and what a protocol is. From there we would add more structure and look at things like the client server model, handling network errors (e.g. connection failure), the structure of the Internet and some distributed programming paradigms like publish/subscribe. At this point students should be able to write a basic application that lives on the Internet.

• The next phase explores applications that uses packet oriented services opposed to a byte stream like TCP. The intention is to motivate this section by introducing multimedia applications and seeing the need for a transport layer with different service properties. Students will be introduced to UDP (or some other transport type protocol that does not provide delivery or ordering guarantees) and exposed to how DNS works. (Note to self look for fast DNS, location DNS, basically DNS that uses some location information to return different results.)

• The final part of the course will focus on the "cloud" (could be motivated by things like app stores) and the rationale behind it. A section of this might also focus on public/private keys, SSL connections etc, which are key pieces of technology used to secure connections for stuff like banking and online retail.

Course Time Line (For January 2012)

Week 1 - January 5 -- Introductory lecture

• Rules and structure of the course
• In class exercise do something like a wget to introduce students to networking and protocols. Use it to tell the story of what we are going to be looking at in the course. Example of a wget might be to www.google.com and www.cs.ubc.ca, students could then compare the differences. (we might want to setup some special servers to return very simple pages so students can compare to some not so simple responses.) Could also want to explore what the communication model is (i.e reliable streamed inorder bytes with no notion of boundaries, perhaps some sort of activity where the server sends the same chunks of data but it is received in different chunks, maybe different times between data writes could achieve this.)

Week 2 - Jan 10, 12

The goal of this section is to introduce students to the socket API and the TCP abstraction of a connection oriented reliable byte stream. Basically students will learn how to use the socket API to make a connection and send data. The programming difference between the connection initiator and acceptor will be one of the topics covered.

• SocketProgramming part 1
• SocketProgramming part 2

Week 3 - Jan 17, 19 -- The notion of a protocol

One way that this section (which runs for the next couple of weeks) could go is to start the students out by having them invent a protocol for something. One of the key things would be to get to students to deal with issues like data formats, the rules for exchanging data (i.e. requests and responses) and completeness as in having to identify all possible scenarios. From that base students would then move on to interacting with a real server of some sort. Interacting with a mail server would be nice so that students get exposed to the idea of how little security there is around mail. A second client server activity would be to do something with an http server with a focus on server side issues. (Or maybe we could have them develop a simple server, or go back to an echo server that they may have worked on in the socket programming module.) Ideally this would lead into a discussion of handling multiple clients at a time and also performance issues associated with different HTTP request strategies like closing the connection when the response is finished as opposed to keeping it open and then sending a new request or keeping the connection open and pipelining requests.

• Introduction to Client Server programming and protocols
  • Construction of simple client and server
  • role of the client
  • role of the server
• This lecture session would focus on exploring and developing protocols.

Week 4 - Jan 24, 26 -- Dealing with Performance

At this point a student knows what a protocol is and the role of a server, so we can now advance to issues of improving performance at the server level. (The idea would be to have the student observe the "poor" performance of applications that work on one request to completion and spend a lot of time waiting for things be it disk I/O or requests to other servers to complete.

• Handling requests simultaneously using threads
• Handling requests simultaneously using an event driven model

Week 5 - Jan 31, Feb 2 -- Issues when building network based applications

The theme for the coming 2 weeks will be on exposing and educating (at an introductory level) the students about the issues and problems associated with building network based applications. The section could start by having the students explore the different types of errors that could be encountered on a TCP connection. Typical examples are connection initiation failures, and connection timeouts during a data exchange. From there one could advance to activities focusing on consistency and reliability (Basically Brewer's CAP Theorem. Another good summary is provided by Julian Browne's link.)

• Revisit protocols and now explore completeness and handling of errors (unexpected but legitimate events)
• Consistency and reliability (Brewer's CAP theorem)

Week 6 - Feb 7, 9 -- Distributed Data Models

• Models for distributing data such as publish/subscribe and software buses.
• Midterm and/or catchup day.

Week 7 - Feb 14, 16 -- Structure of the Internet

(perhaps this is the section where packets are "really" exposed, could the pre-class activity explain what a packet is) This week starts the part of the course that deals with exploring the organization, and structure of the internet and the issues associated with moving data in a packet switched network. The section will explore ideas like bandwidth, latency, jitter, and packet loss. The section will also look at how lost packets are handled and ways to improve throughput.

• Engage in activities to map/trace out the structure of the using things like ping, and traceroute. Also could have them do a reverse traceroute to try to determine if the forward and backward routes are the same or look for different routes to the same host. Should also be able to introduce notions of addressing and the association of IP addresses to interfaces as opposed to machines.
  • To try to get students to understand something about the structure and role that IP addresses play, we could have them ping a bunch of CS and try to observe patterns in the addresses. This could be expanded to include machines elsewhere on campus or around the world. One of the key things would be to make sure that the machines being pinged have something in common so that the subnet pattern is observable. Could also have them use the 192.168 (non-routable addresses) from the department and outside the department.
• In this class we would look at measuring Bandwidth, latency, jitter and packet loss. This could be a mixture of calculations and exploration, data gathering activities. It might be interesting to have the students do a throughput calculation for a stop and wait protocol and then compare it to an actual TCP measurement. (Use a best case scenario.)

Midterm break Feb 21, 23

Week 8 - Feb 28, Mar 1

• MultiMedia Part 1
• MultiMedia Part 2

Week 9 - Mar 6, 8

• Using multimedia as the motivation, we want to have the students do some sort of work with a transport layer where packets are, possibly, delivered out of order or not at all. (Alan has an example assignment from 417 where they use such a protocol and have to build a working app that plays back media. Apparently we provide a server that does all sorts of bad things and they write the client.)
• (Some question as to whether or not we want to go down this route) Introduce students to the UDP socket interface. Maybe have them write something like ping. If going down this route, it might be more appropriate to introduce UDP and then have them work with a more a transport protocol that adds features like sequence numbers or timestamps that the students have to deal with.
• Using UDP sockets we explore how to improve throughput with sliding windows & how to deal with knowing data got through and how to recover from lost packets. (Basically timeouts and sequence numbers)

Week 10 - Mar 13, 15

• Continuation of throughput/reliability session
• DNS - explore the purpose of DNS and how it works. Could use tools like dig and nslookup

Week 11 - Mar 20, 22

• Quiz/catchup
• Introduction and motivation to cloud computing. The motivation for cloud computing could be app stores, and mobile devices, we want to access data in the cloud for various reasons, could be our own data, distributed data, example have students do a traceroute to cbc.ca from here and australia will get different sites. What does it mean or what are the issues when the name binds to a different physical address that is supposed to make available the same content.

Week 12 - Mar 27, 29

• Privacy and confidentiality - Public Key - Explore how to secure data on a connection, in particular the usage of something like public key encryption. (Should be obvious that this is especially important for the "cloud" and mobile devices, or at least it is a place where the problem/concern is at the forefront.) We might also want to explore or introduce something like Shibboleth
• Work with a google API (Map reduce, task api, calendar API, prediction API)

Week 13 - Apr 3, 5

• Mobile - could this be based on bluetooth?
• Last class, review/questions

Other possible topics

• Working with big DATA (Alan's topic)

Concerns and Issues

• On days when there is a quiz, will it be possible to get students motivated enough to do any pre-class activities
• Need to identify the pre-class activity
• Need to specify in more detail the in-class activities
• Refine learning goals - In particular we want to enumerate for each section the low level learning goals along with their contributions or place in the course level learning goals. We also need to careful that the section/class level learning goals don't focus too heavily on being able to perform precise actions as opposed to exposing students to general principles.