CST370 - Week 1

 For this week we were introduced to the basics of algorithms and their usefulness in computer science. After going through the lecture material, I realized that I'm decent at implementing algorithms practically, but I don't have a good understanding of what makes an algorithm a good one and how to determine operations vs basic operations, etc. This will definitely be something that I take time to review further as the class progresses. Another opportunity for me will be slowing down to review pseudocode. I noticed that I tend to assume I know what's going on and glance over the code too quickly when I should be taking the code line by line to make sure I'm fully understanding. One thing I am excited for is the mathematical side of this class. My math has gotten a little rusty over the years, but it used to be my favorite part of computer science, so I'm hoping to find that connection with it again.

CST311 - Week 8

 For this week, we briefly read over firewalls and how they are used in regards to network security. However, most of my time this week was spent working on PA4. For this assignment I worked mainly on part 3, which had to do with generating the certificate. I learned how to save IP addresses from the Mininet network to file and how to generate the certificate without user interaction in order to match the demo video. Learning about how to use the subprocess module was interesting and I imagine it will be very beneficial moving forward to be able to send instructions to the command line in that way. 

CST 311 - Week 7

 For week 7, most of my time was spent studying for the final exam. I spent some more time tracing through Djikstra's algorithm and practicing my understanding of IP addresses and subnet masks. When it comes to new content, we read over Chapter 6, which covers The Link Layer and LANs. As opposed to the network layer that covers end-to-end communication across a series of links, this chapter focused on how information traverses the individual links. 

Basics

There are two link-layer channels -- broadcast channels, which connect multiple hosts in wireless networks, and point-to-point communication links, for example, two routers connected by a long-distance link. The basic service of the link layer is to transfer a datagram from one node to an adjacent one, but we read about the potentially varying details of a link-layer protocol, like framing, link access, reliable delivery, and error detection and correction. We learned that the link layer is usually implemented on a chip called the network adapter, which implements these services. The layer's functionality is mostly controlled by the hardware with only higher-level functionality being software-controlled. Because of this, you can think of the link layer as the place in the stack where hardware meets software. 

Error Checking

One of the main sections that stuck out to me was the section on error-checking. There are three techniques for detecting errors -- parity checks, checksumming methods, and cyclic redundancy checks. 

Parity checks are the simplest form of error-checking, where for information D with d bits in an even parity scheme, the sender includes an additional bit with value such that the total number of 1s in the d + 1 bits is even. In an odd scheme, the number of 1s will be odd. With a two-dimensional parity scheme, a receiver can detect the error and also where it occurred.

A checksum is based on the idea that bytes of data are treated as 16-bit integers and summed. The 1s complement of this forms the checksum. When received, 1s complement of the checksum is performed and if any resulting bits are 1, an error will be detected.

A widely used technique is one based on cyclic redundancy check codes. First, the sender and receiver agree on an r + 1 bit pattern called a generator (G). The idea is that for data D, the sender chooses r additional bits, R, and append them to D so that d + r bit pattern is exactly divisible by G. If the remainder of (d + r)/G does not equal zero, there has been an error.

CST 311 - Week 6

 This week we went covered chapter 5 of the textbook, which dealt with the control plane within the network layer. The control-plane is the network-wide logic that controls how a datagram is routed and also how the network-layer components and services are configured and managed. Later in the chapter we talked about two main routing protocols: OSPF, which exists within a single network and BGP, which interconnects all of the networks that make up the internet. Finally we covered some ways of managing an IP network -- ICMP, the Internet Control Message Protocol, and SNMP, the Simple Network Management Protocol. The thing that stood out the most to me this week was the review of shortest-path algorithms. While I've learned about Djikstra's algorithm in previous courses, I definitely needed to review how to trace it through the nodes. The worksheet for practicing this proved to be extremely useful and I looked up a few other videos to help me feel more comfortable with the content as well.

CST 311 - Week 5

 This week we took a dive into the network layer, which is widely considered to be the most complex layer of the protocol stack. The main role of the network layer is to move packets from a sender to a receiver. Because of this, two functions in particular are very important -- forwarding and routing. Forwarding refers to the router-local action of transferring a packet from an input link interface to the appropriate output link interface. Routing on the other hand refers to the network-wide process that determines end-to-end paths that packets take from source to destination. We also looked over different types of packet scheduling -- FIFO, Priority Queuing, Round Robin, and Weighted Fair Queuing. Next we took some time to learn about IP address and how to convert between binary and dotted-decimal notation. We also covered DHCP, or the Dynamic Host Configuration Protocol, which is a client-server protocol that allows a host to obtain an IP address automatically.

 Overall this week contained a wealth of information and I'm not sure I've wrapped my head around it. I'm about halfway through the optional worksheets and I intend to finish going over those in order to get a better grasp on the concepts before the final exam next week.

CST 311 - Week 4

 Most of my week 4 was spent studying for the midterm. I knew I was struggling with computing the transmission times, so I focused on that. Luckily it paid off and I did better than anticipated on the exam. Unfortunately, two of the questions I missed were errors concerning JEDEC standard vs SI. I thought that I had considered that in my calculations, but I will be sure to double check for the next exam.

We also began work on the network security section of our text. I'm excited to start this section as I was obsessed with code-breaking as a kid so I'm hoping that interest will translate to understanding. So far, the different encryption algorithms are a little over my head, but I know they play an important role in modern-day security, so I am hoping as this section continues I will develop a better comprehension of them.

CST 311 - Week 3

 This week's reading concerned the transport layer, the services it offers (multiplexing, demultiplexing, reliable data transfer, and flow/congestion control), and the protocols involved (UDP, TCP). In comparison to the network layer, which is the logical communication between hosts, the transport layer works as the logical communication between processes and relies on the network layer. The two transport layer protocols are TCP and UDP. UDP is a connectionless protocol that is unreliable and unordered, whereas TCP  is connection-oriented, reliable, and offers flow and congestion control. While it seems unlikely that anyone would choose to utilize UDP over TCP, we learned of a few circumstances where UDP is the better option. We looked at the idea of multiplexing/demultiplexing, which involves funneling and distributing data. The metaphor of entering/exiting a freeway really helped me to understand this concept. Next, we learned about the principles of reliable data transfer and the strategies TCP uses to guarantee this. 

 Outside of lecture, we completed the team programming assignment which had us creating our own version of a UDP Ping service and a UDP Heartbeat. There were also two individual labs to complete which dealt with traffic and congestion control. These were more of a struggle to me as I'm still trying to wrap my head around calculating delays and such. In addition, the Mininet graphical interface wasn't cooperating as well as I'd hoped, but I got it sorted out in the end.