Anytime data integrity is important:

1. Websites
2. File downloads
3. streaming videos/audio : where watching videos or listening to podcasts you may need to see every frame.

When performance is more important than quality:

1. VOIP (Voice over IP)
2. Real-time video : Here you want to keep pace with the video as it is real-time so missing a packet isn't as important as keeping pace with the video.
3. Network services

Top level domain: The last part of the domain. e.g.: .com, .net, .org

Transmission Control Protocol : Used when you want reliable connections such as web browsing, downloading files, fetching email, streaming music or videos.

User Datagram Protocol: Used when you don't mind a more unreliable connection, but real time interactivity is more important. Voice Over IP, Video Chat are examples of where you might use UDP

A hardware address assigned to every physical networking device on a network. They look like a series of Hexidecimal values like ea:de:36:d9:5a:b8; They are used to communicate on the local network ONLY.

An address assigned to a networking device. Usually assigned by an ISP or a router on a local network using DHCP. They are used to route connections across multiple networks. Example: IPV4: 192.168.1.1

Represents a TCP/UDP connection on an actual computer. Valid ports are in the range from 0 - 65535. Used by the operating system of a computer to route TCP connections to the right program running on a computer. These programs can be said to be "listening" on a port. No two programs are allowed to listen on the same port at once.

HTTP port 80, and HTTPS port 443.

A device which hooks multiple computers together over ethernet and blindly repeats ethernet packets to all the other devices on a local area network.

A device which intelligently hooks multiple computers together over ethernet and sends ethernet packets to the correct devices on a local area network based on MAC addresses.

A device which is responsible for routing IP packets BETWEEN Different networks.

The internet protocol address assigned to a particular networking device

A human readable name assigned to an IP address. Examples: google.com or appacademy.io.

Domain Name System: A protocol (on UDP port 53) that allows our computer to talk to a DNS Server and resolve a Domain Name into an IP address. Example: google.com might resolve to 172.217.6.142.

This record directly maps a domain name to an IPv4 Address

This directly maps a domain name to an IPv6 Address

This maps a domain name to another domain name. An alias, you might say.

This defines the mail server for a domain.

This defines the DNS Servers for a zone (domain)

Start of Authority: Defines which DNS Server is the authority for a zone (domain)

In the version. This is a binary number. IPv4 = 0100; IPv6 = 0110. The version number is the 1st->4th bit in the packet

4 octets: 192.168.1.1 for example

• IPv6 addresses are made up of a 128bit number
• IPv6 addresses are typically represented as hexidecimal, with every 4 digits separated by a ':'
• Example: 2001:0db8:85a3:0000:0000:8a2e:0370:7334

• Example: 2001:0db8:85a3:0000:0000:8a2e:0370:7334
• You can replace 4 zeroes in an IPv6 address with only 1 zero
• Leading zeroes can be removed (0370 -> 370)
• An entire string of zeroes can be removed, but you can only do this once
• The above IPv6 string can be reformatted with these rules as follows: 2001:db8:85a3::0:8a2e:370:7334

The IPv6 header

IPv4 : Identified by the first 4 bits on the header, 0100 = 4. Also, this header has many additional fields included in it. IHL, DSCP, ECN, Total Length, Identification, Flags, Fragment Offset, Time To Live, Protocol, Header Checksum and Options. Notice the 3 fields that are the same between IPv4 and IPv6 headers: Version, Source IP Address and Destination IP Address

IPv6: Notice many fewer fields (8 vs 14), but has Version, Source IP Address and Destination IP Address in common

The Internet Layer (IP)

Yes!

A tree is a graph that does not contain any cycles. Note the image below. Tree 4 is a graph in mathematics, but in computer science it is not.

A binary tree is a tree where nodes have at most 2 children. Graphs 1, 2 and 3 are all binary trees shown below.

1. Pre-order traversal : 9:00 : S, L, R
2. In-order traversal : 6:00 : L, S, R
3. Post-order traversal : 3:00 : L, R, S

    function inOrderPrint(root) {
        if (!root) return;

        inOrderPrint(root.left);
        console.log(root.val);
        inOrderPrint(root.right);
    }

    function postOrderPrint(root) {
        if (!root) return;

        postOrderPrint(root.left);
        postOrderPrint(root.right);
        console.log(root.val)
    }

    function inPreOrder(root) {
        if (!root) return;

        console.log(root.val);
        inPreOrder(root.left);
        inPreOrder(root.right);
    }

    function printBreadthFirst(root) {
        let queue = [];
        queue.push(root);
        while (queue.length) {
            let currNode = queue.shift();
            if (currNode.left) queue.push(currNode.left);
            if (currNode.right) queue.push(currNode.right);
            console.log(currNode.val);
        }
    }

    function postOrderArray(root) {
        if (!root) return [];

        return [
            ...postOrderArray(root.left),
            ...postOrderArray(root.right),
            root.val
        ]
    }

    function preOrderArray(root) {
        if (!root) return [];

        return [
            root.val,
            ...preOrderArray[root.left],
            ...preOrderArray[root.right]
        ]
    }

    function inOrderArray(root){
        if (!root) return [];
        return [
            ...inOrderArray(root.left),
            root.val,
            ...inOrderArray(root.right)
        ]
    }

    function add(root, val) {
        if (!root) //root is null
        {
            let newNode = new Node(val);
            root = newNode;
        }

        if (val < root.val) {
            if (root.left === null) {
                let newNode = new Node(val);
                root.left = newNode;
            } else {
                add(root.left, val);
            }
        else if (val > root.val) {
            if (root.right === null) {
                let newNode = new Node(val);
                root.right = newNode;
            } else {
                add(root.right, val);
            }
        }

    function searchRecurse(root, val) {
        if (!root) return false;

        if(root.val < val) {
            return searchRecurse(root.right, val);
        } else if (root.val > val) {
            return searchRecurse(root.left, val);
        } else // (root.val === val) {
            return true;
        }
    }

    function searchIter(root, val) {
        let currNode = root;
        while (currNode) {
            if (currNode.val < val) {
                currNode = currNode.right;
            } else if (currNode.val > val) {
                currNode = currNode.left;
            } else if (currNode.val === val) {
                return true;
            }
        }
        return false;
    }

1. The left subtree values must be less than the root.
2. The right subtree values must be greater than the root.

A graph is a collection of nodes and any edges between those nodes.

Yes!

Yes!

Yes!

1. Using a class: GraphNode with two properties: val, and neighbors = []
2. Using an adjacency list: graph = { 'a' : ['b'], 'b' : ['a'] }

    let graph = {
        'q': ['r'],
        'r': ['q'],
        's': ['t'],
        't': ['s', 'u', 'v'],
        'u': ['t', 'v'],
        'v': ['u', 't'],
        'w': []
    };

    function breadthFirstSearch(graph, startingNode, targetVal) {
        let queue = [ startingNode ];
        let visited = new Set();
        while(queue.length) {
            let node = queue.shift();
            if (visited.has(node)) continue;
            visited.add(node);
            if (node === targetVal) return true;
            queue.push(...graph[node]);
        }
        return false;
    }

    breadthFirstSearch(graph, graph['t'], 'q'); //returns true;
    breadthFirstSearch(graph, graph['q'], 'c'); //returns false;

Note with the following: If your graph has disjointed subgraphs - in that there is no way to move from one subgraph to another, your starting node is ONLY the subgraph you want to search through. Also note, this algorithm only works on graphs with NO cycles. We won't be tested on searching through a cycle for depth-first, so set that topic aside. Also note, mathematicians consider cycles as a graph. Computer scientists do not.

    const depthFirst = (graph, node, targetVal, visited = new Set()) => {
        if (node === targetVal) return true;
        visited.add(node);
        for (let neighbor of graph[node]) {
          if (visited.has(neighbor)) continue;
          if (depthFirst(graph, neighbor, targetVal, visited)) {
            return true;
          }
        }
        return false;
      };

1. Clarify the problem & test I/O and edge cases
2. Formulate your approach(es)
3. Pseudocode your best approach
4. Code it
5. Walk through an example input
6. Determine the Big O time and space complexity