List of exchanges

[James Aylett]

Or "scenes", as we should perhaps call them. These are from the notes I made at Scale Camp, with some gaps filled. I've tried to re-order them in a way that makes sense to me, although it's not always easy. Note that there's a huge number here, and I don't think we should tackle them in the order presented: what would be more useful to start off with is to take some of the first from basic, then some routing, and then perhaps see if there's a way to build a single higher level protocol on top of them. (DNS or HTTP would be strong contenders, I think.)

Basic scenes

* Simple IP (packet exchange between nodes on the same subnet)
* ARP
* TCP handshake
* Checksumming
* TCP sliding window
* Nagle
* TCP termination (and hence *_WAIT)

Routing and *casting

* broadcast and unicast (and hence hubs and switches)
* Simple IP routing (via static routes)
* multicast
* anycast
* NAT
* dynamic routing: RIP
* dynamic routing/reachability: BGP

TCP & network congestion

* Congestion window
* Slow start
* RED (and better)

Failure cases

* Bad routes
* ARP cache poisoning
* Congestive collapse
* BGP bad routes

Other protocols & bits and pieces

* ICMP & traceroute
* DHCP?
* DNS
* HTTP
* Connection filtering
* Packet filtering & DPI

Some of these will need unpacking, some may be better avoided, and I've probably missed some obvious ones. We probably will end up with a flow chart (a bit like a class dependency diagram) that shows which things you should do in order to build up to a useful understanding of something higher level (which is perhaps more relevant say when explaining how everything fits together for HTTP to web developers than it is for taking into schools, but I could be wrong).

Some topics, such as everything RIP & BGP, have lots more failure modes, and specific approaches to mitigate or avoid them, but that's probably getting far too ambitious :-)

Getting started: our 101 scenes

I propose the following, in this order:

1) broadcast and unicast (and hence hubs and switches)
2) Simple IP (packet exchange between nodes on the same subnet)
3) ARP
4) TCP handshake
5) Simple IP routing (via static routes)
6) DNS
7) HTTP

Or to paraphrase:

1) getting messages to each other
2) who sends the messages
3) where to send the messages
4) preparing for lots of messages
5) talking to more distant computers
6) using names not addresses
7) how the web works

We've already done some of these (ARP, simple IP & simple IP routing), so hammering out a proper script for them shouldn't be too hard. Some of the others aren't too tricky either (TCP handshake will force us to deal with exposing and hiding different levels of abstraction), and DNS & HTTP presents us with interesting challenges. (And if we can't figure them out, 1-5 are still useful and then we can go after some of the other stories.)

So…does that sound vaguely sane? And who else should we invite in to help us do this?

James

--
James Aylett
talktorex.co.uk - xapian.org - devfort.com - spacelog.org