bleh

cst311/lec/lec20.md

@@ -0,0 +1,48 @@
+# lec20
+
+Link Layer(is it cool or is it whack)
+
+_Frame_: packets on link layer i.e. layer-2 packet
+
+MAC addresses are used at this layer more often since we don't assume that we'll ever have millions/thousands of people connecting to one network.
+
+## Services
+
+* Framing and link access
+
+Yet another header is added at this point
+
+* Reliable delivery 
+
+* Flow control 
+
+Receiver can report lower send rates
+
+* Error Detection
+
+	* Retransmission signals
+	* checksums yo
+
+## where tho
+
+usually this is in hardware/firmware
+
+Typically theres a microcontroller next to the some bus reading in and out whatever it can
+
+Sender usually tacks on header
+
+Receiver will take take analyze things then send it back up across the apic etc etc, it usually comes right back to another controller to write out onto a different bus.
+
+## Checksum? more like check this parity 
+
+physical world is full of noise so basic checksums won't do shit anymore.
+This is why use things like parity checks.
+Pretty much we take some stream, push it into a grid of n by m size
+Add 1 to n & m. Where the tall side get filled with the parity of each row and the low side is filled with columns' parity.
+Send this result to receiver who verifies this stuff, and we can determine single bit errors.
+
+## Cyclic redundancy check
+
+_even more techniques for error detection_
+
+View a bit stream as some size\_t binary value

cst311/lec/lec21.md

@@ -0,0 +1,47 @@
+# lec21
+
+_Recall CRC_: Basically long division but with xor's instead of repeated subtractions
+
+## Multiple Access Protocols
+
+* point to point link
+
+One machine on each end of the link
+
+* broadcast 
+
+-----
+Ideallly: 
+* we would make sure each node could send at whatever rate they needed to
+* decentralized 
+* simple to implement
+
+## MAC protocols
+
+Three main classes of protocols methods: 
+1. channel paritioning
+	* time muxing, frequency muxing etc
+
+2. Random access
+	* allow collisions and just try to recover on the fly
+
+3. Taking turns
+	* nodes take turns doing things
+
+
+## Random Access 
+
+Basically whenever there's a collision we would retransmit.
+
+### ALOHA
+
+Partially time slotted technique.
+This means it helps us to have an accepted frame size.
+
+Once a node is transmitting it can transmit at its full bandwidth.
+There is tons of collision however, which means we have to recover a ton as well.
+
+Pure unslotted ALOHA we basically transmit a frame as soon as is arrives which means frames can overlap.
+Putting these frames into slots allows us to reduce this collision probability overall raising our efficiency.
+
+

cst311/lec/lec22.md

@@ -0,0 +1,33 @@
+# lec22
+
+_This is continuation of previous lecture where MAC protocols are covered in brief._
+## Taking turns
+
+Let's now describe various methods to achieve turn taking.
+
+
+1. _polling_:
+
+	* master invites slaves to transmit data
+
+2. _token rings_:
+
+	* control token passed from node to node
+## ARP: Address Resolution Protocol
+
+Protocol to determine MAC address on a given device in a network.
+
+Upon association the protocol will emplace an entry into the target device's `arp table` where we record MAC and IP address associations.
+
+# Wireless links
+
+Interference: everything will cause interference which means we expect interference.
+
+Primarily for wireless connections: _Code Division Multiple Access_(asynchronus kinda)
+
+### CDMA 
+
+Each node receives a code which it uses to splice transmissions across the wireless link.
+Each node may transmit data at an arbitrary rate since the transmissions splice into each other forming a consistent signal cumulatively.
+
+

cst311/lec/lec23.md

@@ -0,0 +1,38 @@
+# lec23
+
+Wifi stuff in this lecture... jk its cellular shit wew lad
+
+
+## Pieces
+
+* base station
+
+covers an area for users
+
+* users
+
+yea
+
+* air interface
+
+most(all) of this based on air to air connections
+
+## Dividing up signals
+
+Either we use _TDMA_ or _FDMA_ at the cell tower level.
+
+## Mobility 
+
+Since we're dealing with dealing with literally moving targets now we have to consider a few new things, like handling how cell tower's deal with people connecting and disconnecting all the time.
+Moving from access point to access point we must  somehow maintain connections.
+
+To route this kind of thing we have two options:
+
+1. Let routing handle it
+
+Just like previous lectures, send off some data and hope that the data gets to the right place
+
+2. End system offloading
+
+Let end systems deal with it via direct or indirect routing.
+