Cumulative Review (Semesters 0-7)

This review mixes earlier CS and systems work with Semester 7 architecture work. Run it closed-book first, then grade against your notes, modules, and project artifacts.

Target time: 2-3 hours across one or two sittings.

---

Instructions

1. Answer every prompt without materials.
2. Mark each answer solid, partial, or missed.
3. Revisit the exact semester or module tied to each miss.
4. Update your mistake journal with patterns, not just facts.

You are not aiming for trivia recall. You are checking whether earlier foundations are still usable while doing architecture work.

---

Review Questions

Foundations and Algorithms

1. State the difference between an invariant and a postcondition. Why does that distinction matter when you design an aggregate in Semester 7?
2. Give the time and space tradeoffs between an array, linked list, hash table, and balanced tree for a read-heavy workload.
3. Explain why asymptotic complexity alone is not enough to choose a design in production systems.
4. Describe one graph problem where breadth-first search is the right default and one where Dijkstra's algorithm is required.
5. What is amortized analysis, and where does it show up in real infrastructure or API design?
6. Name one algorithmic optimization that would hurt readability or modifiability enough that you would reject it in an ordinary business service.

Programming and Systems Foundations

7. What is the difference between stack and heap allocation, and why does that still matter even if your primary language is managed?
8. Explain the difference between latency and throughput with one architecture example where improving one harms the other.
9. What is undefined behavior, and why does the concept matter when choosing implementation languages for critical subsystems?
10. Describe what happens during a cache miss and one design implication this has for data-intensive services.
11. Why can a "simple" local function call become a risky architectural boundary once it crosses a process or network hop?
12. Name one debugging or profiling technique from systems work that still helps during architecture reviews.

Operating Systems and Networking

13. Compare a thread, a process, and an async task in terms of isolation, scheduling, and failure impact.
14. Explain the difference between concurrency and parallelism, and name one architecture mistake caused by confusing them.
15. What does backpressure mean in a networked system, and where would you expect to model it in an event-driven design?
16. Describe the TCP reliability model and one case where application-level retries can still produce incorrect outcomes.
17. Why do timeouts, retries, and idempotency have to be designed together?
18. Name two observability signals you need before claiming an asynchronous workflow is reliable.

Databases and Distributed Systems

19. Compare ACID transactions with eventual consistency. When is each the more responsible default?
20. Explain the CAP framing without oversimplifying it into a slogan.
21. What is replication lag, and how can it distort a support-facing read model?
22. Describe the outbox pattern and why it matters for service or event-driven boundaries.
23. What problem does a Phi-Accrual failure detector solve, and what is it still unable to guarantee?
24. Give one example where a distributed lock is the wrong fix for a boundary problem.

Semester 7: Architecture Fundamentals

25. Define architecture as used in this semester. What makes a decision architectural instead of merely local design?
26. Write one measurable quality-attribute scenario for performance and one for modifiability.
27. Name three architectural characteristics that often conflict and explain one concrete tradeoff among them.
28. What is a fitness function in architecture, and what is one thing it should never be mistaken for?

Semester 7: Patterns, DDD, APIs, and ADRs

29. Compare layered architecture, modular monolith, service-based architecture, and microservices in one sentence each.
30. When does a modular monolith become the stronger default than microservices?
31. Define bounded context and explain how it differs from a team boundary or a database schema.
32. What is the difference between an entity, a value object, and an aggregate?
33. When would you place an anticorruption layer between two contexts?
34. Classify the following as additive or breaking: adding an optional response field, renaming a field, tightening an enum, changing pagination semantics.
35. When is POST /orders/{id}:cancel a better API shape than trying to model cancellation as pure CRUD?
36. Compare REST, gRPC, GraphQL, and event-driven integration for one internal system and one public platform API.
37. What are the three irreducible sections of an ADR, and what breaks when one is missing?
38. When should a decision be treated as one-way versus two-way, and how should that change review depth?

Synthesis

39. A checkout system needs fast iteration, moderate scale, strict payment correctness, and support-friendly visibility. Sketch the top-level architecture direction you would start with.
40. For that same system, name the first bounded contexts you would expect and one risky edge between them.
41. Name the first API contract you would stabilize and the consumer promise you would make explicit.
42. Write one ADR title you would expect early in the project and the alternatives it should evaluate.
43. Name one architectural claim from your current or recent work that should be turned into a fitness function.
44. Name one place where earlier CS knowledge directly improved a better architecture decision.
45. Name one place where architecture language can hide weak reasoning, and how you will guard against that.

---

Self-Grading Key

Use this key after your closed-book attempt.

Score	Meaning	Action
solid	Correct, specific, and defensible without notes	Keep moving
partial	Directionally right, but vague or missing tradeoffs	Revisit the exact concept and rewrite
missed	Incorrect, hand-wavy, or dependent on buzzwords	Re-study the source module and produce one new artifact

---

Recovery Plan

If you miss more than five questions:

• revisit Module 1 and Module 2 first if the misses are mostly architecture-style and tradeoff related
• revisit Module 3 if the misses are mostly boundary, language, or aggregate related
• revisit Module 4 if the misses are mostly contract or compatibility related
• revisit Module 5 if the misses are mostly ADR, review, or governance related
• revisit Semester 6 if the misses are actually consistency, replication, or failure-handling problems disguised as architecture misses

---

Reflection

• Questions marked missed:
• Most repeated weakness:
• Artifact I will rewrite next:
• One earlier semester I need to revisit: