Jump Trading Software Engineer Phone Screen Questions

Jump Trading Quant Dev Interview Experience A debugging question, a somewhat strange one. See the screenshot. There are 12 test cases in total. Good luck and lots of points!!!!!!!!!!!!!!! Consider a w

## Problem A set of conceptual questions covering networking and operating systems fundamentals, as asked in onsite and phone screens. **Networking:** - Walk through the full lifecycle of an HTTP request from typing a URL to receiving HTML. Name every protocol involved. - What happens during a TCP 3-way handshake? What state is the server socket in before and after? - Explain the difference between TCP and UDP. When would you choose UDP for a production system? - What is a TIME_WAIT state and why does it exist? How can it cause port exhaustion? **Operating Systems:** - What is the difference between a process and a thread? What is shared vs isolated between threads in the same process? - Describe virtual memory. Why can two processes both "have" address 0x1000 without conflicting? - What is a context switch, what triggers it, and what does the OS save/restore? - Explain the difference between a mutex and a semaphore. Give a scenario where each is the right choice. ## Follow-ups 1. If `ping` succeeds but HTTP fails to the same host, what are the possible causes? 2. You have a program that runs fine single-threaded but crashes intermittently with multiple threads. What tools and techniques do you use to diagnose it? 3. Explain copy-on-write (COW) in the context of `fork()`. Why is it an optimization? 4. What is a page fault, and when is it a problem vs expected behavior?

## Problem Implement a symbol tracker for a simple programming language. Given a list of events (declarations and usages), answer queries about symbol visibility and usage. Events: `DECLARE(scope, name, type)`, `USE(scope, name)`, `ENTER_SCOPE(scope_id)`, `EXIT_SCOPE(scope_id)`. Scopes are nested; inner scopes can see outer scope symbols. A symbol declared in an inner scope shadows an outer one. ```python class SymbolTracker: def declare(self, scope: str, name: str, sym_type: str) -> None: ... def use(self, scope: str, name: str) -> str | None: """Return type of visible symbol, or None if undeclared.""" ... def get_unused_symbols(self) -> list[str]: """Return names declared but never used.""" ... def get_shadowed_symbols(self) -> list[str]: """Return names that shadow an outer declaration.""" ... ``` ``` ENTER outer DECLARE outer x int ENTER inner DECLARE inner x str <- shadows outer x USE inner x -> "str" EXIT inner USE outer x -> "int" get_shadowed_symbols() -> ["x"] ``` ## Follow-ups 1. How do you implement scope lookup (walk up the scope chain)? What data structure represents the chain? 2. What if a symbol can be declared after it's used in the same scope (hoisting, like JS `var`)? How does this change your tracker? 3. How would you extend this to report the exact file/line of each declaration and usage? 4. Describe how a real compiler's symbol table differs from your implementation.