Heap vs Stack Memory, Threads vs Processes, and Semaphores vs Mutexes

This phone screen opens with three rapid-fire operating-systems fundamentals questions before any coding. Answer each one as you would in the interview: explain the difference precisely, give a concrete example, and say when the distinction matters in practice. ### Clarifying Questions - Should the answers be language-neutral, or grounded in a specific runtime (for example C++, Java, or Python), where memory and threading details differ? - Is a short verbal explanation expected, or should you also sketch code for the synchronization question? ### Part 1 — Heap memory vs stack memory Explain the difference between heap memory and stack memory. ```hint Follow a variable's lifetime Think about who decides when a piece of memory is released, and what that implies about how it can be allocated. ``` #### What This Part Should Cover - Allocation and release mechanics, and object lifetime - Size limits, speed, and which threads can see each region - Typical failure modes of each ### Part 2 — Threads vs processes Explain the difference between threads and processes. ```hint Ask what is shared List what two threads of one program share that two separately running programs do not. ``` #### What This Part Should Cover - Address space and resource sharing - The cost of creation and context switches, and how each communicates - Isolation and failure containment, and when to choose each ### Part 3 — Semaphore vs mutex Explain the difference between a semaphore and a mutex. ```hint Think about what is being protected Picture a single shared data structure, then a pool of identical resources. Which primitive fits each picture naturally, and why? ``` #### What This Part Should Cover - Exclusive versus counted access, and the question of ownership - A typical use case for each - Hazards such as deadlock, priority inversion, and lost signals ### What a Strong Answer Covers - Precise, correct definitions rather than analogies alone - A concrete example for each pair - Practical consequences for performance, safety, and debugging - Correct terminology, with caveats where languages or operating systems differ ### Follow-up Questions - Why can deep recursion crash a program even when plenty of heap memory is free, and how do you fix it? - In a runtime with a global interpreter lock, when would you use threads and when processes? - How would you build a mutex from a semaphore, and which property of a real mutex would your version lack? - What happens to a mutex held by a thread that exits or crashes without unlocking it?