Object-oriented design rounds where you produce classes, interfaces, and interactions rather than infrastructure boxes and arrows.
12 published across 7 topics.
Low-level design fundamentals60 short answers on one page, for revising rather than studying.Encapsulation, inheritance versus composition, polymorphism, and where each genuinely applies.
Encapsulation earns its place when a class owns an invariant that callers would otherwise each have to enforce, and polymorphism when a conditional grows with every new requirement. Composition versus inheritance is decided on evidence: how many axes vary, and whether every inherited operation is honest.
The five principles with realistic violations and refactorings, plus cohesion and coupling reasoning.
High-level policy should not depend on low-level detail; both should depend on an abstraction. What inverts is ownership of the interface - it belongs to the module that consumes it, not to the one that implements it, which is what reverses the direction of the source dependency.
A class violates SRP when it has more than one reason to change, not when it has more than one method; the refactor is to split along the axes that have independently churned, such as pricing rules, persistence, and presentation, and to stop splitting once each piece has its own requester.
Factory, builder, singleton, and prototype, including when each is over-engineering.
A constructor is the default and needs no justification. A static factory earns its place when construction can return a cached or alternative implementation, or needs a name; a builder when there are many optional fields. Singleton is usually a testability liability.
The mechanics are easy - an enum in Java, a module-level value elsewhere - and are not the interesting part. The objection is that a singleton bundles two unrelated decisions, one instance and globally reachable, and the second is what makes dependencies invisible and tests order-dependent.
Adapter, decorator, facade, proxy, and composite as answers to concrete design pressures.
Adapter converts a type you do not own into the interface your code already speaks. Decorator adds behaviour while keeping the same interface, so wrappers stack. Facade gives callers one narrow entry point into a subsystem. Each becomes over-engineering the moment nothing on the other side varies.
Strategy, observer, state, command, and template method in interview-sized problems.
Observer decouples a subject from things that react to it, which is right when the subject genuinely should not know its listeners. The costs are a control flow you cannot read from the code, listener lifetimes that leak, and an exception in one observer that silently prevents the rest from running.
Use strategy when behaviour varies along an axis separate from what the object is. Composition lets two axes combine without one subclass per pair, lets the behaviour be swapped at runtime, and lets the algorithm be tested without constructing its host.
Thread-safe components, lock granularity, and immutable-object strategies.
State a policy per field: confined, immutable, or guarded by a named lock. Make the state that readers see immutable and swap it atomically; give each independent invariant its own lock. Method-level synchronisation fails because atomic operations do not compose into atomic sequences.
The bound is the design, not a detail: it is what applies backpressure to the producer instead of letting an unbounded queue absorb an overload until the process dies. Deciding what a full buffer does to the producer - block, drop, or reject - is the decision that determines how the system fails.
Parking lot, elevator, vending machine, Splitwise, and other timed build-it problems.
Scope it in the first five minutes to one deterministic flow of park, unpark and charge, model Vehicle, Slot, Level, Ticket and a ParkingLot facade, then push slot allocation and pricing behind strategy interfaces so the variants asked at review time are configuration rather than surgery.
A fixed window is three lines and lets a client send 2N requests across a window boundary. A token bucket fixes that, needs no per-request history, and stores two numbers per client - but only if you compute refill lazily from a timestamp rather than running a background thread.