Skip to main content

Cumulative Review

This review mixes foundation material from earlier semesters with the operating-systems and networking work from Semester 5. Answer from memory first. Write short, precise answers. If a question asks for a diagram, draw it.

Target time: 2 sessions of 60-90 minutes.

How To Score Yourself​

  • Solid: correct, specific, and explained without notes
  • Partial: roughly correct but missing a key mechanism, tradeoff, or example
  • Weak: mostly guessed, vague, or dependent on notes

If you score Weak on 6 or more questions, do another review pass before the exam.

Questions​

Foundations and Earlier Semesters​

  1. Explain the difference between an invariant, a precondition, and a postcondition, then give one example from systems code.
  2. Why does asymptotic complexity still matter in systems work where constants are large and hardware details matter?
  3. Compare stack and heap allocation in terms of lifetime, performance characteristics, and failure modes.
  4. Walk through what happens from a C source file to an executable at a high level: preprocessing, compilation, assembly, linking.
  5. Why do pointers make aliasing and mutation reasoning harder in low-level code?
  6. Give one example where a data structure choice changes system behavior, not just algorithm elegance.

Module 1: Processes and Scheduling​

  1. Define process, thread, and context switch in operational terms.
  2. Given one CPU and three jobs with different burst times, explain why SJF minimizes average turnaround time.
  3. Compare response time, turnaround time, throughput, and fairness. Which pairs often conflict?
  4. Explain how round-robin trades responsiveness against overhead.
  5. Describe MLFQ in plain language and say what problem it is trying to solve.
  6. Explain why context switches cost more than saving a few registers.
  7. What changes when scheduling moves from one core to many cores?

Module 2: Memory Management and Virtual Memory​

  1. Why does virtual memory exist? Name at least three things it buys the system.
  2. Split a virtual address into page number and offset for a 4 KiB page system and explain what each part is used for.
  3. Distinguish TLB hit, TLB miss, minor page fault, and major page fault.
  4. Why is OPT useful but not implementable as a real replacement policy?
  5. Explain thrashing and why working-set reasoning matters.
  6. Compare buddy allocation, slab allocation, and user-space allocators such as jemalloc.
  7. Explain copy-on-write and why it makes fork practical.

Module 3: Concurrency and Synchronization​

  1. Why is counter++ not atomic? Write the steps that make it unsafe across threads.
  2. Define mutual exclusion, progress, and bounded waiting. Why is only one of them insufficient?
  3. Compare spinlocks and blocking mutexes. When is each the wrong choice?
  4. Why must a condition-variable wait recheck its predicate in a while loop?
  5. Compare semaphores, mutexes, and monitors by typical use case.
  6. Name the Coffman deadlock conditions and explain one way to break each.
  7. Explain why lock-free does not automatically mean faster.

Module 4: File Systems and I/O​

  1. Distinguish file name, inode, file descriptor, and open-file table entry.
  2. Draw or describe a typical ext-style on-disk layout.
  3. Explain the crash-consistency problem with a small append or rename example.
  4. Compare journaling and copy-on-write file systems as two different recovery strategies.
  5. What does fsync guarantee, and what does it not guarantee?
  6. Why is sequential I/O usually much faster than random I/O?
  7. Compare select, poll, epoll, and io_uring at a decision level.

Module 5: Network Protocols and Sockets​

  1. For one HTTPS request, describe the roles of DNS name, IP address, MAC address, TCP port, TLS, and HTTP.
  2. Compare UDP and TCP using guarantees, costs, and common use cases.
  3. Distinguish TCP flow control from congestion control.
  4. Walk through the TCP three-way handshake and explain the purpose of TIME_WAIT.
  5. Explain CIDR and longest-prefix match using one example subnet.
  6. Compare HTTP/1.1, HTTP/2, and HTTP/3 at a high level.
  7. What does TLS 1.3 establish, and what role does the certificate chain play?
  8. Compare iterative, threaded, forking, and event-driven server architectures.
  9. Name the first three tools you would use to debug "the service is up, but requests hang," and say what each tells you.

Final Synthesis Prompts​

Answer these in full sentences. These are the questions that matter most for next semester.

  1. How do caching and buffering show up in all five modules of this semester?
  2. Where do fairness tradeoffs appear in scheduling, locks, disk/service I/O, and network traffic?
  3. Explain one end-to-end request path from client to server process, through memory, synchronization, file I/O, and back onto the network.
  4. Pick one measurement you ran this semester and explain how it changed your mental model.
  5. Which semester skill is still weakest: scheduling, memory, concurrency, persistence, or networking? What is your repair plan before Semester 6?

Review Standard​

You are ready for the exam when:

  • you can answer most questions without reaching for terminology alone
  • your answers include mechanism, tradeoff, and at least one concrete example
  • you can connect modules instead of treating them as isolated topics
  • your weak spots are narrow, not structural