Test Yourself — The Whole Module
Around fifty scenario-based questions across everything the module covers: OO fundamentals and SOLID, all three GoF pattern families, clean code, and architecture through microservices. Every question describes a real situation and asks you to choose the principle or pattern that fits — the way you'll actually meet these ideas at work. The explanations don't just say which answer is right; they say why the tempting wrong answer fails, because that's where real understanding lives.
1. Answer before you click. Commit to a choice out loud or in your head first — clicking to "see what happens" teaches nothing. 2. Re-derive why the wrong options fail. For every question there is a distractor designed to be tempting; if you can't articulate why it's wrong, you don't yet own the distinction. 3. When you miss one, open the linked chapter before moving on. Difficulty ramps up within each section, so a wobble late in a section is normal — slow down there.
Several questions have more than one defensible answer; you're picking the best fit for the stated problem. The explanation always spells out why the runner-up is a weaker fit. That judgement — "these both work, but this one fits this problem" — is the skill being tested.
Foundations & SOLID
Objects, relationships, and the five SOLID principles. If you can name the principle a piece of code violates, you can justify almost every pattern that follows.
Creational patterns
How objects get made without hard-wiring concrete classes into the code that uses them.
Structural patterns
How objects and classes are composed into larger, flexible structures. Watch the wrapper family closely.
Behavioral patterns
How responsibilities and communication flow between objects at runtime.
Clean code
Design happens in every line, not just the class diagram. Naming, function size, comments, and tests.
Architecture & Microservices
Zooming out from classes to whole systems: tiers, MVC, messaging, SOA, and the microservices trade-offs.
Grand mixed round
The final ten mix principles, patterns, and architecture inside a single scenario — the way real design decisions actually arrive. Slow down; each one has a tempting near-miss.
Missed questions cluster by section for a reason. If Structural or Behavioral tripped you, the distinctions live in Chapter 12 — Confusable Patterns; if a SOLID question stung, re-read Chapter 2. The goal isn't a score — it's being able to say, for any real scenario, "this principle, this pattern, and here's the change request that would break the naive alternative." When you can do that unprompted, you've mastered the module.