Computer Networks (CN)

1. OSI Model (7 Layers & their protocols)

The Open Systems Interconnection (OSI) Model is a conceptual framework that standardizes the functions of a telecommunication or computing system into seven logical layers. It ensures interoperability between diverse communication systems with standard protocols.

When you load a webpage, your browser starts at Layer 7 and the signal travels down to Layer 1 before entering the cable.

2. TCP/IP Model vs. OSI

The TCP/IP Model is the functional implementation used in the modern internet, consisting of 4 (or 5) layers. Unlike OSI, it merges the top three layers into a single Application layer and combines the physical/data link layers in some versions.

Every router and smartphone uses TCP/IP to synchronize and transmit data globally.

3. TCP vs. UDP (Handshaking vs. Connectionless)

**Transmission Control Protocol (TCP)** is a connection-oriented, reliable protocol that ensures data delivery via acknowledgments. **User Datagram Protocol (UDP)** is a connectionless, unreliable protocol that prioritizes speed over data integrity.

Downloading a PDF uses TCP (all bytes must be correct); playing 'PUBG' uses UDP (one dropped packet doesn't matter).

4. IP Addressing (IPv4 vs. IPv6, Classful vs. CIDR)

**IP Addressing** is a unique numeric label assigned to each device in a network. **IPv4** uses 32-bit addresses (approx. 4 billion), while **IPv6** uses 128-bit addresses to handle the exponential growth of connected devices.

Your WiFi router assigns you an IPv4 address like 192.168.1.5 domestically.

5. Subnetting & Supernetting

**Subnetting** is the process of dividing a large network into smaller, manageable sub-networks to reduce congestion. **Supernetting (CIDR aggregation)** is the inverse, combining multiple smaller networks into a single large one to reduce routing table size.

An office divides their network so the HR and IT departments have separate **Subnets** for security.

6. DNS, DHCP, and NAT

Fundamental internet service protocols. **DNS** translates domain names to IPs; **DHCP** automatically assigns IPs to devices; **NAT** allows multiple private IPs to share one public IP.

When you join a Starbucks WiFi, **DHCP** gives you an IP, and **NAT** lets you browse the web using the shop's single public address.

7. HTTP vs. HTTPS (The SSL/TLS Handshake)

**HTTP** is the plain-text protocol for web browsing; **HTTPS** adds a layer of security by encrypting the data using **SSL/TLS**. HTTPS protects against "Man-in-the-Middle" (MITM) attacks.

Banking websites strictly use **HTTPS** to ensure your password isn't visible on the public network.

8. Routing Protocols (Distance Vector vs. Link State)

Algorithms used by routers to find the best path for data packet transmission. **Distance Vector** protocols choose paths based on hop count; **Link State** protocols build a complete map of the network for smarter decisions.

Corporate networks use **OSPF** to automatically redirect traffic if a main fiber line is cut.

9. Error Control (CRC, Checksum, Parity)

Mechanism at the Data Link/Transport layers to detect if bits were altered during transmission. **CRC (Cyclic Redundancy Check)** is the most robust method, treating the bit stream as a polynomial.

Every Ethernet frame includes a **CRC** trailer to discard corrupted packets locally.

10. Flow Control (Stop & Wait, Sliding Window)

Mechanisms to ensure a fast sender doesn't overwhelm a slow receiver. It adjusts the rate of data flow between two nodes.

Streaming a video uses **Sliding Window** to keep data flowing while waiting for previous acknowledgments.

11. Congestion Control (Leaky Bucket, Token Bucket)

Network-wide traffic management to prevent node saturation. **Leaky Bucket** ensures a constant output rate (no bursts); **Token Bucket** allows bursts but limits the average rate.

ISPs use **Token Bucket** to let you enjoy high-speed page loads while capping your sustained download speed for a 50GB file.

12. Network Devices (Hub, Switch, Router, Gateway)

Hardware components that build the network. **Hubs** broadcast, **Switches** filter (MAC-based), **Routers** connect networks (IP-based), and **Gateways** convert between dissimilar protocols.

A **Switch** allows two people in the same office to send large files simultaneously without slowing each other down.

13. ARP & RARP

Conversion protocols between Layer 2 and Layer 3 addresses. **Address Resolution Protocol (ARP)** finds a MAC address from a known IP; **Reverse ARP (RARP)** finds an IP from a known MAC.

When you ping 192.168.1.1, your computer first sends an **ARP** request to find your router's hardware MAC address.

14. ICMP (Ping & Traceroute)

**Internet Control Message Protocol (ICMP)** is used by network devices to send error messages and operational information. It is the core of diagnostic tools like **Ping** and **Traceroute**.

Running `ping google.com` sends **ICMP** Echo packets to check if your internet connection is alive.

15. Network Topologies (Mesh, Star, Bus)

The geometric arrangement of devices in a network. **Mesh** is the most robust (everyone connected); **Star** is the most common (connected to a central hub/switch).

Home WiFi setups are **Star Topologies**, where your phone and laptop all connect to the central router.

16. MAC Address vs. IP Address

**MAC Address** is a 48-bit permanent hardware identifier (Physical); **IP Address** is a 32/128-bit dynamic logical identifier (Logical).

A **MAC address** is like your Social Security Number (permanent); an **IP address** is like your Current Mailing Address (changes when you move).

17. Firewalls & VPNs

Network security tools. **Firewalls** filter incoming/outgoing traffic based on rules; **VPNs (Virtual Private Network)** create encrypted tunnels over public networks to hide data and location.

Working from home requires a **VPN** to access the company's internal files securely.

18. Socket Programming basics

The API used by programmers to create end-to-end network communication. A **Socket** is an endpoint formed by combining an **IP Address** and a **Port Number**.

A Chat Application uses **Sockets** to bind your phone to a specific port on the server to receive messages.

19. 3-Way Handshake (SYN, SYN-ACK, ACK)

The process used by TCP to establish a reliable connection before data transfer. It ensures both sides can send and receive data.

Before your computer downloads a file, it performs a **3-Way Handshake** with the server to agree on sequence numbers.

20. SMTP, FTP, POP3, IMAP protocols

Standard application-layer protocols. **SMTP** is for sending emails; **FTP** for file transfers; **POP3/IMAP** for retrieving emails from a mail server.

When you send a CV, you use **SMTP**, and the recruiter reads it via **IMAP** on their phone.

Machine Learning (ML)

1. Supervised vs. Unsupervised vs. Reinforcement Learning

**Supervised Learning** uses labeled data to train models for mapping inputs to known outputs. **Unsupervised Learning** finds hidden patterns in unlabeled data, while **Reinforcement Learning (RL)** trains an 'agent' to make decisions by rewarding positive actions and penalizing negative ones.

A spam filter uses **Supervised Learning**; a customer segmenting tool (Amazon recommendations) uses **Unsupervised Learning**.

2. Linear & Logistic Regression

**Linear Regression** predicts a continuous numeric value by fitting a straight line to data points. **Logistic Regression** is used for binary classification, predicting the probability (0 to 1) of an instance belonging to a specific class using the Signmoid function.

Predicting a house price uses **Linear Regression**; deciding if an email is 'Spam' or 'Inbox' uses **Logistic Regression**.

3. Bias-Variance Tradeoff

**Bias** is the error introduced by simplifying a complex real-world problem (Underfitting). **Variance** is the error from being too sensitive to small fluctuations in training data (Overfitting).

A linear model trying to fit circular data has **High Bias**; a complex polynomial fitting every outlier has **High Variance**.

4. Overfitting & Underfitting (Regularization)

**Overfitting** happens when a model performs perfectly on training data but fails on unseen data. **Underfitting** occurs when the model is too simple to learn even the training data. **Regularization** techniques prevent overfitting by penalizing high weights.

Memorizing questions for an exam is **Overfitting**; understanding the concepts is **Generalization**.

5. L1 (Lasso) vs. L2 (Ridge) Regularization

Techniques that add a penalty to the loss function to prevent overfitting. **L2 (Ridge)** penalizes the square of weights; **L1 (Lasso)** penalizes the absolute value of weights and can drive them to exactly zero.

If you have 100 features but only 10 matter, use **L1 (Lasso)** to automatically zero-out the useless 90.

6. Decision Trees & Random Forest

A **Decision Tree** is a flowchart-like structure that splits data based on feature values. **Random Forest** is an ensemble method that creates multiple trees using bagging and averages their results to reduce variance.

A Single Tree helps you decide 'Should I play tennis?'; a **Random Forest** asks 100 people and takes the majority vote.

7. Support Vector Machines (SVM) & Kernels

**SVM** finds the optimal 'Hyperplane' that creates the maximum margin between two classes. The **Kernel Trick** allows SVM to solve non-linear problems by mapping data into a higher-dimensional space where it becomes linearly separable.

Image recognition tasks use **SVM** with RBF kernels to distinguish between complex shapes like hand-written digits.

8. K-Nearest Neighbors (KNN)

A **Lazy Learning** algorithm that classifies a point based on the majority labels of its \(K\) closest neighbors. It doesn't 'learn' a model; it simply stores the data and calculates distance at runtime.

A real-estate app uses **KNN** to suggest a house price by looking at the prices of the 5 nearest similar houses.

9. K-Means & Hierarchical Clustering

**K-Means** is a centroid-based clustering algorithm that partitions data into \(K\) exclusive clusters. **Hierarchical Clustering** builds a tree-like structure (Dendrogram) to represent nested clusters.

Netflix uses **Clustering** to group users based on their viewing habits into 'Genre Tribes'.

10. Principal Component Analysis (PCA)

**PCA** is a dimensionality reduction technique that transforms a large set of variables into a smaller one that still contains most of the original information. It finds new axes called **Principal Components** that maximize variance.

Reducing 100 census variables into 5 'Indices' for easier visualization is done via **PCA**.

11. Evaluation Metrics (Precision, Recall, F1, ROC-AUC)

Quantitative measures to assess model performance. **Precision** measures accuracy of positive predictions; **Recall** measures the ability to find all positive instances. **F1 Score** is their harmonic mean.

A spam filter needs high **Precision** (don't block important mail); a COVID-19 test needs high **Recall** (find all infected).

12. Confusion Matrix & Type I/II Errors

A **Confusion Matrix** is a table used to describe the performance of a classification model. **Type I Error** is a 'False Positive' (Rejected a true null), while **Type II Error** is a 'False Negative' (Accepted a false null).

In a court trial, convicting an innocent person is a **Type I Error**; letting a guilty person go is a **Type II Error**.

13. Gradient Descent (Batch, SGD, Mini-batch)

An optimization algorithm used to minimize the cost function by iteratively moving in the direction of the steepest descent. The **Learning Rate (\(\eta\))** determines the step size.

Training a massive model like GPT requires **Mini-batch GD** to fit processing requirements and maintain speed.

14. Ensemble Learning (Bagging vs. Boosting)

Combining multiple weak learners to create a strong predictive model. **Bagging** reduces variance by parallel training (Random Forest); **Boosting** reduces bias by sequential training (XGBoost, AdaBoost).

Predicting house market trends often uses **XGBoost (Boosting)** for the highest possible precision in time-series data.

15. Naive Bayes (Bayes Theorem)

A probabilistic classifier based on **Bayes Theorem** with a 'Naive' assumption of total feature independence. Despite the simplistic assumption, it is highly effective for text data.

Your first spam filter in the early 2000s likely used **Naive Bayes** to check for words like 'Prize' or 'Urgent'.

16. Feature Engineering & Selection

**Feature Engineering** is the art of creating new features to help the model learn (e.g., extracting 'Day of Week' from a timestamp). **Feature Selection** is pruning existing features to simplify the model and reduce noise.

In a loan model, adding a feature 'Income-to-Debt Ratio' created from raw columns is **Feature Engineering**.

17. Cross-Validation (K-Fold)

A resampling technique used to evaluate a model's performance on multiple subsets of data. **K-Fold CV** splits data into \(K\) parts, training on \(K-1\) and testing on 1, repeating this \(K\) times.

Academic researchers use **K-Fold** to prove their model is truly robust across different samplings of a medical trial.

18. Curse of Dimensionality

High-dimensional data (too many features) causes data points to become increasingly sparse, making distance-based algorithms like KNN or K-Means highly inaccurate and demanding massive amounts of training data.

Searching for a specific book in a 1D shelf is easy; searching in a 1000-dimensional library where every book is equidistant is the **Curse**.

19. Hyperparameter Tuning (Grid vs. Random Search)

Hyperparameters are settings defined before training (e.g., Learning Rate, K in KNN). **Grid Search** tries every combination in a predefined set, while **Random Search** samples combinations randomly for faster results.

Before deploying an XGBoost model, engineers use **Random Search** to find the perfect 'Number of Trees' and 'Depth'.

20. Model Drift & Deployment (MLOps basics)

**Model Drift** is the degradation of model performance over time because real-world data patterns change. **MLOps** comprises the practices of automating the deployment, monitoring, and maintenance of ML models.

A shopping model trained before COVID-19 suffered from massive **Model Drift** when buying habits shifted suddenly in 2020.

Deep Learning (DL)

1. Perceptron & Multi-Layer Perceptron (MLP)

A Perceptron is the simplest form of a neural network, consisting of a single layer of weights and a threshold activation function. A Multi-Layer Perceptron (MLP) is a feedforward artificial neural network consisting of at least three layers (input, hidden, and output) with non-linear activation functions.

A simple **Perceptron** can decide if you should wear a coat based on temp > 10°C; an **MLP** can predict the exact temperature based on complex climate variables.

2. Activation Functions (ReLU, Sigmoid, Tanh, Softmax)

**Activation Functions** are mathematical equations that determine the output of a neural network node. They introduce Non-linearity into the network, allowing it to learn complex patterns instead of acting as a simple linear transformation.

**ReLU** is used in almost all deep image recognition models to keep the training speed high and gradients healthy.

3. Forward & Backpropagation (Mathematical intuition)

**Forward Propagation** is the process of passing input through the network to generate a prediction. **Backpropagation** is the method used to calculate the gradient of the loss function with respect to each weight by applying the Chain Rule, essentially moving 'errors' backward to update the model.

**Backpropagation** is like a student checking the answer key and tracing back their mental mistakes to prepare for the next practice test.

4. Loss Functions (MSE, Cross-Entropy)

**Loss Functions** quantify how 'wrong' the model's predictions are compared to the actual targets. **MSE (Mean Squared Error)** is used for regression, while **Cross-Entropy** is the standard for classification, measuring the difference between two probability distributions.

Predicting stock prices uses **MSE**; identifying if an image is a dog or cat uses **Cross-Entropy**.

5. Vanishing & Exploding Gradient Problems

Instabilities in deep neural networks during training. **Vanishing Gradients** occur when gradients become extremely small, causing early layers to stop learning. **Exploding Gradients** occur when gradients grow uncontrollably, leading to unstable weight updates and model 'diversion'.

Training a 100-layer network would be impossible without **Residual Connections (ResNet)** to bypass the vanishing gradient bottleneck.

6. CNN: Architecture (Convolution, Pooling, Padding)

**Convolutional Neural Networks (CNNs)** are specialized for spatial data like images. They use **Filters (Kernels)** to detect features like edges and textures via mathematical convolution, followed by **Pooling** to reduce dimensionality and ensure translation invariance.

**CNNs** are the core technology behind Face ID on your iPhone and self-driving car vision systems.

7. RNN: Sequential data & Vanishing Gradients

**Recurrent Neural Networks (RNNs)** are designed for sequential data (time-series, text) where inputs are dependent on previous states. They maintain a 'hidden state' or memory that updates at each time step, allowing them to process sequences of variable length.

Predicting the next word in a sentence (Auto-complete) used to be the primary job of **RNNs** before Transformers.

8. LSTM & GRU (Gating mechanisms)

**Long Short-Term Memory (LSTM)** and **Gated Recurrent Units (GRU)** are advanced RNN architectures designed to solve the long-term dependency problem. They use **Gating Mechanisms** to selectively forget or remember information over long sequences.

Google Translate originally migrated to **LSTMs** to handle long-distance grammatical agreements in translation.

9. Weight Initialization (Xavier, He)

**Weight Initialization** is the strategy for choosing starting values for neural network weights. Proper initialization ensures that the variance of activations and gradients stays stable across layers, preventing signals from disappearing or exploding instantly.