Computer Science Fundamentals

# Process example (Python)
from multiprocessing import Process

def cpu_intensive_task(n):
    return sum(i * i for i in range(n))

# Creates separate memory space
p = Process(target=cpu_intensive_task, args=(10000000,))
p.start()
p.join()

# Thread example
from threading import Thread

def io_bound_task(url):
    response = requests.get(url)
    return response.text

# Shares memory with main thread
t = Thread(target=io_bound_task, args=("https://api.example.com",))
t.start()
t.join()

┌─────────────────────────────────────┐
│           Virtual Memory            │
├─────────────────────────────────────┤
│  Stack (grows down)                 │
│    ↓  Local variables, function    │
│       calls, return addresses       │
│  ... (free space) ...               │
│    ↑  Dynamically allocated        │
│       memory (malloc, new)          │
│  Heap (grows up)                    │
├─────────────────────────────────────┤
│  BSS (uninitialized data)           │
│    Global/static vars (zero-init)   │
├─────────────────────────────────────┤
│  Data (initialized data)            │
│    Global/static vars with values   │
├─────────────────────────────────────┤
│  Text (code)                        │
│    Executable instructions          │
└─────────────────────────────────────┘

// Stack allocation - fast, automatic cleanup
void stackExample() {
    int x = 10;           // Stack
    int arr[100];         // Stack (fixed size)
}  // Memory freed when function returns

// Heap allocation - flexible, manual cleanup
void heapExample() {
    int* ptr = malloc(sizeof(int) * 1000);  // Heap
    // ... use ptr ...
    free(ptr);  // Must manually free!
}

# Deadlock example
import threading

lock_a = threading.Lock()
lock_b = threading.Lock()

def thread_1():
    lock_a.acquire()
    time.sleep(0.1)  # Increases chance of deadlock
    lock_b.acquire()  # Waits forever if thread_2 has lock_b
    # ...
    
def thread_2():
    lock_b.acquire()
    time.sleep(0.1)
    lock_a.acquire()  # Waits forever if thread_1 has lock_a
    # ...

# Prevention: Always acquire locks in same order
def thread_safe():
    lock_a.acquire()  # Always acquire A first
    lock_b.acquire()  # Then B
    # ...
    lock_b.release()
    lock_a.release()

# Race condition example
counter = 0

def increment():
    global counter
    for _ in range(100000):
        counter += 1  # NOT atomic! Read-modify-write

# Two threads, expected: 200000, actual: random lower number

# Fix with Lock
lock = threading.Lock()

def safe_increment():
    global counter
    for _ in range(100000):
        with lock:
            counter += 1  # Now atomic

Layer 7: Application  (HTTP, FTP, DNS, SMTP)
        └── What the user interacts with
        
Layer 4: Transport    (TCP, UDP)
        └── End-to-end communication, ports
        
Layer 3: Network      (IP, ICMP, Routing)
        └── Logical addressing, routing between networks
        
Layer 2: Data Link    (Ethernet, MAC, Switches)
        └── Physical addressing, frame transmission
        
Layer 1: Physical     (Cables, Signals, Hubs)
        └── Raw bit transmission

Client                    Server
  │                         │
  │───── SYN (seq=x) ──────►│  1. Client initiates
  │                         │
  │◄── SYN-ACK (seq=y,      │  2. Server acknowledges
  │     ack=x+1) ───────────│     and sends its own SYN
  │                         │
  │───── ACK (ack=y+1) ────►│  3. Client acknowledges
  │                         │
  │◄═══ Connection ════════►│  4. Ready to transfer data

1. Browser Cache      → Check local browser cache
2. OS Cache           → Check operating system DNS cache
3. Resolver Cache     → ISP's recursive resolver cache
4. Root Server        → "Who handles .com?"
5. TLD Server         → "Who handles example.com?"
6. Authoritative NS   → "example.com = 93.184.216.34"

# Trace DNS resolution
nslookup example.com
dig example.com +trace

# Common HTTP Methods
GET     # Retrieve resource (idempotent, cacheable)
POST    # Create resource (not idempotent)
PUT     # Update/Replace resource (idempotent)
PATCH   # Partial update (not necessarily idempotent)
DELETE  # Remove resource (idempotent)
HEAD    # GET without body (check if resource exists)
OPTIONS # Supported methods (CORS preflight)

# Status Code Categories
1xx  # Informational (100 Continue)
2xx  # Success (200 OK, 201 Created, 204 No Content)
3xx  # Redirection (301 Moved Permanently, 302 Found, 304 Not Modified)
4xx  # Client Error (400 Bad Request, 401 Unauthorized, 403 Forbidden, 404 Not Found, 429 Too Many Requests)
5xx  # Server Error (500 Internal, 502 Bad Gateway, 503 Service Unavailable, 504 Gateway Timeout)

HTTP: Request-Response (Half-duplex)
Client ───Request──► Server
Client ◄──Response── Server
Client ───Request──► Server
Client ◄──Response── Server

WebSocket: Full-duplex, persistent connection
Client ◄═════════════► Server
       │ Real-time    │
       │ bidirectional│
       │ messages     │

-- Set isolation level
SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;

BEGIN TRANSACTION;
-- Your queries here
COMMIT;

-- B-Tree Index (default for most DBs)
-- Good for: range queries, sorting, equality, prefix matching
CREATE INDEX idx_user_email ON users(email);

-- Hash Index
-- Good for: equality comparisons ONLY (not range queries)
CREATE INDEX idx_user_id ON users USING HASH(id);

-- Composite Index (order matters!)
-- Follows "leftmost prefix" rule
CREATE INDEX idx_orders ON orders(user_id, status, created_at);
-- ✅ Uses index: WHERE user_id = 1
-- ✅ Uses index: WHERE user_id = 1 AND status = 'pending'
-- ✅ Uses index: WHERE user_id = 1 AND status = 'pending' AND created_at > '2024-01-01'
-- ❌ Skips index: WHERE status = 'pending' (missing leftmost column)
-- ❌ Skips index: WHERE user_id = 1 AND created_at > '2024-01-01' (gap in middle)

-- Covering Index (includes all needed columns)
CREATE INDEX idx_users_covering ON users(email) INCLUDE (name, created_at);
-- Query can be answered entirely from index, no table lookup needed

-- Partial Index (index subset of rows)
CREATE INDEX idx_active_users ON users(email) WHERE status = 'active';

-- Denormalized (violation of 1NF)
CREATE TABLE orders (
    id INT,
    products VARCHAR(255)  -- "laptop,mouse,keyboard"
);

-- Normalized
CREATE TABLE orders (id INT PRIMARY KEY);
CREATE TABLE order_items (
    order_id INT REFERENCES orders(id),
    product_id INT REFERENCES products(id),
    quantity INT
);

┌─────────────────────────────────────────────┐
│                   CPU                       │
│  ┌─────────────────────────────────────┐   │
│  │           Core                      │   │
│  │  ┌─────────────────────────────┐   │   │
│  │  │   L1 Cache (32-64KB)       │   │   │  ~1ns
│  │  │   Fastest, per-core        │   │   │
│  │  └─────────────────────────────┘   │   │
│  │  ┌─────────────────────────────┐   │   │
│  │  │   L2 Cache (256KB-1MB)     │   │   │  ~3-10ns
│  │  │   Per-core                 │   │   │
│  │  └─────────────────────────────┘   │   │
│  └─────────────────────────────────────┘   │
│  ┌─────────────────────────────────────┐   │
│  │   L3 Cache (8-64MB)                │   │  ~10-40ns
│  │   Shared across cores              │   │
│  └─────────────────────────────────────┘   │
└─────────────────────────────────────────────┘
┌─────────────────────────────────────────────┐
│   RAM (8-128GB+)                           │  ~100ns
└─────────────────────────────────────────────┘
┌─────────────────────────────────────────────┐
│   SSD (~1TB)                               │  ~100μs
└─────────────────────────────────────────────┘
┌─────────────────────────────────────────────┐
│   HDD (~10TB)                              │  ~10ms
└─────────────────────────────────────────────┘

         Consistency
            /\
           /  \
          /    \
         /  CA  \
        /________\
       /\        /\
      /  \  CP  /  \
     / AP \    /    \
    /______\  /______\
Availability  Partition
              Tolerance