Mentor

Let's build up to recursion step by step.

Think of it like Russian nesting dolls. You open a doll, and inside there's a smaller doll. You open that one, and there's an even smaller doll. You keep going until you find the tiniest doll that doesn't open — that's your base case.

The two rules of recursion:

1. Base case — when to stop (the smallest doll)
2. Recursive case — break the problem into a smaller version of itself

Simple example — counting down:

function countdown(n) {
  if (n === 0) return;  // base case: stop at 0
  print(n);             // do something
  countdown(n - 1);     // recursive case: smaller problem
}

countdown(3) does this:

• countdown(3): prints 3, calls countdown(2)
• countdown(2): prints 2, calls countdown(1)
• countdown(1): prints 1, calls countdown(0)
• countdown(0): hits base case, stops

Why it's useful: Some problems are naturally recursive — tree traversal, factorial, Fibonacci, file system navigation. The code mirrors the problem structure.

Common mistake: Forgetting the base case. Without it, the function calls itself forever and crashes (stack overflow).

Want to try writing a recursive function for factorial? I'll guide you through it.

Great question. The core difference is reliability vs speed.

TCP (Transmission Control Protocol):

• Establishes a connection before sending data (3-way handshake)
• Guarantees delivery — if a packet is lost, it retransmits
• Guarantees order — packets arrive in the sequence they were sent
• Slower because of all these guarantees
• Think of it as: sending a registered letter — you know it arrived

UDP (User Datagram Protocol):

• No connection setup — just fire and forget
• No delivery guarantee — packets can be lost
• No order guarantee — packets might arrive out of order
• Much faster because there's no overhead
• Think of it as: shouting across a room — fast but you might miss words

When to use TCP:

• Web browsing (HTTP/HTTPS)
• Email
• File transfers
• Anything where losing data is unacceptable

When to use UDP:

• Video calls and live streaming (a dropped frame is better than a delayed one)
• Online gaming (you need the latest position, old positions don't matter)
• DNS lookups (small, fast queries)
• IoT sensor data (high volume, occasional loss is fine)

The rule of thumb: If you need every byte to arrive correctly, use TCP. If you need speed and can tolerate some loss, use UDP.

Want to dive deeper into how the TCP handshake works?