Senior Game Developer Interview Preparation Guide - FAANG Standards

Brief framing
Visibility culling reduces draw workload by rejecting unseen geometry early. Below I compare techniques, their typical CPU vs GPU cost, when to use them, and how to combine them in a real-time engine.

Frustum culling

• CPU cost: cheap (bounding volume tests per object or batch).
• GPU cost: none until draw.
• Use when: always—first pass to drop objects outside camera view. Works per-object or per-LOD.

Backface culling

• CPU cost: none (GPU rasterization stage or via winding order).
• GPU cost: minimal (hardware discard in triangle setup).
• Use when: for closed meshes to skip triangles facing away—always enabled.

Occlusion culling

• CPU cost: moderate (occluder selection, queries); GPU cost: moderate (occlusion queries or software depth-prepass).
• Use when: scenes with large occluders and high overdraw (indoor/urban). Beneficial when draw count reduction outweighs query overhead.

Portal culling

• CPU cost: moderate (portal graph traversal per frame).
• GPU cost: lower (prunes geometry early).
• Use when: indoor scenes with rooms/doors—deterministic and efficient.

Hierarchical (quad/octrees)

• CPU cost: moderate to low per traversal; scales well for many objects.
• GPU cost: none until draw.
• Use when: large open worlds to cull spatial regions, support range queries and LOD.

Combining in engine (practical pipeline)

1. Hierarchical traversal (octree) -> coarse region rejects.
2. Frustum cull per node/object.
3. Portal cull when inside portal-structured levels.
4. Optional occlusion culling (hardware occlusion queries or Hi-Z) for remaining expensive batches.
5. Submit draws; rely on GPU backface culling during rasterization.
   Tune frequency of occlusion queries, batch small objects, and use async queries to hide CPU/GPU latency.

In the moment, I would stop the blame loop and focus on the shared outcome. I would acknowledge the miss, ask for the facts, and clarify the handoff point that failed. By handoff, I mean the moment one team passes work to another with clear expectations.

I would say something like, "Let's separate what happened from who to blame. What was the requirement, what was the agreed due date, and what did each side believe was done?" If our requirements were unclear, I would own that and propose the next concrete step, such as a revised spec, a quick review, or a smaller interim deliverable so the project does not stall completely.

For the next milestone, I would prevent repeat issues by adding written acceptance criteria, a short handoff checklist, and a scheduled signoff before work starts. For example, if an API needed three required fields and one edge-case behavior, I would list those explicitly in the ticket and get both teams to confirm them before implementation. That lowers ambiguity and makes accountability much easier.

Client‑Server vs Peer‑to‑Peer (brief)
Client‑Server: central authoritative server manages game state; clients send input and receive updates.
P2P: each client communicates directly with others and may share authority/lockstep state.

Pros / Cons — general

• Client‑Server: + authoritative cheat prevention, easier replay/rollback, predictable NAT traversal, easier logging/scaling via server clusters; − higher server bandwidth/costs, single point of failure, potential added latency if server far.
• P2P: + lower server cost, potentially lower latency for geographically close peers, good for small groups; − hard to prevent cheating, NAT traversal (hole punching) fragile, scaling mesh = O(n^2) bandwidth.

By game type & recommendation

1. Real‑time action (FPS, fighting) — Recommendation: Client‑Server
   Reasons: low cheat tolerance requires authoritative server, consistent hit detection, deterministic RTT expectations. Latency sensitivity favors regional servers and client‑side prediction; P2P’s security and NAT issues make it risky.

2. Turn‑based (chess, card games) — Recommendation: P2P or hybrid (lightweight server)
   Reasons: low real‑time demands; P2P reduces server cost and is fine for trustful players. For open/public play, a lightweight authoritative server is better for anti‑cheat and matchmaking.

3. Cooperative co‑op (small party PvE) — Recommendation: Hybrid (hosted peer or dedicated server)
   Reasons: For 2–4 players, a host‑client P2P (one player as host) can minimize cost and latency; but dedicated server improves reliability, anti‑cheat and scaling. Choose host‑migration and rollback to handle host drop; prefer dedicated servers for competitive/coordinated co‑op.

Considerations

• Bandwidth: P2P bandwidth grows O(n^2); client‑server is O(n).
• NAT: Client‑server easiest; P2P requires robust STUN/TURN fallback.
• Security: Client‑server best for authoritative checks.
• Scalability/cost: P2P cheaper but operationally complex; client‑server scales predictably with cloud autoscaling.

As a game developer I'd default to client‑server for any competitive real‑time title; use P2P or hybrid for low‑stakes turn‑based or very small co‑op to save costs.

Direct answer

Owning a miss means surfacing it myself before anyone else has to point it out, naming the actual root cause even when part of it sits outside my direct control, and bringing a concrete corrective plan in the same conversation where I admit the shortfall, not a separate one later. The prevention step afterward is what separates genuinely owning a miss from just apologizing for it.

Structured elaboration

The sequence I follow is the same regardless of what specifically got missed, a deadline, a budget, an adoption number, or a quality bar: catch the shortfall through my own tracking rather than waiting to be told, report it proactively with a first-pass explanation and a plan already attached, then do a real root-cause pass rather than settling for the first explanation that comes to mind. The ownership discipline is specifically in how I frame the cause: I name what was actually within my control to have caught earlier, even if the proximate technical or operational constraint belonged to someone else, instead of routing the story toward whichever team is easiest to point at. From there, the corrective steps need a real revised commitment, not a vague "working on it," and the prevention change afterward has to generalize to the class of mistake, not just patch this one instance.

Worked example

Situation: I owned a quarterly initiative to cut checkout latency, committed to leadership as a 30% reduction in p95 (95th percentile) load time, from 800 milliseconds to 560 milliseconds, by the end of the quarter.

Task: deliver that reduction on the committed date.

Action: I found out we were behind through my own mid-quarter metrics review, three weeks before the deadline, not from anyone flagging it to me. At that point the actual reduction was tracking to about half the committed target. I reported the shortfall to leadership the same week I found it, before being asked, and framed it as my initiative being behind schedule with a first-pass reason and next steps already attached, rather than waiting for a status meeting to surface it. The root-cause work showed that our original estimate hadn't accounted for a downstream payment-gateway call that turned out not to be optimizable the way we'd assumed. The real gap wasn't the gateway team's fault; it was that I hadn't validated during initial scoping whether that call's latency was actually tunable, and I said so directly rather than describing it as a dependency problem. The corrective step was adding a caching layer in front of that gateway call to claw back most of the remaining gap, and I asked leadership for three additional weeks with a specific revised number attached, not an open-ended extension.

Result: at the three-weeks-before-deadline check, checkout latency stood at 680 milliseconds, a 15% reduction, half of the committed 30%. After the additional three weeks of corrective work, it reached 570 milliseconds, roughly a 28.75% reduction, close to the original target though three weeks later than committed. Afterward, I added a mandatory dependency-tunability validation step to the estimation template used for any future latency-reduction initiative, so an unverified assumption about whether a downstream call can actually be optimized gets caught during scoping rather than discovered mid-quarter, and I started doing a formal check-in at the halfway point of every quarterly initiative rather than relying on a single review near the end.

Trade-offs and pitfalls

• Reporting a miss before being asked protects trust, but only if it arrives with a credible root cause and a real corrective plan attached; a proactive admission without a plan is just an earlier apology, not ownership.
• It's tempting to frame the cause around the team whose system couldn't be optimized as expected; the actual ownership move is naming that verifying feasibility with that dependency during scoping was mine to have done, even though the technical constraint itself sat elsewhere.
• Asking for more time only stays honest if the revised number and date are specific; a vague "we'll get there soon" undermines the same trust the proactive disclosure was meant to protect.
• A prevention change that only addresses this exact scenario (this one gateway call) isn't real prevention; the estimation-template change and the halfway check-in both target the general class of problem, an unvalidated dependency assumption and a lagging-trend detected too late, not just this one incident.

Direct answer

Track two rolling values while scanning left to right, the best total achievable ending here-or-earlier if this position is skipped, and the best total if it is taken, then at each position choose max(skip, nums[i] + best_two_positions_back); the "no adjacent picks" constraint is exactly what makes only the last two rolling values matter, giving $O(1)$ extra space. The circular version runs that same linear solution twice, once excluding the last position and once excluding the first, and takes the better of the two, since the wraparound constraint only ever affects whether the first and last positions can coexist. Replacing the hard adjacency ban with a cooldown of K positions is the same recurrence with one number changed: look back K + 1 positions instead of 2 before adding the current value's own contribution.

Structured elaboration

The linear recurrence

Let best[i] be the best achievable total using only the first i positions. At position i (1-indexed), either skip it (best[i-1]) or take it, which forces skipping position i-1 (nums[i-1] + best[i-2], where best[i-2] is treated as 0 if i < 2). Only the last two values of best are ever read, so a rolling pair of variables suffices instead of a full array.

Extending to circular

With the first and last positions now also adjacent, at most one of them can ever be part of an optimal solution together, they can never both be picked. So the answer is the better of two independent linear sub-problems: solve the linear version on positions [0, n-2] (excluding the last), and separately on [1, n-1] (excluding the first), then take the max. Each sub-problem is a small array slice, so the same $O(1)$-space linear solution applies to each.

Generalizing to a cooldown of K positions

The hard "no two adjacent" rule is really "cooldown of 1": picking position i forbids picking position i-1 only. A cooldown of K extends that reach: picking position i forbids picking any of the previous K positions, so taking position i must add to best[i - 1 - K] (treated as 0 if that index is negative) instead of best[i-2]. The skip branch is unchanged. Because the recurrence for a cooldown of K only ever looks back exactly K + 1 steps, a rolling buffer of that fixed size, rather than the full array, again keeps space bounded, this time by K instead of a constant.

This is the same shape as a promotion-scheduling problem with a K-day cooldown: each day has a promotional value, running a promotion on a given day forbids running another one for the next K days, and the goal is to maximize total promotional value over the period, the "no two adjacent picks" DP and the "K-day cooldown" DP are the same recurrence with only the lookback distance changed.

Worked example

Approach

First, the classic linear-and-circular version with the pure two-variable rolling scheme:

def rob_linear(nums):
    prev2 = prev1 = 0
    for v in nums:
        cur = max(prev1, prev2 + v)
        prev2, prev1 = prev1, cur
    return prev1

def rob_circular(nums):
    n = len(nums)
    if n == 0:
        return 0
    if n == 1:
        return nums[0]
    return max(rob_linear(nums[:-1]), rob_linear(nums[1:]))

print(rob_linear([2, 7, 9, 3, 1]))
print(rob_circular([2, 3, 2]))
print(rob_circular([1, 2, 3, 1]))

This prints:

12
3
4

rob_linear([2, 7, 9, 3, 1]) picks positions 0, 2, 4 (2 + 9 + 1 = 12), skipping every adjacent pair. rob_circular([2, 3, 2]) cannot take both position 0 and position 2 (they are adjacent on the circle), so the best is either of them alone or the middle, giving 3. rob_circular([1, 2, 3, 1]) compares excluding the last position (best 4, from positions 0 and 2: 1 + 3) against excluding the first position (best 3, from position 1 alone: 2, or position 2 alone: 3), and returns the larger, 4.

Now the cooldown-of-K generalization, using a rolling buffer sized to the cooldown window instead of a full array:

def rob_cooldown(nums, k):
    n = len(nums)
    if n == 0:
        return 0
    buf_len = k + 2
    buf = [0] * buf_len
    for i in range(1, n + 1):
        prev = buf[(i - 1) % buf_len]
        back_idx = i - 1 - k
        take = nums[i - 1] + (buf[back_idx % buf_len] if back_idx >= 0 else 0)
        buf[i % buf_len] = max(prev, take)
    return buf[n % buf_len]

print(rob_cooldown([2, 7, 9, 3, 1], 1))   # k=1 reduces to the ordinary linear rule
print(rob_cooldown([5, 1, 1, 5], 2))

This prints:

12
10

rob_cooldown([2, 7, 9, 3, 1], 1) matches rob_linear on the same input exactly (12), confirming a cooldown of 1 reduces to the ordinary adjacency ban. rob_cooldown([5, 1, 1, 5], 2) picks positions 0 and 3 (three positions apart, satisfying a cooldown of 2), giving 5 + 5 = 10.

Key points

• The circular case is not a new algorithm, it is two calls to the exact same linear one-dimensional solver on two overlapping slices.
• The cooldown generalization changes exactly one index in the recurrence (i - 2 becomes i - 1 - k); everything else, including the skip branch, stays identical.
• A rolling buffer of size k + 2 (rather than the full array) keeps the cooldown version's space bounded by the cooldown length, not by the input length.

Complexity

rob_linear / rob_circular: $O(n)$ time, $O(1)$ extra space (two rolling variables; the circular version calls the linear one twice on slices, still $O(n)$ total time and $O(1)$ extra space beyond the slices themselves).
rob_cooldown: $O(n)$ time, $O(k)$ extra space (the rolling buffer holds exactly k + 2 slots regardless of n).

Edge cases

• Empty input: all three functions return 0 immediately.
• Single element: rob_linear and rob_cooldown return that element's value directly; rob_circular special-cases n == 1 since excluding "the last" and excluding "the first" would otherwise both empty out the same single-element array.
• k = 0 in the cooldown version: every position becomes independently pickable (no cooldown at all), correctly reducing to "sum of all positive values" in effect, since back_idx = i - 1 always refers to the immediately preceding position's own best, which already includes that position.

Trade-offs & pitfalls

A common mistake in the circular version is trying to patch the linear recurrence in place with a special case for "position 0 and position n-1 both chosen," rather than the cleaner two-independent-subproblems framing, that patched version tends to miss cases where neither endpoint is optimal at all. For the cooldown generalization, forgetting to clamp the back-reference index at zero (treating an out-of-range lookback as 0, not as an error or a wraparound) is the most common bug, especially once the rolling buffer's modular indexing is introduced; validating the rolling-buffer version against a full, non-rolling dp array on the same inputs is a cheap way to catch that class of indexing bug before it ships.

Direct answer

I see ability as something built through effort and specific feedback, not a trait I either have or don't. The practical difference between that and a fixed outlook shows up in the first few seconds after something goes wrong, because that's before there's time to perform the socially correct answer.

Structured elaboration

The contrast is clearest in three recurring situations:

• An experiment or change that doesn't work. A fixed reaction treats the negative result as a verdict on competence and looks for reasons the setup was unfair. A growth reaction treats it as one data point and asks what it rules out.
• A critical review. A fixed reaction defends the original decision, sometimes relitigating context nobody asked for. A growth reaction isolates the single most specific, actionable point raised and changes that one thing next time, even when the feedback stings.
• An unfamiliar tool or an unclear brief. A fixed mindset avoids volunteering, because failing at something new feels riskier to the self-image than staying in safe territory. A growth mindset treats "I don't know this yet" as a normal, temporary state.

What the fixed pattern costs a team: velocity drops because people route around unfamiliar work instead of through it, quality suffers because problems get relitigated instead of fixed, people stop raising issues early because raising one risks being blamed for it, and morale erodes because the same few people end up carrying anything ambiguous.

Worked example

In a design review, a reviewer was blunt about a flaw in an approach I'd already committed time to. My first instinct was defensive: I started explaining the constraints that led me there. I caught myself mid-sentence, asked one specific question instead ("is the concern the failure mode when input is empty, or the overall structure?"), and it turned out to be the narrower issue. I fixed that one thing and confirmed with the reviewer it addressed the concern, rather than reworking everything out of general anxiety.

Being honest about the flip side matters more than the tidy version of this story: I am still more fixed-mindset than I'd like about unscripted public communication, like presenting unfinished work live to a large group. I know it because I over-prepare for it and get visibly rattled if the plan changes mid-presentation, which is exactly the "competence is on trial" reaction I described above, just in a different context.

Trade-offs and pitfalls

A common wrong turn here is giving the scripted, socially correct version of this answer with no concrete instance behind it. What makes it credible is naming an actual moment the reaction was tested, and being willing to name a domain where the fixed pattern still shows up, since nobody is growth-minded everywhere at once.

Direct answer

Treat it as an active transfer project with an owner and a deadline, not passive documentation. Inventory what this person uniquely holds, rank it by risk rather than by how interesting it is to write up, transfer the highest-risk pieces through hands-on shadowing rather than just writing, and verify the transfer actually worked by having the successor perform the task for real while there's still time to catch gaps.

Transfer approach

Inventory and rank by risk, not by volume. List what this person actually holds that nobody else can currently do, then rank by what breaks or stalls if it disappears, not by what's easiest or most interesting to document. A fixed departure date means you can't transfer everything equally; risk ranking tells you where to spend the limited time.

Match the transfer method to the kind of knowledge. Procedural and tacit knowledge, how to actually make a judgment call under pressure, how to run something that doesn't go by the book, transfers best through shadowing and pairing, not documents. Declarative knowledge, why a past decision was made, historical context, transfers fine through writing, since there's no live judgment being exercised.

Verify the transfer actually happened, don't assume it. Have the successor perform the highest-risk task for real, a supervised dry run or an actual live instance, while the departing person is still around to catch what's missing. "They read the doc" is not verification.

Build in redundancy, not just a single successor. Naming one person as the new holder of the knowledge just recreates the same single point of failure with a different name on it.

Sequence by time pressure. The runway is fixed and shrinking, so the highest-risk items go first, even if lower-risk items would be quicker or more satisfying to knock out.

Worked example

Someone with deep knowledge of a specific system announces they're leaving in a few months. You inventory what they uniquely hold and rank it by risk: the thing that would cause the most damage if nobody understood it isn't the thing that's easiest to write a doc about, it's a judgment-heavy process that only they've ever run. You assign a primary and a backup successor rather than just one person. For that highest-risk item, instead of relying on a runbook, you have the successor run it for real under supervision before the departure date. During that supervised run, a real gap surfaces, a step the departing person did automatically and never thought to write down, and it gets caught and fixed while there's still time, instead of surfacing for the first time after they're gone.

Trade-offs and pitfalls

A knowledge-dump documentation sprint feels productive but is rarely sufficient on its own. What the departing person chooses to write down reflects what they consciously think matters, filtered through their own blind spots; the things that are automatic to them are exactly the things they won't think to write down.

Waiting until the final weeks to start is a common and costly mistake. Tacit knowledge transfer through shadowing takes real elapsed time to work, so it needs to front-load into the runway, not compress into the last stretch.

Verifying through a real supervised run costs more time, and carries some real risk, compared to just trusting a document. That cost is worth it, because it's the only way to catch a gap before it becomes expensive, rather than after.

Naming a single successor and calling the transfer complete just recreates the original risk with a new name attached. The goal isn't a new single point of failure; it's genuine redundancy.

Direct answer

A strong pre-interview research plan works from the most authoritative sources outward: company-controlled material first (site, blog, filings), then people-and-code sources (LinkedIn, GitHub), then outside voices (news, reviews), synthesized into a short brief with the one or two findings that would most change your approach flagged as open questions to raise or confirm.

Structured elaboration

What to pull from each source:

• Engineering or product blog: what they're building and what they've recently launched or pivoted away from. Tells you current priorities, not just stated ones.
• LinkedIn: team size and growth trend, who the hiring manager's other reports are, recent hires or departures (a churn signal), and the seniority mix of recent hires.
• GitHub (if they have public repos): commit cadence, open-issue volume and age, contributor count. This is a proxy for engineering health and how much attention a given system gets.
• Public filings (a 10-K or 10-Q, the annual and quarterly financial reports public companies must file with regulators) or funding announcements for a startup: which business segment is growing, headcount trends, and risks the company names about itself.
• Recent news: layoffs, funding rounds, leadership changes, or product launches, which tell you whether the team is likely riding a tailwind or working through a headwind.

Most of what you find is context. Two findings are worth naming explicitly as the ones that would change how you approach the role, because they change what you do, not just what you know:

• The red flag that matters most: departures concentrated in the team you'd join. Not company-wide churn, which usually reflects the market, but several people at your level leaving that one team within a couple of quarters, especially alongside a posting that has been re-listed. That pattern points at the team rather than the industry. It changes your approach from selling yourself to diligence: you'd want the hiring manager's own account of what changed and who left, and you'd weight what individual engineers say about it far above what the recruiter does.
• The positive signal that matters most: recent, specific, public evidence the team ships. A dated engineering post describing a system they actually built and what went wrong, a changelog with real entries rather than "bug fixes," a conference talk by someone still there. Claiming a culture of ownership is free; a public record of shipping is expensive to fake. This one raises how much scope you'd be willing to take on at the stated level, rather than negotiating for a safer, narrower remit.

Two things also matter more than any single source:

1. When sources conflict, don't average them. If LinkedIn shows fast headcount growth but reviews mention understaffing complaints, hold both as live hypotheses and pick the one interview question that would resolve the conflict, rather than quietly picking whichever story you like better.
2. Synthesize into something short you'd actually use. A one-page brief (mission in one line, likely challenges ranked, two or three open questions) beats a folder of tabs you never revisit.

Worked example

Say you're interviewing for a Backend Developer role at a mid-size fintech company. The blog's last three posts are about migrating a monolith to services. LinkedIn shows engineering headcount growing noticeably over the past year, and most recent hires are titled "Senior," none "Staff." Their one public GitHub repo, a customer-facing SDK (software development kit, a packaged set of tools other companies use to integrate with a product), has a large number of open issues, the oldest well over a year old. News shows a funding round closed several months ago.

Reading this together: the funding round is the likely reason the headcount line moved, which makes this growth a funded plan rather than a churn backfill, and senior-heavy hiring during a service migration suggests they need people who can operate with less hand-holding. Those two together are the positive signal, and they're worth saying out loud because they tell you the role is probably real scope rather than a replacement seat. The stale open-source issues on a customer-facing SDK is the actual red flag worth raising, not as a criticism, but as a genuine question: is that repo neglected, or intentionally deprioritized while the team focuses elsewhere? Note it isn't a strong enough flag to change whether you'd take the role, only what you'd ask.

Trade-offs and pitfalls

The most common mistake is treating any single source as ground truth, LinkedIn headcount counts are noisy (they include inactive profiles and contractors), so weight repeated, specific signals over one-off numbers. It also helps to say your assumptions out loud early in the process, whether to the recruiter or the hiring manager, rather than presenting inference as settled fact, since that's what catches a wrong read before it steers your whole set of questions in the wrong direction. A related failure is collecting a fact and then never using it, if the funding round or the layoff never shows up in your reading of the team, it wasn't research, it was browsing. Finally, don't let the research become the performance itself, its job is to sharpen two or three real questions, not to be recited back verbatim.

Approach summary
Decouple game logic from engine subsystems via clean interfaces, inject them into game classes, then unit-test using mocks/fakes that provide deterministic behavior (no engine loop, no real physics). Use dependency injection and controlled time.

Interfaces / abstraction

public interface IPhysics {
  Vector3 Raycast(Vector3 origin, Vector3 dir, float maxDist);
  bool CheckCollision(Collider a, Collider b);
  Vector3 ResolveCollision(GameObject mover, Collider other);
}
public interface IRenderer { void Spawn(string prefab, Vector3 pos); }
public interface ITime { float DeltaTime { get; } float Now { get; } }

Fakes & mocks

• FakePhysics: deterministic responses (pre-set collisions or raycast results).
• MockRenderer: record spawn calls.
• TestTime: advanceable time source with DeltaTime controlled.

class TestTime : ITime { public float Now { get; private set; } public float DeltaTime { get; private set; } 
  public void Advance(float dt){ DeltaTime = dt; Now += dt; } }

Example: movement test

• Inject TestTime and FakePhysics into PlayerController.
• Call UpdateLoop step(s) manually.
• Assert position = start + velocity * dt when no collision.

Collision response test

• Configure FakePhysics to return a collider at predicted position.
• Verify ResolveCollision called and final velocity/position updated correctly.

Respawn/time-dependent behavior

• Use TestTime to advance past death timers; check that MockRenderer.Spawn called at expected Now timestamp.

Determinism & best practices

• Seed RNG in tests or inject IRandom.
• Keep physics math in pure functions for unit tests.
• Use small focused tests: movement, collision resolution, respawn timer, and integration test combining fakes.

Direct answer. Dependency injection gives you compile-time (or construction-time) visibility into what a class depends on and lets a test substitute a fake trivially; the service locator hides dependencies inside a global lookup, so a reader (and a test) can't tell what a class actually needs without reading its full body.

Dependency injection

class OrderService:
    def __init__(self, payment_client, notifier):
        self.payment_client = payment_client
        self.notifier = notifier

Every dependency is visible in the constructor signature. A test constructs OrderService(fake_payment_client, fake_notifier) with zero global state to set up or tear down, and the signature itself documents the class's needs.

Service locator

class OrderService:
    def charge(self, amount):
        payment_client = ServiceLocator.get("payment_client")  # dependency is hidden
        payment_client.charge(amount)

A reader has to open the METHOD BODY (not just the constructor) to discover this class needs a payment client at all, and a test has to configure the global locator before running, then remember to reset it afterward or risk leaking state into the next test.

What you gain and lose with each

• Testability: DI wins clearly -- dependencies are explicit and swappable per-test with no shared global state. Service locator tests are more fragile (order-dependent, need setup/teardown discipline) because the locator itself is global mutable state.
• Discoverability: DI wins -- you can tell a class's dependencies from its constructor without reading every method. Service locator dependencies are invisible until you trace every call site that hits the locator.
• Runtime cost: essentially a wash for typical DI (constructor injection is just normal object construction); a poorly implemented service locator that does string-keyed lookups on every call adds a small runtime cost DI avoids, though a well-cached locator narrows this gap.
• Convenience for deep call chains: service locator can look more convenient when a dependency is needed 10 layers deep and you don't want to thread it through every intermediate constructor ('parameter drilling') -- but that's usually a signal the layering itself needs rethinking, not a case for hiding the dependency.

Default recommendation

Default to constructor-based DI for new code; it makes the dependency graph an explicit, reviewable part of the design and keeps tests simple and isolated. Reach for a locator (or a DI container that resolves dependencies FOR you, which is a more disciplined middle ground) mainly in frameworks/plugin systems where the set of implementations is genuinely dynamic and not known at construction time.

Trade-offs and pitfalls

• A DI container (Spring, Guice, etc.) can itself become a soft service locator if code reaches into the container directly at arbitrary points rather than only at composition roots -- the discipline that matters is WHERE resolution happens, not just which mechanism you use.
• Excessive constructor parameters from over-injecting is itself a smell (see the parameter-object survivor) -- if a class needs eight injected dependencies, that's often a sign it has too many responsibilities.